15public TargetPointer(ulong value) => Value = value;

200Descriptor subDescriptor = ReadContractDescriptor(subDescriptorAddress.Value, _dataTargetDelegates); 286NumericValue = descriptor.PointerData[global.NumericValue.Value].Value, 407if (dataTargetDelegates.ReadFromTarget(descriptorAddr.Value, descriptorBuffer) < 0) 408throw DescriptorMalformed($"Failed to read contract descriptor JSON at 0x{descriptorAddr.Value:x8}."); 434if (!TryReadPointer(pointerDataAddr.Value + (uint)(i * pointerSize), config, dataTargetDelegates, out pointerData[i])) 534Write<ulong>(address, value.Value); 536Write<uint>(address, checked((uint)value.Value)); 825=> IsAligned(pointer.Value, _config.PointerSize);

17public static implicit operator ulong(TargetPointer p) => p.Value; 20public static bool operator ==(TargetPointer left, TargetPointer right) => left.Value == right.Value; 21public static bool operator !=(TargetPointer left, TargetPointer right) => left.Value != right.Value; 26public bool Equals(TargetPointer other) => Value == other.Value; 28public override int GetHashCode() => Value.GetHashCode(); 30public override string ToString() => $"0x{Value:x}";

25return new TargetCodePointer(address.Value | Arm32ThumbBit); 32return new TargetCodePointer(address.Value);

80TargetNUInt thisMask = new(_target.ReadGlobalPointer(Constants.Globals.CCWThisMask).Value);

113if (module != TargetPointer.Null && entry.ClrModule.Value != module.Value) 188if (entry.ClrModule.Value != module.Value) 238_target.WriteBuffer(tablePointer.Value, zeros); 240_target.WritePointer(globalAddr.Value, tablePointer);

62return (int)_target.Read<uint>(addr.Value); 68uint currentFlags = _target.Read<uint>(addr.Value); 69_target.Write<uint>(addr.Value, currentFlags | (uint)DebuggerControlFlag_1.PendingAttach); 75uint currentFlags = _target.Read<uint>(addr.Value); 78_target.Write<uint>(addr.Value, currentFlags | (uint)DebuggerControlFlag_1.Attached); 82_target.Write<uint>(addr.Value, currentFlags & ~((uint)DebuggerControlFlag_1.Attached | (uint)DebuggerControlFlag_1.PendingAttach)); 90return _target.Read<byte>(addr.Value.Value) != 0; 156ulong start = entry.StartAddress.Value; 267_target.WriteBuffer(remotePtr.Value, record.AsSpan(0, cbSize)); 294_target.WriteBuffer(espOSContext.Value, ctx.GetBytes()); 325new TargetNUInt(espContext.Value), 326new TargetNUInt(espRecord.Value), 328new TargetNUInt(userData.Value), 333ctx.InstructionPointer = new TargetCodePointer(pfnHijackFunction.Value); 365sp = new TargetPointer(sp.Value - (ulong)(cc.HomeSpaceSlotCount * target.PointerSize));

17sp = new TargetPointer(sp.Value - (ulong)bytes.Length); 24target.WriteBuffer(sp.Value, bytes); 35sp = new TargetPointer(sp.Value - (ulong)target.PointerSize); 42target.WriteNUInt(sp.Value, value); 69sp = new TargetPointer(sp.Value & mask);

66throw new InvalidOperationException($"Stack trace object 0x{stackTraceObj.Value:x} has no MethodTable."); 105ip = new TargetPointer(ip.Value - 1);

155return codeHeaderIndirect.Value <= stubCodeBlockLast; 262TargetPointer runtimeFunctionPtr = jitManager?.GetUnwindInfo(range, codeInfoHandle.Address.Value) ?? TargetPointer.Null; 288jitManager?.GetMethodRegionInfo(range, codeInfoHandle.Address.Value, out hotSize, out coldStart, out coldSize); 333if (((IExecutionManager)this).GetCodeKind(new TargetCodePointer(startAddress.Value)) == CodeKind.Interpreter) 370return jitManager?.GetUnwindInfo(range, codeInfoHandle.Address.Value) ?? TargetPointer.Null; 390return jitManager?.GetDebugInfo(range, codeInfoHandle.Address.Value, out hasFlagByte) ?? TargetPointer.Null; 403jitManager?.GetGCInfo(range, codeInfoHandle.Address.Value, out gcInfo, out gcVersion); 516TargetPointer jitManagerAddress = new(table.Context.Value & ~(ulong)3); 545RangeSection range = RangeSection.Find(_target, _topRangeSectionMap, _rangeSectionMapLookup, codeInfoHandle.Address.Value); 624isCatchAllHandler = typeHandle.Value.Value == objectMethodTable.Value;

