public virtual bool ValidateImports(ModuleImportDescriptor descriptor)
{
foreach (MethodImportDescriptor method in descriptor.Imports)
{
if (!_methods.ContainsKey(HashMethod(method.Name, method.Signature)))
{
return(false);
}
}
return(true);
}
public bool ValidateImports(ModuleImportDescriptor descriptor)
{
foreach (MethodImportDescriptor method in descriptor.Imports)
{
if (Exports.FirstOrDefault(lnk => lnk.Signature == method.Signature && lnk.Name == method.Name) == null)
{
return(false);
}
}
return(true);
}
IModule GetModule(string path, ModuleImportDescriptor descriptor)
{
IModule result;
if (!_loadedModules.TryGetValue(path, out result))
{
ObjectFile obj = ObjectFile.FromFile(path);
if (obj == null)
{
return(null);
}
result = Module.FromObjectFile(this, obj);
_loadedModules[path] = result;
}
if (!result.ValidateImports(descriptor))
{
return(null);
}
return(result);
}
void ExecuteInstruction()
{
switch (_currentInstruction.Opcode)
{
case Op.addb:
{
byte src = ReadSourceAsByte();
byte middle = ReadMiddleAsByte();
WriteDestinationAsByte((byte)((src + middle) & 0xff));
break;
}
case Op.addc:
{
DisString src = ReadSourceAsObject <DisString> () ?? DisString.Empty;
DisString middle = ReadMiddleAsObject <DisString> () ?? DisString.Empty;
DisString result = new DisString(middle.NativeValue + src.NativeValue);
WriteDestinationAsObject(result);
break;
}
case Op.addf:
{
double src = ReadSourceAsFloat();
double middle = ReadMiddleAsFloat();
WriteDestinationAsFloat(src + middle);
break;
}
case Op.addl:
{
long src = ReadSourceAsInt64();
long middle = ReadMiddleAsInt64();
WriteDestinationAsInt64(src + middle);
break;
}
case Op.addw:
{
int src = ReadSourceAsInt32();
int middle = ReadMiddleAsInt32();
WriteDestinationAsInt32(src + middle);
break;
}
case Op.alt:
break;
case Op.andb:
WriteDestinationAsByte((byte)((ReadSourceAsByte() & ReadMiddleAsByte()) & 0xff));
break;
case Op.andl:
WriteDestinationAsInt64(ReadSourceAsInt64() & ReadMiddleAsInt64());
break;
case Op.andw:
WriteDestinationAsInt32(ReadSourceAsInt32() & ReadMiddleAsInt32());
break;
case Op.beqb:
{
if (ReadSourceAsByte() == ReadMiddleAsByte())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.beqc:
break;
case Op.beqf:
{
if (ReadSourceAsFloat() == ReadMiddleAsFloat())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.beql:
{
if (ReadSourceAsInt64() == ReadMiddleAsInt64())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.beqw:
{
if (ReadSourceAsInt32() == ReadMiddleAsInt32())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bgeb:
{
if (ReadSourceAsByte() >= ReadMiddleAsByte())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bgec:
break;
case Op.bgef:
{
if (ReadSourceAsFloat() >= ReadMiddleAsFloat())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bgel:
{
if (ReadSourceAsInt64() >= ReadMiddleAsInt64())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bgew:
{
if (ReadSourceAsInt32() >= ReadMiddleAsInt32())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bgtb:
{
if (ReadSourceAsByte() > ReadMiddleAsByte())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bgtc:
break;
case Op.bgtf:
{
if (ReadSourceAsFloat() > ReadMiddleAsFloat())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bgtl:
{
if (ReadSourceAsInt64() > ReadMiddleAsInt64())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bgtw:
{
if (ReadSourceAsInt32() > ReadMiddleAsInt32())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bleb:
{
if (ReadSourceAsByte() <= ReadMiddleAsByte())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.blec:
break;
case Op.blef:
{
if (ReadSourceAsFloat() <= ReadMiddleAsFloat())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.blel:
{
if (ReadSourceAsInt64() <= ReadMiddleAsInt64())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.blew:
{
if (ReadSourceAsInt32() <= ReadMiddleAsInt32())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bltb:
{
if (ReadSourceAsByte() < ReadMiddleAsByte())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bltc:
break;
case Op.bltf:
{
if (ReadSourceAsFloat() < ReadMiddleAsFloat())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bltl:
{
if (ReadSourceAsInt64() < ReadMiddleAsInt64())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bltw:
{
if (ReadSourceAsInt32() < ReadMiddleAsInt32())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bneb:
{
if (ReadSourceAsByte() != ReadMiddleAsByte())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bnec:
break;
case Op.bnef:
{
if (ReadSourceAsFloat() != ReadMiddleAsFloat())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bnel:
{
if (ReadSourceAsInt64() != ReadMiddleAsInt64())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.bnew:
{
if (ReadSourceAsInt32() != ReadMiddleAsInt32())
{
_currentThread.PC = ReadDestinationAsInt32();
}
break;
}
case Op.call:
{
int currentSize = _frames.Peek().Size;
PushCallFrame(new IntPtr(ReadSourceAsInt32()));
_currentThread.PC = ReadDestinationAsInt32();
int frame = PointerToCurrentFrame().ToInt32();
FP = ReadSourceAsInt32() - frame;
break;
}
case Op.@case:
break;
case Op.casec:
break;
case Op.consb:
break;
case Op.consf:
break;
case Op.consl:
break;
case Op.consm:
break;
case Op.consmp:
break;
case Op.consp:
break;
case Op.consw:
break;
case Op.cvtac:
{
DisByteArray array = ReadSourceAsObject <DisByteArray> ();
WriteDestinationAsObject(new DisString(array.InnerArray));
break;
}
case Op.cvtbw:
WriteDestinationAsInt32(ReadSourceAsByte());
break;
case Op.cvtca:
{
DisString str = ReadSourceAsObject <DisString> ();
WriteDestinationAsObject(new DisByteArray(str.Bytes));
break;
}
case Op.cvtcf:
{
DisString str = ReadSourceAsObject <DisString> ();
WriteDestinationAsFloat(Double.Parse(str.NativeValue));
break;
}
case Op.cvtcl:
{
DisString str = ReadSourceAsObject <DisString> ();
WriteDestinationAsInt64(Int64.Parse(str.NativeValue));
break;
}
case Op.cvtcw:
{
DisString str = ReadSourceAsObject <DisString> ();
WriteDestinationAsInt32(Int32.Parse(str.NativeValue));
break;
}
case Op.cvtfc:
WriteDestinationAsObject(new DisString(ReadSourceAsFloat().ToString()));
break;
case Op.cvtfl:
WriteDestinationAsInt64((Int64)ReadSourceAsFloat());
break;
case Op.cvtfr:
WriteDestinationAsSingle((Single)ReadSourceAsFloat());
break;
case Op.cvtfw:
WriteDestinationAsInt32((Int32)ReadSourceAsFloat());
break;
case Op.cvtlc:
WriteDestinationAsObject(new DisString(ReadSourceAsFloat().ToString()));
break;
case Op.cvtlf:
WriteDestinationAsFloat(ReadSourceAsInt64());
break;
case Op.cvtlw:
WriteDestinationAsInt32((int)ReadSourceAsInt64());
break;
case Op.cvtrf:
WriteDestinationAsFloat((Double)ReadSourceAsSingle());
break;
case Op.cvtsw:
WriteDestinationAsInt32((Int32)ReadSourceAsInt16());
break;
case Op.cvtwb:
WriteDestinationAsByte((byte)ReadSourceAsInt32());
break;
case Op.cvtwc:
WriteDestinationAsObject(new DisString(ReadSourceAsInt32().ToString()));
break;
case Op.cvtwf:
WriteDestinationAsFloat(ReadSourceAsInt32());
break;
case Op.cvtwl:
WriteDestinationAsInt64(ReadSourceAsInt32());
break;
case Op.cvtws:
WriteDestinationAsInt16((Int16)ReadSourceAsInt32());
break;
case Op.divb:
WriteDestinationAsByte((byte)(ReadMiddleAsByte() / ReadSourceAsByte()));
break;
case Op.divf:
WriteDestinationAsFloat(ReadMiddleAsFloat() / ReadSourceAsFloat());
break;
case Op.divl:
WriteDestinationAsInt64(ReadMiddleAsInt64() / ReadSourceAsInt64());
break;
case Op.divw:
WriteDestinationAsInt32(ReadMiddleAsInt32() / ReadSourceAsInt32());
break;
case Op.eclr:
break;
case Op.exit:
break;
case Op.frame:
{
int type = ReadSourceAsInt32();
IntPtr ptr = PointerToFrame(FP + _currentModule.Types[type].Size);
WriteDestinationAsInt32(ptr.ToInt32());
break;
}
case Op.@goto:
break;
case Op.headb:
break;
case Op.headf:
break;
case Op.headl:
break;
case Op.headm:
break;
case Op.headmp:
break;
case Op.headp:
break;
case Op.headw:
break;
case Op.indc:
{
DisString str = ReadSourceAsObject <DisString> ();
WriteDestinationAsInt32((int)str.NativeValue[ReadMiddleAsInt32()]);
break;
}
case Op.indb:
case Op.indf:
case Op.indl:
case Op.indw:
case Op.indx:
{
DisArray array = ReadSourceAsObject <DisArray> ();
WriteMiddleAsInt32((int)array.GetPointerAt(ReadDestinationAsInt32()));
break;
}
case Op.insc:
{
DisString str = ReadSourceAsObject <DisString> ();
str.InsertCharAt(ReadMiddleAsInt32(), (char)ReadDestinationAsInt32());
break;
}
case Op.jmp:
_currentThread.PC = ReadDestinationAsInt32();
break;
case Op.lea:
{
WriteDestinationAsInt32((int)GetSourcePointer());
break;
}
case Op.lena:
{
DisArray array = ReadSourceAsObject <DisArray> ();
WriteDestinationAsInt32(array.Length);
break;
}
case Op.lenc:
{
DisString str = ReadSourceAsObject <DisString> () ?? DisString.Empty;
WriteDestinationAsInt32(Encoding.UTF8.GetCharCount(str.Bytes));
break;
}
case Op.lenl:
break;
case Op.load:
{
string path = ReadSourceAsObject <DisString> ().NativeValue;
int linkId = ReadMiddleAsInt32();
ModuleImportDescriptor descriptor = _currentModule.ImportedModules[linkId];
IModule m = GetModule(path, descriptor);
if (m == null)
{
WriteDestinationAsObject(null);
}
else
{
DisModuleRef moduleRef = new DisModuleRef {
Module = m,
LinkId = linkId
};
WriteDestinationAsObject(moduleRef);
}
break;
}
case Op.lsrl:
break;
case Op.lsrw:
break;
case Op.mcall:
{
PushCallFrame(new IntPtr(ReadSourceAsInt32()));
int currentSize = _frames.Peek().Size;
int frame = PointerToCurrentFrame().ToInt32();
FP = ReadSourceAsInt32() - frame;
DisModuleRef moduleRef = ReadDestinationAsObject <DisModuleRef> ();
ModuleImportDescriptor mimp = _currentModule.ImportedModules[moduleRef.LinkId];
MethodImportDescriptor method = mimp.Imports[ReadMiddleAsInt32()];
if (moduleRef.Module is Module)
{
_currentModule = (Module)moduleRef.Module;
_currentThread.PC = _currentModule.Exports.FirstOrDefault(m => m.Signature == method.Signature && m.Name == method.Name).PC;
}
else
{
NativeModule native = (NativeModule)moduleRef.Module;
var m = native.GetMethod(method.Name, method.Signature);
m.Invoke(this);
}
break;
}
case Op.mframe:
{
DisModuleRef moduleRef = ReadSourceAsObject <DisModuleRef> ();
ModuleImportDescriptor descriptor = _currentModule.ImportedModules[moduleRef.LinkId];
MethodImportDescriptor method = descriptor.Imports[ReadMiddleAsInt32()];
IntPtr ptr = PointerToFrame(FP + moduleRef.Module.GetFrameSize(method.Name, method.Signature));
WriteDestinationAsInt32(ptr.ToInt32());
break;
}
case Op.mnewz:
break;
case Op.modb:
WriteDestinationAsByte((byte)((ReadMiddleAsByte() % ReadSourceAsByte()) & 0xff));
break;
case Op.modl:
WriteDestinationAsInt64(ReadMiddleAsInt64() % ReadSourceAsInt64());
break;
case Op.modw:
WriteDestinationAsInt32(ReadMiddleAsInt32() % ReadSourceAsInt32());
break;
case Op.movb:
WriteDestinationAsByte(ReadSourceAsByte());
break;
case Op.movf:
WriteDestinationAsFloat(ReadSourceAsFloat());
break;
case Op.movl:
WriteDestinationAsInt64(ReadSourceAsInt64());
break;
case Op.movm:
break;
case Op.movmp:
break;
case Op.movp:
{
WriteDestinationAsObject(ReadSourceAsObject <DisObject> ());
break;
}
case Op.movpc:
break;
case Op.movw:
{
WriteDestinationAsInt32(ReadSourceAsInt32());
break;
}
case Op.mspawn:
break;
case Op.mulb:
WriteDestinationAsByte((byte)((ReadMiddleAsByte() * ReadSourceAsByte()) & 0xff));
break;
case Op.mulf:
WriteDestinationAsFloat(ReadMiddleAsFloat() * ReadSourceAsFloat());
break;
case Op.mull:
WriteDestinationAsInt64(ReadMiddleAsInt64() * ReadSourceAsInt64());
break;
case Op.mulw:
WriteDestinationAsInt32(ReadMiddleAsInt32() * ReadSourceAsInt32());
break;
case Op.nbalt:
break;
case Op.negf:
WriteDestinationAsFloat(ReadSourceAsFloat() * -1.0);
break;
case Op.@new:
break;
case Op.newa:
{
int count = ReadSourceAsInt32();
int type = ReadMiddleAsInt32();
int size = _currentModule.Types[type].Size;
DisArray array;
switch (size)
{
case 4:
array = new DisInt32Array(count);
break;
case 8:
array = new DisInt64Array(count);
break;
default:
array = null;
break;
}
WriteDestinationAsObject(array);
break;
}
case Op.newaz:
break;
case Op.newcb:
break;
case Op.newcf:
break;
case Op.newcl:
break;
case Op.newcm:
break;
case Op.newcmp:
break;
case Op.newcp:
break;
case Op.newcw:
break;
case Op.newz:
break;
case Op.nop:
break;
case Op.orb:
WriteDestinationAsByte((byte)((ReadSourceAsByte() * ReadMiddleAsByte()) & 0xff));
break;
case Op.orl:
WriteDestinationAsInt64(ReadSourceAsInt64() * ReadMiddleAsInt64());
break;
case Op.orw:
WriteDestinationAsInt32(ReadSourceAsInt32() * ReadMiddleAsInt32());
break;
case Op.recv:
break;
case Op.ret:
{
PopCallFrame();
break;
}
case Op.runt:
break;
case Op.send:
break;
case Op.shlb:
break;
case Op.shll:
break;
case Op.shlw:
break;
case Op.shrb:
break;
case Op.shrl:
break;
case Op.shrw:
break;
case Op.slicea:
break;
case Op.slicec:
break;
case Op.slicela:
break;
case Op.spawn:
break;
case Op.subb:
WriteDestinationAsByte((byte)((ReadMiddleAsByte() - ReadSourceAsByte()) & 0xff));
break;
case Op.subf:
WriteDestinationAsFloat(ReadMiddleAsFloat() - ReadSourceAsFloat());
break;
case Op.subl:
WriteDestinationAsInt64(ReadMiddleAsInt64() - ReadSourceAsInt64());
break;
case Op.subw:
WriteDestinationAsInt32(ReadMiddleAsInt32() - ReadSourceAsInt32());
break;
case Op.tail:
break;
case Op.tcmp:
{
DisObject src = ReadSourceAsObject <DisObject> ();
DisObject dest = ReadDestinationAsObject <DisObject> ();
if (src.GetType() != dest.GetType())
{
; // error ("typecheck")
}
break;
}
case Op.xorb:
WriteDestinationAsByte((byte)((ReadSourceAsByte() ^ ReadMiddleAsByte()) & 0xff));
break;
case Op.xorl:
WriteDestinationAsInt64(ReadSourceAsInt64() ^ ReadMiddleAsInt64());
break;
case Op.xorw:
WriteDestinationAsInt32(ReadSourceAsInt32() ^ ReadMiddleAsInt32());
break;
}
}
public static ObjectFile FromReader(DisReader reader)
{
int magic = reader.ReadOP();
if ((magic != XMAGIC) && (magic != SMAGIC))
{
throw new InvalidDataException("Invalid magic number");
}
if (magic == SMAGIC)
{
int slength = reader.ReadOP();
byte[] signature = reader.ReadBytes(slength);
}
int runtimeFlag = reader.ReadOP();
int stackExtent = reader.ReadOP();
int codeSize = reader.ReadOP();
int dataSize = reader.ReadOP();
int typeSize = reader.ReadOP();
int linkSize = reader.ReadOP();
int entryPc = reader.ReadOP();
int entryType = reader.ReadOP();
ObjectFile result = new ObjectFile();
result.ShareMP = ((runtimeFlag & FLAG_SHAREMP) != 0);
result.StackExtent = stackExtent;
result.EntryPC = entryPc;
result.EntryFrameType = entryType;
result.Instructions = new Instruction[codeSize];
for (int i = 0; i < codeSize; i++)
{
Instruction inst = Instruction.FromReader(reader);
result.Instructions[i] = inst;
}
result.Types = new TypeDescriptor[typeSize];
for (int i = 0; i < typeSize; i++)
{
result.Types[i] = TypeDescriptor.FromReader(reader);
}
List <DataDescriptor> data = new List <DataDescriptor> ();
while (true)
{
DataDescriptor descriptor = DataDescriptor.FromReader(reader);
if (descriptor.Code == 0)
{
break;
}
data.Add(descriptor);
}
result.Data = data.ToArray();
result.Name = reader.ReadString();
result.Link = new ExportDescriptor[linkSize];
for (int i = 0; i < linkSize; i++)
{
ExportDescriptor desc = ExportDescriptor.FromReader(reader);
desc.FrameSize = result.Types[desc.FrameTypeId].Size;
result.Link[i] = desc;
}
if (!reader.AtEndOfStream)
{
int importCount = reader.ReadOP();
List <ModuleImportDescriptor> imports = new List <ModuleImportDescriptor> (importCount);
for (int i = 0; i < importCount; i++)
{
imports.Add(ModuleImportDescriptor.FromReader(reader));
}
result.Imports = imports.ToArray();
}
if (!reader.AtEndOfStream)
{
int handlerCount = reader.ReadOP();
List <HandlerDescriptor> handlers = new List <HandlerDescriptor> (handlerCount);
for (int i = 0; i < handlerCount; i++)
{
handlers.Add(HandlerDescriptor.FromReader(reader));
}
result.Handlers = handlers.ToArray();
}
return(result);
}