private void DecodeStackSlots(byte[] image, Machine machine, GcInfoTypes gcInfoTypes, uint nSlots, bool isUntracked, ref int bitOffset)
{
// We have stack slots left and more room to predecode
GcStackSlotBase spBase = (GcStackSlotBase)NativeReader.ReadBits(image, 2, ref bitOffset);
int normSpOffset = NativeReader.DecodeVarLengthSigned(image, gcInfoTypes.STACK_SLOT_ENCBASE, ref bitOffset);
int spOffset = gcInfoTypes.DenormalizeStackSlot(normSpOffset);
GcSlotFlags flags = (GcSlotFlags)NativeReader.ReadBits(image, 2, ref bitOffset);
GcSlots.Add(new GcSlot(-1, new GcStackSlot(spOffset, spBase), flags, isUntracked));
for (int i = 1; i < nSlots; i++)
{
spBase = (GcStackSlotBase)NativeReader.ReadBits(image, 2, ref bitOffset);
if ((uint)flags != 0)
{
normSpOffset = NativeReader.DecodeVarLengthSigned(image, gcInfoTypes.STACK_SLOT_ENCBASE, ref bitOffset);
spOffset = gcInfoTypes.DenormalizeStackSlot(normSpOffset);
flags = (GcSlotFlags)NativeReader.ReadBits(image, 2, ref bitOffset);
}
else
{
int normSpOffsetDelta = NativeReader.DecodeVarLengthSigned(image, gcInfoTypes.STACK_SLOT_DELTA_ENCBASE, ref bitOffset);
normSpOffset += normSpOffsetDelta;
spOffset = gcInfoTypes.DenormalizeStackSlot(normSpOffset);
}
GcSlots.Add(new GcSlot(-1, new GcStackSlot(spOffset, spBase), flags, isUntracked));
}
}
public GcSlotTable(byte[] image, Machine machine, GcInfoTypes gcInfoTypes, ref int bitOffset)
{
if (NativeReader.ReadBits(image, 1, ref bitOffset) != 0)
{
NumRegisters = NativeReader.DecodeVarLengthUnsigned(image, gcInfoTypes.NUM_REGISTERS_ENCBASE, ref bitOffset);
}
if (NativeReader.ReadBits(image, 1, ref bitOffset) != 0)
{
NumStackSlots = NativeReader.DecodeVarLengthUnsigned(image, gcInfoTypes.NUM_STACK_SLOTS_ENCBASE, ref bitOffset);
NumUntracked = NativeReader.DecodeVarLengthUnsigned(image, gcInfoTypes.NUM_UNTRACKED_SLOTS_ENCBASE, ref bitOffset);
}
NumSlots = NumRegisters + NumStackSlots + NumUntracked;
GcSlots = new List <GcSlot>();
if (NumRegisters > 0)
{
DecodeRegisters(image, gcInfoTypes, ref bitOffset);
}
if ((NumStackSlots > 0) && (GcSlots.Count < gcInfoTypes.MAX_PREDECODED_SLOTS))
{
DecodeStackSlots(image, machine, gcInfoTypes, NumStackSlots, false, ref bitOffset);
}
if ((NumUntracked > 0) && (GcSlots.Count < gcInfoTypes.MAX_PREDECODED_SLOTS))
{
DecodeStackSlots(image, machine, gcInfoTypes, NumUntracked, true, ref bitOffset);
}
}
private IEnumerable <uint> EnumerateSafePoints(byte[] image, ref int bitOffset)
{
List <uint> safePoints = new List <uint>();
uint numBitsPerOffset = GcInfoTypes.CeilOfLog2(CodeLength);
for (int i = 0; i < NumSafePoints; i++)
{
uint normOffset = (uint)NativeReader.ReadBits(image, (int)numBitsPerOffset, ref bitOffset);
safePoints.Add(normOffset);
}
return(safePoints);
}
private void DecodeRegisters(byte[] image, GcInfoTypes gcInfoTypes, ref int bitOffset)
{
// We certainly predecode the first register
uint regNum = NativeReader.DecodeVarLengthUnsigned(image, gcInfoTypes.REGISTER_ENCBASE, ref bitOffset);
GcSlotFlags flags = (GcSlotFlags)NativeReader.ReadBits(image, 2, ref bitOffset);
GcSlots.Add(new GcSlot((int)regNum, null, flags));
for (int i = 1; i < NumRegisters; i++)
{
if ((uint)flags != 0)
{
regNum = NativeReader.DecodeVarLengthUnsigned(image, gcInfoTypes.REGISTER_ENCBASE, ref bitOffset);
flags = (GcSlotFlags)NativeReader.ReadBits(image, 2, ref bitOffset);
}
else
{
uint regDelta = NativeReader.DecodeVarLengthUnsigned(image, gcInfoTypes.REGISTER_DELTA_ENCBASE, ref bitOffset) + 1;
regNum += regDelta;
}
GcSlots.Add(new GcSlot((int)regNum, null, flags));
}
}
public GcInfo(byte[] image, int offset, Machine machine, ushort majorVersion)
{
Offset = offset;
_gcInfoTypes = new GcInfoTypes(machine);
SecurityObjectStackSlot = -1;
GSCookieStackSlot = -1;
PSPSymStackSlot = -1;
SecurityObjectStackSlot = -1;
GenericsInstContextStackSlot = -1;
StackBaseRegister = 0xffffffff;
SizeOfEditAndContinuePreservedArea = 0xffffffff;
ReversePInvokeFrameStackSlot = -1;
Version = ReadyToRunVersionToGcInfoVersion(majorVersion);
int bitOffset = offset * 8;
int startBitOffset = bitOffset;
ParseHeaderFlags(image, ref bitOffset);
if (Version >= MIN_GCINFO_VERSION_WITH_RETURN_KIND) // IsReturnKindAvailable
{
int returnKindBits = (_slimHeader) ? _gcInfoTypes.SIZE_OF_RETURN_KIND_SLIM : _gcInfoTypes.SIZE_OF_RETURN_KIND_FAT;
ReturnKind = (ReturnKinds)NativeReader.ReadBits(image, returnKindBits, ref bitOffset);
}
CodeLength = _gcInfoTypes.DenormalizeCodeLength((int)NativeReader.DecodeVarLengthUnsigned(image, _gcInfoTypes.CODE_LENGTH_ENCBASE, ref bitOffset));
if (_hasGSCookie)
{
uint normPrologSize = NativeReader.DecodeVarLengthUnsigned(image, _gcInfoTypes.NORM_PROLOG_SIZE_ENCBASE, ref bitOffset) + 1;
uint normEpilogSize = NativeReader.DecodeVarLengthUnsigned(image, _gcInfoTypes.NORM_PROLOG_SIZE_ENCBASE, ref bitOffset);
ValidRangeStart = normPrologSize;
ValidRangeEnd = (uint)CodeLength - normEpilogSize;
}
else if (_hasSecurityObject || _hasGenericsInstContext)
{
ValidRangeStart = NativeReader.DecodeVarLengthUnsigned(image, _gcInfoTypes.NORM_PROLOG_SIZE_ENCBASE, ref bitOffset) + 1;
ValidRangeEnd = ValidRangeStart + 1;
}
if (_hasSecurityObject)
{
SecurityObjectStackSlot = _gcInfoTypes.DenormalizeStackSlot(NativeReader.DecodeVarLengthSigned(image, _gcInfoTypes.SECURITY_OBJECT_STACK_SLOT_ENCBASE, ref bitOffset));
}
if (_hasGSCookie)
{
GSCookieStackSlot = _gcInfoTypes.DenormalizeStackSlot(NativeReader.DecodeVarLengthSigned(image, _gcInfoTypes.GS_COOKIE_STACK_SLOT_ENCBASE, ref bitOffset));
}
if (_hasPSPSym)
{
PSPSymStackSlot = _gcInfoTypes.DenormalizeStackSlot(NativeReader.DecodeVarLengthSigned(image, _gcInfoTypes.PSP_SYM_STACK_SLOT_ENCBASE, ref bitOffset));
}
if (_hasGenericsInstContext)
{
GenericsInstContextStackSlot = _gcInfoTypes.DenormalizeStackSlot(NativeReader.DecodeVarLengthSigned(image, _gcInfoTypes.GENERICS_INST_CONTEXT_STACK_SLOT_ENCBASE, ref bitOffset));
}
if (_hasStackBaseRegister && !_slimHeader)
{
StackBaseRegister = _gcInfoTypes.DenormalizeStackBaseRegister(NativeReader.DecodeVarLengthUnsigned(image, _gcInfoTypes.STACK_BASE_REGISTER_ENCBASE, ref bitOffset));
}
if (_hasSizeOfEditAndContinuePreservedArea)
{
SizeOfEditAndContinuePreservedArea = NativeReader.DecodeVarLengthUnsigned(image, _gcInfoTypes.SIZE_OF_EDIT_AND_CONTINUE_PRESERVED_AREA_ENCBASE, ref bitOffset);
}
if (_hasReversePInvokeFrame)
{
ReversePInvokeFrameStackSlot = NativeReader.DecodeVarLengthSigned(image, _gcInfoTypes.REVERSE_PINVOKE_FRAME_ENCBASE, ref bitOffset);
}
// FIXED_STACK_PARAMETER_SCRATCH_AREA (this macro is always defined in _gcInfoTypes.h)
if (!_slimHeader)
{
SizeOfStackOutgoingAndScratchArea = _gcInfoTypes.DenormalizeSizeOfStackArea(NativeReader.DecodeVarLengthUnsigned(image, _gcInfoTypes.SIZE_OF_STACK_AREA_ENCBASE, ref bitOffset));
}
// PARTIALLY_INTERRUPTIBLE_GC_SUPPORTED (this macro is always defined in _gcInfoTypes.h)
NumSafePoints = NativeReader.DecodeVarLengthUnsigned(image, _gcInfoTypes.NUM_SAFE_POINTS_ENCBASE, ref bitOffset);
if (!_slimHeader)
{
NumInterruptibleRanges = NativeReader.DecodeVarLengthUnsigned(image, _gcInfoTypes.NUM_INTERRUPTIBLE_RANGES_ENCBASE, ref bitOffset);
}
// PARTIALLY_INTERRUPTIBLE_GC_SUPPORTED (this macro is always defined in _gcInfoTypes.h)
SafePointOffsets = EnumerateSafePoints(image, ref bitOffset);
uint numBitsPerOffset = GcInfoTypes.CeilOfLog2(CodeLength);
bitOffset += (int)(NumSafePoints * numBitsPerOffset);
InterruptibleRanges = EnumerateInterruptibleRanges(image, _gcInfoTypes.INTERRUPTIBLE_RANGE_DELTA1_ENCBASE, _gcInfoTypes.INTERRUPTIBLE_RANGE_DELTA2_ENCBASE, ref bitOffset);
SlotTable = new GcSlotTable(image, machine, _gcInfoTypes, ref bitOffset);
Transitions = GetTranstions(image, ref bitOffset);
Size = bitOffset - startBitOffset;
_machine = machine;
}
