private static ObjectTableWrapper ReadObjectTable(SPEEmulator.IEndianBitConverter conv)
{
uint object_table_size = conv.ReadUInt(SPEJITCompiler.OBJECT_TABLE_OFFSET);
SPEEmulator.EndianBitConverter obj_tb_tmp = new SPEEmulator.EndianBitConverter(new byte[(object_table_size + 1) * 16]);
conv.ReadBytes(SPEJITCompiler.OBJECT_TABLE_OFFSET, obj_tb_tmp.Data);
uint[] object_table = new uint[(object_table_size + 1) * 4];
for (int i = 0; i < object_table.Length; i++)
{
object_table[i] = obj_tb_tmp.ReadUInt();
}
ObjectTableWrapper objtable = new ObjectTableWrapper(object_table);
/*Console.WriteLine("#Size {0}, nextFree: {1}, nextOffset: {2}, memSize: {3}", objtable.Size, objtable.NextFree, objtable.NextOffset, objtable.Memsize);
* foreach (var e in objtable)
* Console.WriteLine(e.ToString());*/
foreach (var v in objtable.Where(c => c.KnownType == AccCIL.KnownObjectTypes.String))
{
byte[] localdata = new byte[v.AlignedSize];
conv.ReadBytes(v.Offset, localdata);
objtable.Strings.Add(System.Text.Encoding.UTF8.GetString(localdata, 0, (int)v.Size), v.Index);
}
return(objtable);
}
public SPEObjectManager(SPEEmulator.IEndianBitConverter conv)
{
this.Converter = conv;
this.ObjectTable = ReadObjectTable(conv);
KnownObjectsById = new Dictionary <uint, object>();
KnownObjectsByObj = new Dictionary <object, uint>(new PointerComparer());
Serializers = GetDefaultSerializers();
}
protected T FinalizeAndReturn <T>(SPEEmulator.IEndianBitConverter conv, SPEObjectManager manager, Dictionary <uint, int> transferedObjects, object[] args)
{
SPEObjectManager newmanager = new SPEObjectManager(conv);
//Now extract data back into the objects that are byref
foreach (KeyValuePair <uint, int> k in transferedObjects)
{
if (m_typeSerializeOut[k.Value])
{
newmanager.ReadObjectFromLS(k.Key, args[k.Value]);
}
//Remove the entry from the LS object table
manager.DeleteObject(k.Key);
}
//Write back the old, unmodified object table,
manager.SaveObjectTable();
Type rtype = typeof(T);
if (rtype == typeof(ReturnTypeVoid))
{
return(default(T));
}
else if (rtype.IsPrimitive)
{
return((T)newmanager.ReadRegisterPrimitiveValue(rtype, 0));
}
else
{
uint objindex = (uint)newmanager.ReadRegisterPrimitiveValue(typeof(uint), 0);
if (objindex == 0)
{
return(default(T));
}
return((T)newmanager.ReadObjectFromLS(objindex));
}
}
private static void WriteObjectTable(SPEEmulator.IEndianBitConverter conv, ObjectTableWrapper objtable)
{
SPEEmulator.EndianBitConverter obj_tb_tmp = new SPEEmulator.EndianBitConverter(new byte[objtable.Data.Length * 4]);
foreach (uint u in objtable.Data)
{
obj_tb_tmp.WriteUInt(u);
}
conv.WriteBytes(SPEJITCompiler.OBJECT_TABLE_OFFSET, obj_tb_tmp.Data);
foreach (KeyValuePair <string, uint> k in objtable.Strings)
{
ObjectTableEntry e = objtable[k.Value];
System.Diagnostics.Debug.Assert(e.KnownType == AccCIL.KnownObjectTypes.String);
System.Diagnostics.Debug.Assert(e.Size == k.Key.Length);
byte[] localdata = new byte[e.AlignedSize];
System.Text.Encoding.UTF8.GetBytes(k.Key, 0, k.Key.Length, localdata, 0);
conv.WriteBytes(e.Offset, localdata);
}
}
protected Dictionary <uint, int> LoadInitialArguments(SPEEmulator.IEndianBitConverter conv, SPEObjectManager manager, object[] args)
{
conv.WriteUInt(0, 0);
conv.WriteUInt(4, (uint)args.Length);
uint lsoffset = manager.ObjectTable.Memsize - (16 * 8);
//The -(16 * 8) is used to prevent the bootloader stack setup from overwriting the arguments
Dictionary <uint, int> transferedObjects = new Dictionary <uint, int>();
for (int i = args.Length - 1; i >= 0; i--)
{
lsoffset -= 16;
if (m_loadedMethodTypes[i].IsPrimitive)
{
manager.WriteRegisterPrimitiveValue(args[i], lsoffset);
}
else
{
uint objindex = manager.CreateObjectOnLS(args[i]);
if (objindex != 0 && !transferedObjects.ContainsKey(objindex))
{
transferedObjects[objindex] = i;
}
manager.WriteRegisterPrimitiveValue(objindex, lsoffset);
}
}
conv.WriteUInt(8, lsoffset);
conv.WriteUInt(12, 0);
manager.SaveObjectTable();
return(transferedObjects);
}
protected bool MethodCallback(SPEEmulator.IEndianBitConverter c, uint offset)
{
uint sp = c.ReadUInt(offset);
//Stack size is 77 elements, and return address is next next instruction
uint call_address = (c.ReadUInt(sp + (16 * 77)) - 4) / 4;
Mono.Cecil.MethodReference calledmethod;
m_callpoints.TryGetValue((int)call_address, out calledmethod);
if (calledmethod == null)
{
foreach (KeyValuePair <int, Mono.Cecil.MethodReference> f in m_callpoints)
{
Console.WriteLine("Call registered at {0} for method {1}", f.Key, f.Value.DeclaringType.FullName + "::" + f.Value.Name);
}
throw new Exception("No method call registered at " + call_address);
}
//All good, we have a real function, now load all required arguments onto PPE
object[] arguments = new object[calledmethod.Parameters.Count];
System.Reflection.MethodInfo m = AccCIL.AccCIL.FindReflectionMethod(calledmethod);
if (m == null)
{
throw new Exception("Unable to find function called: " + calledmethod.DeclaringType.FullName + "::" + calledmethod.Name);
}
uint arg_base = sp + 32;
uint sp_offset = arg_base;
object @this = null;
SPEObjectManager manager = new SPEObjectManager(c);
if (!m.IsStatic)
{
Type argtype = m.DeclaringType;
uint objindex = (uint)manager.ReadRegisterPrimitiveValue(typeof(uint), sp_offset);
@this = manager.ReadObjectFromLS(objindex);
sp_offset += 16;
}
for (int i = 0; i < arguments.Length; i++)
{
Type argtype = Type.GetType(calledmethod.Parameters[i].ParameterType.FullName);
arguments[i] = manager.ReadRegisterPrimitiveValue(argtype.IsPrimitive ? argtype : typeof(uint), sp_offset);
if (!argtype.IsPrimitive)
{
arguments[i] = manager.ReadObjectFromLS((uint)arguments[i]);
}
sp_offset += 16;
}
if (calledmethod.Name != "WriteLine" && calledmethod.Name != "Format" && calledmethod.Name != "ToString")
{
Console.WriteLine("Invoking {0} with arguments: ", calledmethod.DeclaringType.FullName + "::" + calledmethod.Name);
foreach (object o in arguments)
{
Console.WriteLine("\t{0}", o == null ? "<null>" : o.ToString());
}
}
object result = m.Invoke(@this, arguments);
int resultIndex = result == null ? 0 : -1;
foreach (KeyValuePair <uint, object> t in manager.KnownObjectsById)
{
if (t.Value != null)
{
//Strings are imutable, so there is no reason to transfer them back
if (manager.ObjectTable[t.Key].KnownType == AccCIL.KnownObjectTypes.String)
{
if (t.Value.Equals(result))
{
resultIndex = (int)t.Key;
}
continue;
}
manager.WriteObjectToLS(t.Key, t.Value);
if (t.Value == result)
{
resultIndex = (int)t.Key;
}
}
}
if (m.ReturnType != null)
{
if (m.ReturnType.IsPrimitive)
{
manager.WriteRegisterPrimitiveValue(result, arg_base);
}
else
{
if (resultIndex < 0)
{
resultIndex = (int)manager.CreateObjectOnLS(result);
manager.ObjectTable[(uint)resultIndex].Refcount = 1;
manager.SaveObjectTable();
}
manager.WriteRegisterPrimitiveValue((uint)resultIndex, arg_base);
}
}
return(true);
}
public object Deserialize(SPEEmulator.IEndianBitConverter conv, ObjectTableEntry e, object storage)
{
Type arrtype;
uint elsize;
if (e.KnownType == AccCIL.KnownObjectTypes.String)
{
throw new InvalidProgramException("Something is wrong here");
}
if (e.Type == 0)
{
arrtype = AccCIL.AccCIL.GetObjType(e.KnownType).MakeArrayType();
elsize = 1u << (int)BuiltInSPEMethods.get_array_elem_len_mult((uint)e.KnownType);
}
else
{
arrtype = Type.GetType((string)m_parent.ReadObjectFromLS(e.Type));
elsize = 4;
}
Type eltype = arrtype.GetElementType();
uint arraylen = e.Size / elsize;
Array arr;
if (storage == null)
{
arr = Array.CreateInstance(eltype, arraylen);
}
else
{
arr = (Array)storage;
if (storage.GetType().GetElementType() != eltype || arr.Length != arraylen)
{
throw new Exception("Unexpected difference in storage object and actual object");
}
}
if (eltype.IsPrimitive)
{
ISerializer elserializer;
m_parent.Serializers.TryGetValue(eltype, out elserializer);
if (elserializer == null)
{
throw new Exception("Unsupported inner type: " + eltype.FullName);
}
for (int i = 0; i < arr.Length; i++)
{
arr.SetValue(elserializer.Deserialize(conv, null, arr.GetValue(i)), i);
}
}
else
{
//In this case elements may have a different type than what the array states,
//because the array elements can be interface or object type, and the actual
//instance type is unknown
ISerializer uintd = m_parent.Serializers[typeof(uint)];
for (int i = 0; i < arr.Length; i++)
{
arr.SetValue(m_parent.ReadObjectFromLS((uint)uintd.Deserialize(conv, null, null), arr.GetValue(i)), i);
}
}
return(arr);
}
public object Deserialize(SPEEmulator.IEndianBitConverter conv, ObjectTableEntry e, object storage)
{
byte[] data = new byte[e.AlignedSize];
conv.ReadBytes(data);
return(System.Text.Encoding.UTF8.GetString(data, 0, (int)e.Size));
}
public object Deserialize(SPEEmulator.IEndianBitConverter conv, ObjectTableEntry e, object storage)
{
return(conv.ReadDouble());
}
public object Deserialize(SPEEmulator.IEndianBitConverter conv, ObjectTableEntry e, object storage)
{
return(conv.ReadByte() == 0 ? false : true);
}
