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); }
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 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 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); }