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

193Descriptor subDescriptor = ReadContractDescriptor(subDescriptorAddress.Value, _dataTargetDelegates); 279NumericValue = descriptor.PointerData[global.NumericValue.Value].Value, 400if (dataTargetDelegates.ReadFromTarget(descriptorAddr.Value, descriptorBuffer) < 0) 401throw DescriptorMalformed($"Failed to read contract descriptor JSON at 0x{descriptorAddr.Value:x8}."); 427if (!TryReadPointer(pointerDataAddr.Value + (uint)(i * pointerSize), config, dataTargetDelegates, out pointerData[i])) 527Write<ulong>(address, value.Value); 529Write<uint>(address, checked((uint)value.Value)); 818=> 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);

55return (int)_target.Read<uint>(addr.Value); 61uint currentFlags = _target.Read<uint>(addr.Value); 62_target.Write<uint>(addr.Value, currentFlags | (uint)DebuggerControlFlag_1.PendingAttach); 68uint currentFlags = _target.Read<uint>(addr.Value); 71_target.Write<uint>(addr.Value, currentFlags | (uint)DebuggerControlFlag_1.Attached); 75_target.Write<uint>(addr.Value, currentFlags & ~((uint)DebuggerControlFlag_1.Attached | (uint)DebuggerControlFlag_1.PendingAttach)); 83return _target.Read<byte>(addr.Value.Value) != 0; 149ulong start = entry.StartAddress.Value; 211_target.WriteBuffer(remotePtr.Value, record.AsSpan(0, cbSize)); 238_target.WriteBuffer(espOSContext.Value, ctx.GetBytes()); 269new TargetNUInt(espContext.Value), 270new TargetNUInt(espRecord.Value), 272new TargetNUInt(userData.Value), 277ctx.InstructionPointer = new TargetCodePointer(pfnHijackFunction.Value); 309sp = 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);

64throw new InvalidOperationException($"Stack trace object 0x{stackTraceObj.Value:x} has no MethodTable.");

153return codeHeaderIndirect.Value <= stubCodeBlockLast; 260TargetPointer runtimeFunctionPtr = jitManager?.GetUnwindInfo(range, codeInfoHandle.Address.Value) ?? TargetPointer.Null; 286jitManager?.GetMethodRegionInfo(range, codeInfoHandle.Address.Value, out hotSize, out coldStart, out coldSize); 331if (((IExecutionManager)this).GetCodeKind(new TargetCodePointer(startAddress.Value)) == CodeKind.Interpreter) 368return jitManager?.GetUnwindInfo(range, codeInfoHandle.Address.Value) ?? TargetPointer.Null; 388return jitManager?.GetDebugInfo(range, codeInfoHandle.Address.Value, out hasFlagByte) ?? TargetPointer.Null; 401jitManager?.GetGCInfo(range, codeInfoHandle.Address.Value, out gcInfo, out gcVersion); 514TargetPointer jitManagerAddress = new(table.Context.Value & ~(ulong)3); 543RangeSection range = RangeSection.Find(_target, _topRangeSectionMap, _rangeSectionMapLookup, codeInfoHandle.Address.Value); 623isCatchAllHandler = 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);

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

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

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

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

121_infoHdrSize = (uint)(offset.Value - gcInfoAddress.Value); 564return new TargetPointer(GetOutermostBaseFP(fp).Value & ~SHADOW_SP_BITS); 569return new TargetPointer(sp.Value + CalculatePushedArgSizeAt(codeOffset)); 576TargetPointer pLocalloc = new(ebp.Value - GetLocallocSPOffset()); 580return new TargetPointer(ebp.Value - RawStackSize + (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; 68offsetToFirstChar = (uint)(str.FirstChar.Value - address.Value);

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

184ulong pageBase = instrPointer.Value & ~pageMask; 185ulong 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);

1245if (_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); 713ulong value = _target.ReadPointer(address).Value;

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

85uint controlPcRva = (uint)(context.Pc - imageBase.Value); 723ulong 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)

357return (icf.Datum.Value & mask) == mask; 384return frame.Datum != TargetPointer.Null && (frame.Datum.Value & 0x1) == 0; 388return ((long)frame.Datum.Value & ~0xffff) != 0; 545if (!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));

157if (frameIterator.CurrentFrameAddress.Value >= curSP.Value) 445TargetPointer slot = new(gcFrame.ObjRefs.Value + (ulong)i * pointerSize); 827handle.Context.StackPointer.Value < handle.FrameIter.CurrentFrameAddress.Value || 1007return handle.FrameIter.CurrentFrameAddress.Value < parentContext.StackPointer.Value; 1022TargetPointer contextAddress = _target.ReadPointer(slotAddress.Value); 1046ulong baseValue = (useFramePointer ? context.FramePointer : context.StackPointer).Value; 1187=> _target.ReadPointer(new TargetPointer(unchecked(baseAddress.Value + (ulong)(long)offset))); 1204ulong unwoundEsp = CallerStackPointer(handle).Value; 1219return new TargetPointer(hijacked.StackPointer.Value - pointerSize); 1319_target.ReadBuffer(filterContext.Value, buffer); 1352if (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)

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