37Debug.Assert(codeStart.Value <= jittedCodeAddress.Value); 39TargetNUInt relativeOffset = new TargetNUInt(instrPointer.Value - codeStart.Value); 75Debug.Assert(codeStart.Value <= jittedCodeAddress.Value); 106Debug.Assert(codeStart.Value <= jittedCodeAddress.Value); 141Debug.Assert(codeStart.Value <= jittedCodeAddress.Value); 172TargetCodePointer current = new(heapListNode.EndAddress.Value); 191if (codeStart.Value <= heapListNode.StartAddress.Value) 194current = new TargetCodePointer(codeStart.Value - 1); 231return GetStubKind((StubKind)codeHeaderAddress.Value);

35Debug.Assert(codeStart.Value <= jittedCodeAddress.Value); 37TargetNUInt relativeOffset = new TargetNUInt(instrPointer.Value - codeStart.Value); 42info = new CodeBlock(codeStart.Value, realCodeHeader.MethodDesc, relativeOffset, rangeSection.Data.JitManager);

51new TargetCodePointer(imageBase.Value + function.BeginAddress), Target); 60new TargetCodePointer(imageBase.Value + coldFunction.BeginAddress), Target);

60TargetNUInt relativeAddress = new TargetNUInt(currentPC.Value - mapBase.Value);

135TargetNUInt relativeAddress = new TargetNUInt(currentPC.Value - mapBase.Value);

462TargetPointer next = new TargetPointer(currentAddress.Value + currentObjectSize); 471return new TargetPointer(context.Limit.Value + minObjSize);

122_infoHdrSize = (uint)(offset.Value - gcInfoAddress.Value); 566return new TargetPointer(GetOutermostBaseFP(fp).Value & ~SHADOW_SP_BITS); 571return new TargetPointer(sp.Value + CalculatePushedArgSizeAt(codeOffset)); 578TargetPointer pLocalloc = new(ebp.Value - GetLocallocSPOffset()); 582return new TargetPointer(ebp.Value - _stackSize + (uint)sizeof(int));

47notification = (NotificationType_1)(uint)exceptionInformation[0].Value switch 54NotificationType_1.ExceptionCatcherEnter => new ExceptionCatcherEnterNotificationData(exceptionInformation[1], (uint)exceptionInformation[2].Value), 63GcEventType eventType = (GcEventType)(uint)exceptionInformation[1].Value; 64GcEventData eventData = new(eventType, (int)(uint)exceptionInformation[2].Value);

38return mt.Value & (ulong)~_objectToMethodTableUnmask; 69offsetToFirstChar = (uint)(str.FirstChar.Value - address.Value);

96byte targetBytePattern = target.Read<byte>(new TargetPointer((instrAddress.Value + (ulong)i)));

177ulong pageBase = instrPointer.Value & ~pageMask; 178ulong offset = instrPointer.Value - pageBase;

840? (long)(int)_target.ReadPointer(mtAddress - pointerSize).Value 841: (long)_target.ReadPointer(mtAddress - pointerSize).Value; 851ulong rawSeriesSize = _target.ReadPointer(seriesBase).Value; 852ulong seriesOffset = _target.ReadPointer(seriesBase + pointerSize).Value; 859ulong startOffset = _target.ReadPointer(mtAddress - 2 * pointerSize).Value;

66return new TargetPointer(vaSigCookieAddr.Value + cookie.SizeOfArgs); 69return new TargetPointer(vaSigCookieAddr.Value + (ulong)_target.PointerSize);

1247if (_eman.GetCodeBlockHandle(controlPC.Value) is not CodeBlockHandle cbh)

46set => Rsp = value.Value; 56set => Rbp = value.Value;

65uint controlPcRva = (uint)(context.Pc - imageBase.Value); 600uint controlPcRva = (uint)(context.Pc - imageBase.Value);

52set => Sp = value.Value; 62set => Fp = value.Value;

44set => Sp = (uint)value.Value; 56set => R11 = (uint)value.Value;

