public static void *InternalInvoke(void *mptr, object[] args, void *rtype, uint flags)
{
int p_length = (args == null) ? 0 : args.Length;
// See InternalStrCpy for the rationale here
int max_stack_alloc = p_length > 512 ? 512 : p_length;
IntPtr *pstack = stackalloc IntPtr[max_stack_alloc];
IntPtr *tstack = stackalloc IntPtr[max_stack_alloc];
void **ps, ts;
if (max_stack_alloc <= 512)
{
ps = (void **)pstack;
ts = (void **)tstack;
}
else
{
ps = (void **)MemoryOperations.GcMalloc(p_length * sizeof(void *));
ts = (void **)MemoryOperations.GcMalloc(p_length * sizeof(void *));
}
// Build a new params array and a tysos type array
if (args != null)
{
for (int i = 0; i < args.Length; i++)
{
var cp = CastOperations.ReinterpretAsPointer(args[i]);
ps[i] = cp;
ts[i] = *(void **)cp;
}
}
return(InternalInvoke(mptr, args.Length, ps, ts, rtype, flags));
}
static unsafe object to_object(TysosType enum_type, object value)
{
/* Convert value (of an integral type) to an enum of type 'enum_type'
* and return its boxed value
*/
if (enum_type == null)
{
throw new ArgumentNullException("enumType");
}
if (value == null)
{
throw new ArgumentException("value");
}
/* The incoming value type 'value' is already boxed.
*
* We can therefore just copy its data to a new enum object
*/
void *value_obj = CastOperations.ReinterpretAsPointer(value);
void *value_vtbl = *(void **)value_obj;
int value_csize = *(int *)((byte *)value_vtbl + ClassOperations.GetVtblTypeSizeOffset());
void *ret_obj = MemoryOperations.GcMalloc(value_csize);
MemoryOperations.MemCpy(ret_obj, value_obj, value_csize);
void *ret_vtbl = *(void **)((byte *)CastOperations.ReinterpretAsPointer(enum_type) + ClassOperations.GetSystemTypeImplOffset());
*(void **)ret_obj = ret_vtbl;
*(void **)((byte *)ret_obj + ClassOperations.GetMutexLockOffset()) = null;
return(CastOperations.ReinterpretAsObject(ret_obj));
}
static void ModuleHandle_GetModuleType(TysosModule mod, ObjectHandleOnStack oh)
{
// Get the <Module> type name for the current module. This is always defined as tdrow 1.
var ts = (TysosType)mod.m.GetTypeSpec(metadata.MetadataStream.tid_TypeDef, 1);
*oh.ptr = CastOperations.ReinterpretAsPointer(ts);
}
static unsafe void AssemblyName_nInit(byte *obj, out TysosAssembly assembly, bool forIntrospection, bool raiseResolveEvent)
{
string name = CastOperations.ReinterpretAsString(*(void **)(obj + ClassOperations.GetFieldOffset("_ZW19System#2EReflection12AssemblyName", "_Name")));
System.Diagnostics.Debugger.Log(0, "libsupcs", "AssemblyName_nInit(" + name + ", out TysosAssembly, bool, bool) called");
// split assembly name off from other fields
int comma = name.IndexOf(',');
string Name;
if (comma != -1)
{
Name = name.Substring(0, comma);
}
else
{
Name = name;
}
if (Name.Equals("System.Private.CoreLib"))
{
Name = "mscorlib";
}
*(void **)(obj + ClassOperations.GetFieldOffset("_ZW19System#2EReflection12AssemblyName", "_Name")) =
CastOperations.ReinterpretAsPointer(Name);
System.Diagnostics.Debugger.Log(0, "libsupcs", "AssemblyName_nInit - setting _Name to " + Name);
assembly = null;
}
static internal TysosModule GetModule(void *aptr, string ass_name)
{
var mfile = CastOperations.ReinterpretAsUlong(CastOperations.ReinterpretAsObject(aptr));
lock (mod_cache)
{
if (!mod_cache.TryGetValue(mfile, out var ret))
{
ret = new TysosModule(aptr, ass_name);
mod_cache[mfile] = ret;
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosType: building new TysosModule for " + ass_name);
}
return(ret);
}
}
static unsafe void get_enum_values_and_names(TysosType enum_type, HandleOnStack values_ptr, HandleOnStack names_ptr, bool getNames)
{
//System.Diagnostics.Debugger.Log(0, "libsupcs", "get_enum_values_and_names: enum_type: " + ((ulong)enum_vtbl).ToString("X16"));
//var enum_type = TysosType.internal_from_vtbl(enum_vtbl);
MonoEnumInfo info;
get_enum_info(enum_type, out info);
ulong[] values = new ulong[info.values.Length];
int[] v = info.values as int[];
for (int i = 0; i < info.values.Length; i++)
{
values[i] = (ulong)v[i];
}
*values_ptr.ptr = CastOperations.ReinterpretAsPointer(values);
if (getNames)
{
*names_ptr.ptr = CastOperations.ReinterpretAsPointer(info.names);
}
}
/* Build an array of a particular type */
public static unsafe T[] CreateSZArray <T>(int nitems, void *data_addr)
{
TysosType arrtt = (TysosType)typeof(T[]);
TysosType elemtt = (TysosType)typeof(T);
int elemsize;
if (elemtt.IsValueType)
{
elemsize = elemtt.GetClassSize() - ClassOperations.GetBoxedTypeDataOffset();
}
else
{
elemsize = OtherOperations.GetPointerSize();
}
if (data_addr == null)
{
data_addr = MemoryOperations.GcMalloc(elemsize * nitems);
}
byte *ret = (byte *)MemoryOperations.GcMalloc(ArrayOperations.GetArrayClassSize() + 8); // extra space for lobounds and length array
void *vtbl = *(void **)((byte *)CastOperations.ReinterpretAsPointer(arrtt) + ClassOperations.GetSystemTypeImplOffset());
*(void **)(ret + ClassOperations.GetVtblFieldOffset()) = vtbl;
*(ulong *)(ret + ClassOperations.GetMutexLockOffset()) = 0;
*(void **)(ret + ArrayOperations.GetElemTypeOffset()) = *(void **)((byte *)CastOperations.ReinterpretAsPointer(elemtt) + ClassOperations.GetSystemTypeImplOffset());
*(int *)(ret + ArrayOperations.GetElemSizeOffset()) = elemsize;
*(void **)(ret + ArrayOperations.GetInnerArrayOffset()) = data_addr;
*(void **)(ret + ArrayOperations.GetLoboundsOffset()) = ret + ArrayOperations.GetArrayClassSize();
*(void **)(ret + ArrayOperations.GetSizesOffset()) = ret + ArrayOperations.GetArrayClassSize() + 4;
*(int *)(ret + ArrayOperations.GetRankOffset()) = 1;
*(int *)(ret + ArrayOperations.GetArrayClassSize()) = 0; // lobounds[0]
*(int *)(ret + ArrayOperations.GetArrayClassSize() + 4) = nitems; // sizes[0]
return((T[])CastOperations.ReinterpretAsObject(ret));
}
internal static unsafe metadata.TypeSpec GetTypeSpec(RuntimeTypeHandle rth)
{
void *ptr = CastOperations.ReinterpretAsPointer(rth.Value);
return(GetTypeSpec(ptr));
}
public override object Invoke(object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] parameters, System.Globalization.CultureInfo culture)
{
uint flags = 0;
if (MethodAddress == null)
{
var mangled_name = mspec.MangleMethod();
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosMethod.Invoke: requesting run-time address for " + mangled_name);
MethodAddress = JitOperations.GetAddressOfObject(mspec.MangleMethod());
if (MethodAddress == null)
{
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosMethod.Invoke: jit compiling method");
MethodAddress = JitOperations.JitCompile(this.mspec);
}
}
if (MethodAddress == null)
{
throw new System.Reflection.TargetException("Method does not have a defined implementation (" + OwningType.FullName + "." + Name + "())");
}
if (!IsStatic && (obj == null))
{
throw new System.Reflection.TargetException("Instance method and obj is null (" + OwningType.FullName + "." + Name + "())");
}
// TODO: check number and type of parameters is what the method expects
// Get total number of parameters
int p_length = 0;
if (parameters != null)
{
p_length = parameters.Length;
}
if (!IsStatic)
{
p_length++;
}
// See InternalStrCpy for the rationale here
int max_stack_alloc = p_length > 512 ? 512 : p_length;
IntPtr *pstack = stackalloc IntPtr[max_stack_alloc];
IntPtr *tstack = stackalloc IntPtr[max_stack_alloc];
void **ps, ts;
if (max_stack_alloc <= 512)
{
ps = (void **)pstack;
ts = (void **)tstack;
}
else
{
ps = (void **)MemoryOperations.GcMalloc(p_length * sizeof(void *));
ts = (void **)MemoryOperations.GcMalloc(p_length * sizeof(void *));
}
// Build a new params array to include obj if necessary, and a tysos type array
int curptr = 0;
if (!IsStatic)
{
ps[0] = CastOperations.ReinterpretAsPointer(obj);
ts[0] = OtherOperations.GetStaticObjectAddress("_Zu1O");
curptr++;
}
if (parameters != null)
{
for (int i = 0; i < parameters.Length; i++, curptr++)
{
var cp = CastOperations.ReinterpretAsPointer(parameters[i]);
ps[curptr] = cp;
ts[curptr] = *(void **)cp;
}
}
if (!IsStatic)
{
flags |= invoke_flag_instance;
}
if (OwningType.IsValueType)
{
flags |= invoke_flag_vt;
}
if (ReturnType != null && ReturnType.IsValueType)
{
flags |= invoke_flag_vt_ret;
}
return(CastOperations.ReinterpretAsObject(InternalInvoke(MethodAddress, p_length, ps, ts,
(ReturnType != null) ? TysosType.ReinterpretAsType(ReturnType)._impl : null, flags)));
}
internal static unsafe char *GetChars(string s)
{
byte *s2 = (byte *)CastOperations.ReinterpretAsPointer(s);
return((char *)(s2 + GetDataOffset()));
}
static void GetExecutingAssembly(StackCrawlMarkHandle scmh, TysosModule.ObjectHandleOnStack ret)
{
int scm = *(int *)scmh.ptr;
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosAssembly.GetExecutingAssembly: scm: " + scm.ToString());
Unwinder u = OtherOperations.GetUnwinder();
u.UnwindOne();
u.UnwindOne(); // we are double-nested within coreclr so unwind this and calling method (GetExecutingAssembly(ref StackMarkHandle)) first
switch (scm)
{
case 0:
break;
case 1:
u.UnwindOne();
break;
case 2:
u.UnwindOne();
u.UnwindOne();
break;
default:
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosAssembly.GetExecutingAssembly: unsupported scm: " + scm.ToString());
throw new NotSupportedException();
}
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosAssembly.GetExecutingAssembly: requested pc " + ((ulong)u.GetInstructionPointer()).ToString("X"));
void *offset;
var name = JitOperations.GetNameOfAddress((void *)u.GetInstructionPointer(), out offset);
if (name == null)
{
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosAssembly.GetExecutingAssembly: symbol not found");
*ret.ptr = null;
return;
}
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosAssembly.GetExecutingAssembly: found method " + name);
var ts = Metadata.MSCorlib.DemangleObject(name);
if (ts == null)
{
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosAssembly.GetExecutingAssembly: demangler returned null");
*ret.ptr = null;
return;
}
var m = ts.Metadata;
if (m == null)
{
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosAssembly.GetExecutingAssembly: returned ts had no assembly");
*ret.ptr = null;
return;
}
var aptr = (m.file as Metadata.BinaryInterface).b;
var retm = TysosModule.GetModule(aptr, m.AssemblyName);
System.Diagnostics.Debugger.Log(0, "libsupcs", "TysosAssembly.GetExecutingAssembly: returning " + retm.ass.assemblyName);
*ret.ptr = CastOperations.ReinterpretAsPointer(retm.ass);
}