static unsafe void InternalSetValue(void *typedref, void *objval) { // get the type from the typed reference to see if we need to unbox the object // or store as a reference type void *et = *(void **)((byte *)typedref + ClassOperations.GetTypedReferenceTypeOffset()); void *ptr = *(void **)((byte *)typedref + ClassOperations.GetTypedReferenceValueOffset()); void *etextends = *(void **)((byte *)et + ClassOperations.GetVtblExtendsVtblPtrOffset()); if (etextends == OtherOperations.GetStaticObjectAddress("_Zu1L") || etextends == OtherOperations.GetStaticObjectAddress("_ZW6System4Enum")) { // this is a boxed value type. Get its size var vt_size = TysosType.GetValueTypeSize(et); // src ptr void *src = *(void **)((byte *)objval + ClassOperations.GetBoxedTypeDataOffset()); CopyMem((byte *)ptr, (byte *)src, vt_size); } else { // simply copy the reference *(void **)ptr = objval; } }
static unsafe void *InternalToObject(void *typedref) { // get the type from the typed reference to see if we need to box the object // or simply return the address as a reference type void *et = *(void **)((byte *)typedref + ClassOperations.GetTypedReferenceTypeOffset()); void *src = *(void **)((byte *)typedref + ClassOperations.GetTypedReferenceValueOffset()); void *etextends = *(void **)((byte *)et + ClassOperations.GetVtblExtendsVtblPtrOffset()); if (etextends == OtherOperations.GetStaticObjectAddress("_Zu1L") || etextends == OtherOperations.GetStaticObjectAddress("_ZW6System4Enum")) { // this is a boxed value type. Get its size var vt_size = TysosType.GetValueTypeSize(et); // build a new boxed type var ret = MemoryOperations.GcMalloc(*(int *)((byte *)et + ClassOperations.GetVtblTypeSizeOffset())); // dst ptr var dst = (byte *)ret + ClassOperations.GetBoxedTypeDataOffset(); CopyMem(dst, (byte *)src, vt_size); return(ret); } else { // simply copy the reference return(*(void **)src); } }
internal static unsafe void StackTrace_GetStackFramesInternal(void *sfh, int iSkip, bool fNeedFileInfo, Exception e) { /* We set the 'reentrant' member of the stack frame helper here to prevent InitializeSourceInfo running further and set * iFrameCount to zero to prevent stack traces occuring via CoreCLR */ *(int *)((byte *)OtherOperations.GetStaticObjectAddress("_ZW20System#2EDiagnostics16StackFrameHelperS") + ClassOperations.GetStaticFieldOffset("_ZW20System#2EDiagnostics16StackFrameHelper", "t_reentrancy")) = 1; *(int *)((byte *)sfh + ClassOperations.GetFieldOffset("_ZW20System#2EDiagnostics16StackFrameHelper", "iFrameCount")) = 0; }
private static void load_mscorlib() { var str = AssemblyLoader.LoadAssembly("mscorlib"); metadata.PEFile pef = new metadata.PEFile(); var m = pef.Parse(str, AssemblyLoader); AssemblyLoader.AddToCache(m, "mscorlib"); mscorlib = m; BinaryAssemblyLoader.ptr_cache[(ulong)OtherOperations.GetStaticObjectAddress("mscorlib")] = m; }
static unsafe byte InternalGetCorElementType(void *enum_obj) { var enum_type = GetUnderlyingEnumTypeVtbl(**(void ***)enum_obj); if (enum_type == OtherOperations.GetStaticObjectAddress("_Zi")) { return((byte)metadata.CorElementType.I4); } else if (enum_type == OtherOperations.GetStaticObjectAddress("_Zx")) { return((byte)metadata.CorElementType.I8); } throw new NotImplementedException(); }
public override DataInterface LoadAssembly(string name) { void *ptr; System.Diagnostics.Debugger.Log(0, "metadata", "Metadata.BinaryAssemblyLoader.LoadAssembly: request to load " + name); if (name == "mscorlib" || name == "mscorlib.dll") { ptr = OtherOperations.GetStaticObjectAddress("mscorlib"); } else if (name == "libsupcs" || name == "libsupcs.dll") { ptr = OtherOperations.GetStaticObjectAddress("libsupcs"); } else if (name == "metadata" || name == "metadata.dll") { ptr = OtherOperations.GetStaticObjectAddress("metadata"); } else { ptr = JitOperations.GetAddressOfObject(name); } return(new BinaryInterface(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))); }
static unsafe void *GetValueImpl(void *arr, int pos) { /* Get the element type of the array */ void *et = *(void **)((byte *)arr + ArrayOperations.GetElemTypeOffset()); /* Get a pointer to the source data */ var elem_size = *(int *)((byte *)arr + ArrayOperations.GetElemSizeOffset()); void *ia = *(void **)((byte *)arr + ArrayOperations.GetInnerArrayOffset()); void *sptr = (void *)((byte *)ia + pos * elem_size); /* Is this a value type? In which case we need to return a boxed value */ void *extends = *(void **)((byte *)et + ClassOperations.GetVtblExtendsVtblPtrOffset()); if (extends == OtherOperations.GetStaticObjectAddress("_Zu1L") || extends == OtherOperations.GetStaticObjectAddress("_ZW6System4Enum")) { /* This is a value type. We need to read the size of the element, * create a new object of the appropriate size and copy the data * into it */ byte *ret = (byte *)MemoryOperations.GcMalloc(elem_size + ClassOperations.GetBoxedTypeDataOffset()); *(void **)(ret + ClassOperations.GetVtblFieldOffset()) = et; *(ulong *)(ret + ClassOperations.GetMutexLockOffset()) = 0; /* Avoid calls to memcpy if possible */ switch (elem_size) { case 1: *(byte *)(ret + ClassOperations.GetBoxedTypeDataOffset()) = *(byte *)sptr; return(ret); case 2: *(ushort *)(ret + ClassOperations.GetBoxedTypeDataOffset()) = *(ushort *)sptr; return(ret); case 4: *(uint *)(ret + ClassOperations.GetBoxedTypeDataOffset()) = *(uint *)sptr; return(ret); case 8: if (OtherOperations.GetPointerSize() >= 8) { *(ulong *)(ret + ClassOperations.GetBoxedTypeDataOffset()) = *(ulong *)sptr; return(ret); } else { *(uint *)(ret + ClassOperations.GetBoxedTypeDataOffset()) = *(uint *)sptr; *(uint *)(ret + ClassOperations.GetBoxedTypeDataOffset() + 4) = *(uint *)((byte *)sptr + 4); return(ret); } case 16: if (OtherOperations.GetPointerSize() >= 8) { *(ulong *)(ret + ClassOperations.GetBoxedTypeDataOffset()) = *(ulong *)sptr; *(ulong *)(ret + ClassOperations.GetBoxedTypeDataOffset() + 8) = *(ulong *)((byte *)sptr + 8); return(ret); } else { *(uint *)(ret + ClassOperations.GetBoxedTypeDataOffset()) = *(uint *)sptr; *(uint *)(ret + ClassOperations.GetBoxedTypeDataOffset() + 4) = *(uint *)((byte *)sptr + 4); *(uint *)(ret + ClassOperations.GetBoxedTypeDataOffset() + 8) = *(uint *)((byte *)sptr + 8); *(uint *)(ret + ClassOperations.GetBoxedTypeDataOffset() + 12) = *(uint *)((byte *)sptr + 12); return(ret); } } /* Do data copy via memcpy */ MemoryOperations.MemCpy(ret + ClassOperations.GetBoxedTypeDataOffset(), sptr, elem_size); return(ret); } else { /* Its a reference type, so just return the pointer */ return(*(void **)sptr); } }