77uint controlPcRva = (uint)(context.Pc - imageBase.Value); 716ulong value = _target.ReadPointer(address).Value;

50set => Sp = value.Value; 60set => Fp = value.Value;

85uint controlPcRva = (uint)(context.Pc - imageBase.Value); 727ulong value = _target.ReadPointer(address).Value;

50set => Sp = value.Value; 60set => Fp = value.Value;

87baseVirtualIP = minVirtualIP.Value + runtimeFunction.BeginAddress; 102unwindDataAddress = new TargetPointer(r2rInfo.LoadedImageBase.Value + runtimeFunction.UnwindData);

83if (sp.Value <= LinearStackFloor) 86ulong current = sp.Value; 89current = _target.ReadPointer(current + _pointerSize).Value; 110=> _target.ReadPointer(sp.Value + _pointerSize); 122uint functionIndex = _target.Read<uint>(frameBase.Value + FunctionIndexOffset); 125uint functionLocalVirtualIP = _target.Read<uint>(frameBase.Value + VirtualIpOffset) * 2; 148uint functionIndex = _target.Read<uint>(frameBase.Value + FunctionIndexOffset); 155uint frameSize = DecodeULEB128(unwindData.Value); 163sp = new TargetPointer(frameBase.Value + frameSize);

63set => _interpreterSP = (uint)value.Value; 75set => _interpreterFP = (uint)value.Value;

383offset = SKIP_PUSH_REG(methodStart.Value, offset); 388offset = SKIP_ALLOC_FRAME((int)gcInfo.RawStackSize, methodStart.Value, offset); 476UnwindEbpDoubleAlignFrameProlog(ref context, gcInfo, methodStart.Value);

53set => Esp = (uint)value.Value; 63set => Ebp = (uint)value.Value;

23_holder.Context.Rcx = next.Address.Value; 27_holder.Context.Rdi = next.Address.Value;

23_holder.Context.X0 = next.Address.Value;

115if (current.Next.Value == terminator)

356return (icf.Datum.Value & InlinedCallFrameMarkerMask) == InlinedCallFrameMarkerMask; 381ulong datum = frame.Datum.Value & ~InlinedCallFrameMarkerMask; 560if (!context.TrySetRegister(registerName, new TargetNUInt(value.Value)))

41if (!_holder.Context.TrySetRegister(WasmContext.InterpreterWalkFramePointerRegister, new TargetNUInt(next.Address.Value)))

93_currentByte = new TargetPointer(_currentByte.Value + 1);

136if (obj.Value < seg.Start.Value || obj.Value >= seg.End.Value) 141while (currentObj.Value <= obj.Value) 144if (!_cache.TryReadPointer(currentObj.Value + _methodTableOffset, out TargetPointer mt)) 148mt = mt.Value & (ulong)~_objectToMethodTableUnmask; 157if (currentObj.Value + size > seg.End.Value || size == 0) 186if (!_cache.TryReadUInt32(objAddr.Value + numComponentsOffset, out uint numComponents))

91TargetPointer addr = new(baseAddr.Value + (ulong)(long)slot.SpOffset); 100ulong sp = context.StackPointer.Value; 101if (addr.Value >= sp && addr.Value < sp + scratchAreaSize) 279ulong imageBase = r2rInfo.LoadedImageBase.Value; 280if (indirection.Value < imageBase) 282ulong diff = indirection.Value - imageBase; 296TargetPointer sectionAddr = new(sectionsBase.Value + i * ImportSectionSize); 317uint lookupOffset = _target.Read<uint>(new TargetPointer(gcRefMapBase.Value + lookupIndex * 4)); 318TargetPointer p = new(gcRefMapBase.Value + lookupOffset); 323p = new(p.Value + 1); 324p = new(p.Value + 1); 364return new TargetPointer(tb.FirstGCRefMapSlot.Value + (ulong)(pos * _target.PointerSize)); 375return new TargetPointer(tb.ArgumentRegisters.Value + (ulong)offset); 378return new TargetPointer(tb.OffsetOfArgs.Value + (ulong)stackOffset); 380return new TargetPointer(tb.ArgumentRegisters.Value + (ulong)(argIndex * _target.PointerSize));