38public 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);

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

30private ulong CorDBDefaultEnCFunctionVersion => _target.ReadGlobalPointer(Constants.Globals.CorDBDefaultEnCFunctionVersion).Value; 272pTargetRefInfo->vmAssembly = targetAssembly.Value; 369pTargetBuffer->pAddress = targetSpan.Address.Value; 499pTargetBuffer->pAddress = buffer.Value; 541pData->vmAssembly = loader.GetAssembly(handle).Value; 542pData->vmPEAssembly = loader.GetPEAssembly(handle).Value; 549pData->pPEBaseAddress = baseAddress.Value; 591*pModule = modulePtr.Value; 760fpCallback(assembly.Value, pUserData); 762cdacAssemblies?.Add(assembly.Value); 952*pRemoteContextAddr = espContext.Value; 984fpCallback(currentThread.Value, pUserData); 986cdacThreads?.Add(currentThread.Value); 1056*pRetVal = (void*)threadData.ThreadHandle.Value; 1085*pRetVal = threadData.ExposedObjectHandle.Value; 1113ulong limit = threadData.AllocContextLimit.Value; 1114ulong pointer = threadData.AllocContextPointer.Value; 1387*pRetVal = exceptionHandle.Value; 1436*pRetVal = objectHandle.Value; 1462*pRetVal = threadData.CurrentCustomDebuggerNotificationHandle.Value; 1520*pRetVal = loader.GetAssembly(referencedModuleHandle).Value; 1633*pRetVal = filterContext.Value; 1641*pRetVal = redirectedContext.Value; 1693sb.Append($" | SP cdac=0x{cdacCtx.StackPointer.Value:X16} dac=0x{dacCtx.StackPointer.Value:X16}"); 1694sb.Append($" | FP cdac=0x{cdacCtx.FramePointer.Value:X16} dac=0x{dacCtx.FramePointer.Value:X16}"); 2136data.fp = _target.Contracts.StackWalk.GetRuntimeFramePointer(handle).Value; 2137data.vmCurrentAppDomainToken = currentAppDomain.Value; 2159data.v.exactGenericArgsToken = _target.Contracts.StackWalk.GetExactGenericArgsToken(handle).Value; 2174data.v.funcData.vmAssembly = vmAssembly.Value; 2183data.v.jitFuncData.nativeStartAddressPtr = eman.GetStartAddress(cbh).Value; 2195data.v.jitFuncData.vmNativeCodeMethodDescToken = mdPtr.Value; 2196data.v.taAmbientESP = GetAmbientSP(handle, codeBlockHandle, (uint)nativeOffset).Value; 2200data.v.jitFuncData.fpParentOrSelf = _target.Contracts.StackWalk.GetFuncletRootId(handle, out uint parentNativeOffset).Value; 2325data.fp = frame.FrameAddress.Value; 2326data.vmCurrentAppDomainToken = currentAppDomain.Value; 2329data.stubFrame.vmAssembly = vmAssembly.Value; 2330data.stubFrame.vmMethodDesc = vmMethodDesc.Value; 2597*pArgBase = argBase.Value; 2598*pRetVal = new DacDbiTargetBuffer { pAddress = sigAddr.Value, cbSize = sigLen }; 2678*pRetVal = _target.Contracts.Object.GetMethodTableAddress(new TargetPointer(rawToken)).Value; 2753pTargetBuffer->pAddress = headerPtr.Value + (ulong)headerSize; 2865code = new TargetCodePointer(code.ToAddress(_target).Value); 2890NativeCodeVersionHandle nativeCodeVersion = codeVersions.GetNativeCodeVersionForIP(new TargetCodePointer(codeStart.Value)); 3172fd.m_vmFieldDesc = fdPtr.Value; 3209fd.m_pFldStaticAddress = addr.Value; 3407*pRetVal = loader.GetModuleLookupMapElement(lookupTables.TypeDefToMethodTable, metadataToken, out var _).Value; 3410*pRetVal = loader.GetModuleLookupMapElement(lookupTables.TypeRefToMethodTable, metadataToken, out var _).Value; 3454*pRetVal = th.Address.Value; 3508*pVmTypeHandle = th.Address.Value; 3784*pRetVal = rts.GetFieldDescThreadStaticAddress(fd, new TargetPointer(vmRuntimeThread)).Value; 3811*pRetVal = rts.GetFieldDescStaticAddress(fd, unboxValueTypes: false).Value; 3872pFieldData->m_vmFieldDesc = fieldDescPointer.Value; 3876pFieldData->m_pFldStaticAddress = fieldAddress.Value; 3883pFieldData->m_fldInstanceOffset = fieldAddress.Value - (objectAddr + offsetToVars); 4056*pVmModule = module.Value; 4144ulong vmAppDomain = _target.Contracts.Loader.GetAppDomain().Value; 4152frames.Add((vmAppDomain, vmAssembly.Value, frame.Ip.Value, methodDef, isLastForeign)); 4154fpCallback(vmAppDomain, vmAssembly.Value, frame.Ip.Value, methodDef, isLastForeign, pUserData); 4243itfPtrs.Add(unknown.Value); 4287*pObjRef = info.Data.Value; 4483*pRetVal = _target.Contracts.Debugger.GetDebuggerControlBlockAddress().Value; 4508*pRetVal = _target.ReadPointer(new TargetPointer(ptr)).Value; 4960segments.Add((gen0AllocStart.Value, heapData.AllocAllocated.Value, (int)CorDebugGenerationTypes.CorDebug_Gen0, heapIndex)); 4966segments.Add((raw.Start.Value, raw.End.Value, (int)ToCorDebugGenerationType(raw.Generation), heapIndex)); 4973segments.Add((gen1AllocStart.Value, gen0AllocStart.Value, (int)CorDebugGenerationTypes.CorDebug_Gen1, heapIndex)); 4975segments.Add((raw.Start.Value, gen1AllocStart.Value, (int)CorDebugGenerationTypes.CorDebug_Gen2, heapIndex)); 5243pType->token1 = mt.Value; 5392corField->id.token1 = rts.GetPrimitiveType(CorElementType.I).Address.Value; 5403corField->id.token1 = mtHandle.Address.Value; 5466pLayout->parentID.token1 = parentMT.Value; 5525pLayout->componentID.token1 = charTypeHandle.Address.Value; 5542pLayout->componentID.token1 = componentTypeHandle.Address.Value; 5711*pVmILCodeVersionNode = ilCodeVersion.ILCodeVersionNode.Value; 5774pCodeInfo->pAddress = headerPtr.Value + (ulong)headerSize; 5822*pVmNativeCodeVersionNode = nativeCodeVersion.CodeVersionNodeAddress.Value; 5859*pVmILCodeVersionNode = ilCodeVersion.ILCodeVersionNode.Value; 5894pData->pbIL = codeVersions.GetIL(ilCodeVersion).Value; 5898pData->rgInstrumentedMapEntries = mapEntries.Value; 6019*ppFunctionAssembly = _target.Contracts.Loader.GetAssembly(moduleHandle).Value; 6058*ppTargetObj = delegateInfo.TargetObject.Value; 6165*pVmAssembly = assemblyPtr.Value; 6193*pDiagnosticIP = info.DiagnosticIP.Value; 6194*pNextContinuation = info.Next.Value; 6524WriteLittleEndian(ref pTypeInfo->ClassTypeData_typeHandle, typeHandle.Address.Value); 6531WriteLittleEndian(ref pTypeInfo->ClassTypeData_vmAssembly, loader.GetAssembly(moduleHandle).Value); 6543WriteLittleEndian(ref pTypeInfo->NaryTypeData_typeHandle, typeHandle.Address.Value); 6563WriteLittleEndian(ref typeInfo.vmTypeHandle, typeHandle.Address.Value); 6579WriteLittleEndian(ref typeInfo.vmTypeHandle, typeHandle.Address.Value); 6585WriteLittleEndian(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;

806data->MethodStart = eman.GetStartAddress(cbh).Value; 3140data->metadataStart = readOnlyMetadata.Address.Value; 3224*nextNestedException = nextNestedExceptionLocal.Value; 3376data->ElementTypeHandle = element.Address.Value; 4082Address = refs[i].Address.Value, 4083Object = refs[i].Object.Value, 4085Source = refs[i].Source.Value, 4093StackPointer = refs[i].StackPointer.Value, 4757pCallback(block.Address.Value, (nuint)block.Size.Value, i == 1 ? Interop.BOOL.TRUE : Interop.BOOL.FALSE); 4759DebugTraverseLoaderHeapBlocks.Add((block.Address.Value, (nuint)block.Size.Value)); 5259arguments[i] = _target.ReadNUInt(basePtr.Value + (ulong)(i * _target.PointerSize)).Value;

72_target.ReadBuffer(functionEntries[i].Value, destination); 259TargetPointer methodDesc = eman.NonVirtualEntry2MethodDesc(new TargetCodePointer(entryPoint.Value)); 263*displacement = codeAddr.ToAddress(_target).Value - entryPoint;

180if (parentTypePointer.Value == 0)