[Flags]
public enum SourceTypes : uint
{
    Default = 0x00, // To indicate that nothing else applies
    StackEmpty = 0x01, // The stack is empty here
    CallInstruction = 0x02  // The actual instruction of a call
    Async = 0x04 // (Version 2+) Indicates suspension/resumption for an async call
}

public readonly struct OffsetMapping
{
    public uint NativeOffset { get; init; }
    public uint ILOffset { get; init; }
    public SourceTypes SourceType { get; init; }
}

// Returns true if the method at pCode has debug info associated with it.
// Methods such as ILStubs may be JIT-compiled but have no debug metadata.
bool HasDebugInfo(TargetCodePointer pCode);

// Given a code pointer, return the associated native/IL offset mapping and codeOffset.
// If preferUninstrumented, will always read the uninstrumented bounds.
// Otherwise will read the instrumented bounds and fallback to the uninstrumented bounds.
IEnumerable<OffsetMapping> GetMethodNativeMap(TargetCodePointer pCode, bool preferUninstrumented, out uint codeOffset);

bool IDebugInfo.HasDebugInfo(TargetCodePointer pCode)
{
    if (_eman.GetCodeBlockHandle(pCode) is not CodeBlockHandle cbh)
        return false;

    return _eman.GetDebugInfo(cbh, out _) != TargetPointer.Null;
}

IEnumerable<OffsetMapping> IDebugInfo.GetMethodNativeMap(TargetCodePointer pCode, bool preferUninstrumented, out uint codeOffset)
{
    // Get the method's DebugInfo
    if (_eman.GetCodeBlockHandle(pCode) is not CodeBlockHandle cbh)
        throw new InvalidOperationException($"No CodeBlockHandle found for native code {pCode}.");
    TargetPointer debugInfo = _eman.GetDebugInfo(cbh, out bool hasFlagByte);

    TargetCodePointer nativeCodeStart = _eman.GetStartAddress(cbh);
    codeOffset = (uint)(CodePointerUtils.AddressFromCodePointer(pCode, _target) - CodePointerUtils.AddressFromCodePointer(nativeCodeStart, _target));

    // No debug info exists (e.g. ILStubs). Return empty sequence.
    // Callers that need to distinguish this case should use HasDebugInfo first.
    if (debugInfo == TargetPointer.Null)
        return [];

    return RestoreBoundaries(debugInfo, hasFlagByte, preferUninstrumented);
}

private IEnumerable<OffsetMapping> RestoreBoundaries(TargetPointer debugInfo, bool hasFlagByte, bool preferUninstrumented)
{
    if (hasFlagByte)
    {
        // Check flag byte and skip over any patchpoint info
        byte flagByte = _target.Read<byte>(debugInfo++);

        if ((flagByte & EXTRA_DEBUG_INFO_PATCHPOINT) != 0)
        {
            uint localCount = _target.Read<uint>(debugInfo + /*PatchpointInfo::LocalCount offset*/)
            debugInfo += /*size of PatchpointInfo*/ + (localCount * 4);
        }

        if ((flagByte & EXTRA_DEBUG_INFO_RICH) != 0)
        {
            uint richDebugInfoSize = _target.Read<uint>(debugInfo);
            debugInfo += 4;
            debugInfo += richDebugInfoSize;
        }
    }

    NativeReader nibbleNativeReader = new(new TargetStream(_target, debugInfo, 24 /*maximum size of 4 32bit ints compressed*/), _target.IsLittleEndian);
    NibbleReader nibbleReader = new(nibbleNativeReader, 0);

    uint cbBounds = nibbleReader.ReadUInt();
    uint cbUninstrumentedBounds = 0;
    if (cbBounds == DEBUG_INFO_BOUNDS_HAS_INSTRUMENTED_BOUNDS)
    {
        // This means we have instrumented bounds.
        cbBounds = nibbleReader.ReadUInt();
        cbUninstrumentedBounds = nibbleReader.ReadUInt();
    }
    uint _ /*cbVars*/ = nibbleReader.ReadUInt();

    TargetPointer addrBounds = debugInfo + (uint)nibbleReader.GetNextByteOffset();
    // TargetPointer addrVars = addrBounds + cbBounds + cbUninstrumentedBounds;

    if (preferUninstrumented && cbUninstrumentedBounds != 0)
    {
        // If we have uninstrumented bounds, we will use them instead of the regular bounds.
        addrBounds += cbBounds;
        cbBounds = cbUninstrumentedBounds;
    }

    if (cbBounds > 0)
    {
        NativeReader boundsNativeReader = new(new TargetStream(_target, addrBounds, cbBounds), _target.IsLittleEndian);
        return DoBounds(boundsNativeReader);
    }

    return Enumerable.Empty<OffsetMapping>();
}