161if (frameIterator.CurrentFrameAddress.Value >= curSP.Value) 449TargetPointer slot = new(gcFrame.ObjRefs.Value + (ulong)i * pointerSize); 831handle.Context.StackPointer.Value < handle.FrameIter.CurrentFrameAddress.Value || 1011return handle.FrameIter.CurrentFrameAddress.Value < parentContext.StackPointer.Value; 1026TargetPointer contextAddress = _target.ReadPointer(slotAddress.Value); 1050ulong baseValue = (useFramePointer ? context.FramePointer : context.StackPointer).Value; 1191=> _target.ReadPointer(new TargetPointer(unchecked(baseAddress.Value + (ulong)(long)offset))); 1208ulong unwoundEsp = CallerStackPointer(handle).Value; 1223return new TargetPointer(hijacked.StackPointer.Value - pointerSize); 1323_target.ReadBuffer(filterContext.Value, buffer); 1356if (context.StackPointer.Value != 0 && context.InstructionPointer.Value != 0)

110TargetNUInt maxModules = new(target.ReadGlobalPointer(Constants.Globals.StressLogMaxModules).Value); 145if (currentPointer.Value < currentChunkData.Buf.Value) 152if (readPointer.Value >= currentChunkData.Buf.Value + chunkSize)

35public uint Flags { get; } = (uint)(value.Value & FLAG_MASK);

35public uint Flags { get; } = (uint)(value.Value & FLAG_MASK);

24WriteClrModule(new TargetNUInt(module.Value));

83builder.Append(ptr.Value.ToString($"X{_target.PointerSize * 2}")); 117builder.Append($"(#Could not read address of string at 0x{ptr.Value:x}#)"); 129builder.Append($"(#Could not read address of string at 0x{ptr.Value:x}#)"); 139ReadOnlySpan<char> value = ptr.Value.ToString(format); 148builder.Append($"0x{ptr.Value:x}".PadLeft(paddingFormat.Width, paddingFormat.FormatChar)); 157return T.CreateTruncating(value.Value).ToString($"{format}{paddingFormat.Width}", formatProvider: CultureInfo.InvariantCulture); 161return T.CreateTruncating(value.Value).ToString($"{format}", formatProvider: CultureInfo.InvariantCulture).PadLeft(paddingFormat.Width, paddingFormat.FormatChar); 167double value = BitConverter.UInt64BitsToDouble(valueAsBits.Value);

58_stackPointerBeforeFiltering = stackWalk.GetStackPointer(_dataFrames.Current).Value; 62_stackSizeSkipped = unchecked(stackWalk.GetStackPointer(_dataFrames.Current).Value - _stackPointerBeforeFiltering);

468: _target.ReadPointer(new TargetPointer(currentLocation.AddressOrValue)).Value; 655ulong offset = data.Value; 992baseAddress = address.Value; 997AddressOrValue = address.Value,

21return address.Value; 25return (ulong)(int)address.Value;

33private ulong CorDBDefaultEnCFunctionVersion => _target.ReadGlobalPointer(Constants.Globals.CorDBDefaultEnCFunctionVersion).Value; 314pTargetRefInfo->vmAssembly = targetAssembly.Value; 409pTargetBuffer->pAddress = targetSpan.Address.Value; 542pTargetBuffer->pAddress = buffer.Value; 585pData->vmAssembly = loader.GetAssembly(handle).Value; 586pData->vmPEAssembly = loader.GetPEAssembly(handle).Value; 593pData->pPEBaseAddress = baseAddress.Value; 636*pModule = modulePtr.Value; 809fpCallback(assembly.Value, pUserData); 811cdacAssemblies?.Add(assembly.Value); 1006*pRemoteContextAddr = espContext.Value; 1039fpCallback(currentThread.Value, pUserData); 1041cdacThreads?.Add(currentThread.Value); 1113*pRetVal = (void*)threadData.ThreadHandle.Value; 1143*pRetVal = threadData.ExposedObjectHandle.Value; 1172ulong limit = threadData.AllocContextLimit.Value; 1173ulong pointer = threadData.AllocContextPointer.Value; 1455*pRetVal = exceptionHandle.Value; 1505*pRetVal = objectHandle.Value; 1532*pRetVal = threadData.CurrentCustomDebuggerNotificationHandle.Value; 1595*pRetVal = loader.GetAssembly(referencedModuleHandle).Value; 1710*pRetVal = filterContext.Value; 1718*pRetVal = redirectedContext.Value; 1770sb.Append($" | SP cdac=0x{cdacCtx.StackPointer.Value:X16} dac=0x{dacCtx.StackPointer.Value:X16}"); 1771sb.Append($" | FP cdac=0x{cdacCtx.FramePointer.Value:X16} dac=0x{dacCtx.FramePointer.Value:X16}"); 2220data.fp = _target.Contracts.StackWalk.GetRuntimeFramePointer(handle).Value; 2221data.vmCurrentAppDomainToken = currentAppDomain.Value; 2243data.v.exactGenericArgsToken = _target.Contracts.StackWalk.GetExactGenericArgsToken(handle).Value; 2258data.v.funcData.vmAssembly = vmAssembly.Value; 2267data.v.jitFuncData.nativeStartAddressPtr = eman.GetStartAddress(cbh).Value; 2279data.v.jitFuncData.vmNativeCodeMethodDescToken = mdPtr.Value; 2280data.v.taAmbientESP = GetAmbientSP(handle, codeBlockHandle, (uint)nativeOffset).Value; 2284data.v.jitFuncData.fpParentOrSelf = _target.Contracts.StackWalk.GetFuncletRootId(handle, out uint parentNativeOffset).Value; 2411data.fp = frame.FrameAddress.Value; 2412data.vmCurrentAppDomainToken = currentAppDomain.Value; 2415data.stubFrame.vmAssembly = vmAssembly.Value; 2416data.stubFrame.vmMethodDesc = vmMethodDesc.Value; 2688*pArgBase = argBase.Value; 2689*pRetVal = new DacDbiTargetBuffer { pAddress = sigAddr.Value, cbSize = sigLen }; 2771*pRetVal = _target.Contracts.Object.GetMethodTableAddress(new TargetPointer(rawToken)).Value; 2850pTargetBuffer->pAddress = headerPtr.Value + (ulong)headerSize; 2964code = new TargetCodePointer(code.ToAddress(_target).Value); 2989NativeCodeVersionHandle nativeCodeVersion = codeVersions.GetNativeCodeVersionForIP(new TargetCodePointer(codeStart.Value)); 3277fd.m_vmFieldDesc = fdPtr.Value; 3314fd.m_pFldStaticAddress = addr.Value; 3514*pRetVal = loader.GetModuleLookupMapElement(moduleHandle, ModuleLookupMapKind.TypeDefToMethodTable, metadataToken, out var _).Value; 3517*pRetVal = loader.GetModuleLookupMapElement(moduleHandle, ModuleLookupMapKind.TypeRefToMethodTable, metadataToken, out var _).Value; 3562*pRetVal = th.Address.Value; 3617*pVmTypeHandle = th.Address.Value; 3895*pRetVal = rts.GetFieldDescThreadStaticAddress(fd, new TargetPointer(vmRuntimeThread)).Value; 3923*pRetVal = rts.GetFieldDescStaticAddress(fd, unboxValueTypes: false).Value; 3988pFieldData->m_vmFieldDesc = fieldDescPointer.Value; 3992pFieldData->m_pFldStaticAddress = fieldAddress.Value; 3999pFieldData->m_fldInstanceOffset = fieldAddress.Value - (objectAddr + offsetToVars); 4173*pVmModule = module.Value; 4263ulong vmAppDomain = _target.Contracts.Loader.GetAppDomain().Value; 4271frames.Add((vmAppDomain, vmAssembly.Value, frame.Ip.Value, methodDef, isLastForeign)); 4273fpCallback(vmAppDomain, vmAssembly.Value, frame.Ip.Value, methodDef, isLastForeign, pUserData); 4364itfPtrs.Add(unknown.Value); 4409*pObjRef = info.Data.Value; 4608*pRetVal = _target.Contracts.Debugger.GetDebuggerControlBlockAddress().Value; 4634*pRetVal = _target.ReadPointer(new TargetPointer(ptr)).Value; 5103segments.Add((gen0AllocStart.Value, heapData.AllocAllocated.Value, (int)CorDebugGenerationTypes.CorDebug_Gen0, heapIndex)); 5109segments.Add((raw.Start.Value, raw.End.Value, (int)ToCorDebugGenerationType(raw.Generation), heapIndex)); 5116segments.Add((gen1AllocStart.Value, gen0AllocStart.Value, (int)CorDebugGenerationTypes.CorDebug_Gen1, heapIndex)); 5118segments.Add((raw.Start.Value, gen1AllocStart.Value, (int)CorDebugGenerationTypes.CorDebug_Gen2, heapIndex)); 5391pType->token1 = mt.Value; 5542corField->id.token1 = rts.GetPrimitiveType(CorElementType.I).Address.Value; 5553corField->id.token1 = mtHandle.Address.Value; 5617pLayout->parentID.token1 = parentMT.Value; 5677pLayout->componentID.token1 = charTypeHandle.Address.Value; 5694pLayout->componentID.token1 = componentTypeHandle.Address.Value; 5899*pVmILCodeVersionNode = ilCodeVersion.ILCodeVersionNode.Value; 5962pCodeInfo->pAddress = headerPtr.Value + (ulong)headerSize; 6011*pVmNativeCodeVersionNode = nativeCodeVersion.CodeVersionNodeAddress.Value; 6049*pVmILCodeVersionNode = ilCodeVersion.ILCodeVersionNode.Value; 6085pData->pbIL = codeVersions.GetIL(ilCodeVersion).Value; 6089pData->rgInstrumentedMapEntries = mapEntries.Value; 6213*ppFunctionAssembly = _target.Contracts.Loader.GetAssembly(moduleHandle).Value; 6253*ppTargetObj = delegateInfo.TargetObject.Value; 6363*pVmAssembly = assemblyPtr.Value; 6392*pDiagnosticIP = info.DiagnosticIP.Value; 6393*pNextContinuation = info.Next.Value; 6725WriteLittleEndian(ref pTypeInfo->ClassTypeData_typeHandle, typeHandle.Address.Value); 6732WriteLittleEndian(ref pTypeInfo->ClassTypeData_vmAssembly, loader.GetAssembly(moduleHandle).Value); 6744WriteLittleEndian(ref pTypeInfo->NaryTypeData_typeHandle, typeHandle.Address.Value); 6764WriteLittleEndian(ref typeInfo.vmTypeHandle, typeHandle.Address.Value); 6780WriteLittleEndian(ref typeInfo.vmTypeHandle, typeHandle.Address.Value); 6786WriteLittleEndian(ref typeInfo.vmAssembly, loader.GetAssembly(moduleHandle).Value);