private static IEnumerable<OffsetMapping> DoBounds(NativeReader nativeReader)
{
    NibbleReader reader = new(nativeReader, 0);

    uint boundsEntryCount = reader.ReadUInt();

    uint bitsForNativeDelta = reader.ReadUInt() + 1; // Number of bits needed for native deltas
    uint bitsForILOffsets = reader.ReadUInt() + 1; // Number of bits needed for IL offsets

    uint bitsPerEntry = bitsForNativeDelta + bitsForILOffsets + SOURCE_TYPE_BITS; // 2 bits for source type
    ulong bitsMeaningfulMask = (1UL << ((int)bitsPerEntry)) - 1;
    int offsetOfActualBoundsData = reader.GetNextByteOffset();

    uint bitsCollected = 0;
    ulong bitTemp = 0;
    uint curBoundsProcessed = 0;

    uint previousNativeOffset = 0;

    while (curBoundsProcessed < boundsEntryCount)
    {
        bitTemp |= ((uint)nativeReader[offsetOfActualBoundsData++]) << (int)bitsCollected;
        bitsCollected += 8;
        while (bitsCollected >= bitsPerEntry)
        {
            ulong mappingDataEncoded = bitsMeaningfulMask & bitTemp;
            bitTemp >>= (int)bitsPerEntry;
            bitsCollected -= bitsPerEntry;

            SourceTypes sourceType = (mappingDataEncoded & 0x3) switch
            {
                0 => SourceTypes.SourceTypeInvalid,
                1 => SourceTypes.CallInstruction,
                2 => SourceTypes.StackEmpty,
                3 => SourceTypes.StackEmpty | SourceTypes.CallInstruction,
                _ => throw new InvalidOperationException($"Unknown source type encoding: {mappingDataEncoded & 0x3}")
            };

            mappingDataEncoded >>= (int)SOURCE_TYPE_BITS;
            uint nativeOffsetDelta = (uint)(mappingDataEncoded & ((1UL << (int)bitsForNativeDelta) - 1));
            previousNativeOffset += nativeOffsetDelta;
            uint nativeOffset = previousNativeOffset;

            mappingDataEncoded >>= (int)bitsForNativeDelta;
            uint ilOffset = (uint)mappingDataEncoded + IL_OFFSET_BIAS;

            yield return new OffsetMapping()
            {
                NativeOffset = nativeOffset,
                ILOffset = ilOffset,
                SourceType = sourceType
            };
            curBoundsProcessed++;
        }
    }
}

BoundsStart = debugInfo + headerBytesConsumed
VarsStart = BoundsStart + BoundsSize
UninstrumentedBoundsStart = VarsStart + VarsSize
PatchpointInfoStart = UninstrumentedBoundsStart + UninstrumentedBoundsSize
RichDebugInfoStart = PatchpointInfoStart + PatchpointInfoSize
AsyncInfoStart = RichDebugInfoStart + RichDebugInfoSize
DebugInfoEnd = AsyncInfoStart + AsyncInfoSize

SourceTypes sourceType = 0;
if ((encoded & 0x1) != 0) sourceType |= SourceTypes.CallInstruction;
if ((encoded & 0x2) != 0) sourceType |= SourceTypes.StackEmpty;
if ((encoded & 0x4) != 0) sourceType |= SourceTypes.Async; // New bit