46if (seg.Start.Value >= seg.End.Value) 50while (currentObj.Value < seg.End.Value) 53if (!_cache.TryReadPointer(currentObj.Value + _methodTableOffset, out TargetPointer mt)) 58mt = new TargetPointer(mt.Value & _methodTableMask); 68if (currentObj.Value + size > seg.End.Value || size == 0) 76if (nextObj.Value > seg.End.Value) 98address = reportedAddr.Value, 100type = new COR_TYPEID { token1 = mt.Value, token2 = 0 }, 128if (!_cache.TryReadUInt32(objAddr.Value + numComponentsOffset, out uint numComponents))

61vmDomain = _appDomain.Value, 62objHnd = handle.Handle.Value, 121extraData = handle.Secondary.Value; 148vmDomain = _appDomain.Value, 156reference.pObject = stackRef.Object.Value | 1; 158reference.objHnd = stackRef.Address.Value;

826data->MethodStart = eman.GetStartAddress(cbh).Value; 3232data->metadataStart = readOnlyMetadata.Address.Value; 3311*nextNestedException = nextNestedExceptionLocal.Value; 3465data->ElementTypeHandle = element.Address.Value; 4189Address = refs[i].Address.Value, 4190Object = refs[i].Object.Value, 4192Source = refs[i].Source.Value, 4200StackPointer = refs[i].StackPointer.Value, 4877pCallback(block.Address.Value, (nuint)block.Size.Value, i == 1 ? Interop.BOOL.TRUE : Interop.BOOL.FALSE); 4879DebugTraverseLoaderHeapBlocks.Add((block.Address.Value, (nuint)block.Size.Value)); 5388arguments[i] = _target.ReadNUInt(basePtr.Value + (ulong)(i * _target.PointerSize)).Value;

74_target.ReadBuffer(functionEntries[i].Value, destination); 297*displacement = managedCodeAddr.ToAddress(_target).Value - eman.GetStartAddress(codeBlock).Value; 310TargetPointer methodDesc = eman.NonVirtualEntry2MethodDesc(new TargetCodePointer(entryPoint.Value)); 314*displacement = codeAddr.ToAddress(_target).Value - entryPoint;

180if (parentTypePointer.Value == 0)