951 lines
41 KiB
C#
951 lines
41 KiB
C#
|
/*******************************************************************/
|
||
|
|
/* WARNING */
|
||
|
|
/* This file should be identical in the Bartok and Singularity */
|
||
|
|
/* depots. Master copy resides in Bartok Depot. Changes should be */
|
||
|
|
/* made to Bartok Depot and propagated to Singularity Depot. */
|
||
|
|
/*******************************************************************/
|
||
|
|
|
||
|
|
//
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
//
|
||
|
|
|
||
|
|
namespace System.GCs {
|
||
|
|
|
||
|
|
using System.Runtime.CompilerServices;
|
||
|
|
using System.Runtime.InteropServices;
|
||
|
|
using System.Threading;
|
||
|
|
|
||
|
|
using Microsoft.Bartok.Options;
|
||
|
|
using Microsoft.Bartok.Runtime;
|
||
|
|
|
||
|
|
#if SINGULARITY_KERNEL
|
||
|
|
using Microsoft.Singularity.X86;
|
||
|
|
#elif SINGULARITY_PROCESS
|
||
|
|
using Microsoft.Singularity.X86;
|
||
|
|
using Microsoft.Singularity.V1.Services;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
[NoCCtor]
|
||
|
|
[RequiredByBartok]
|
||
|
|
internal unsafe class CallStack
|
||
|
|
{
|
||
|
|
|
||
|
|
[Mixin(typeof(Thread))]
|
||
|
|
private class CallStackThread : Object {
|
||
|
|
[AccessedByRuntime("reference in brtstack.asm")]
|
||
|
|
internal UIntPtr asmStackBase; // Limit of thread's stack
|
||
|
|
[AccessedByRuntime("reference in brtstack.asm")]
|
||
|
|
internal UIntPtr asmStackLimit;
|
||
|
|
[AccessedByRuntime("reference in brtforgc.asm")]
|
||
|
|
internal unsafe TransitionRecord *asmStackMarker;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static CallStackThread MixinThread(Thread t) {
|
||
|
|
return (CallStackThread) (Object) t;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static UIntPtr StackBase(Thread t) {
|
||
|
|
return MixinThread(t).asmStackBase;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static void SetStackBase(Thread t, UIntPtr value) {
|
||
|
|
MixinThread(t).asmStackBase = value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static UIntPtr StackLimit(Thread t) {
|
||
|
|
return MixinThread(t).asmStackLimit;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static void SetStackLimit(Thread t, UIntPtr value) {
|
||
|
|
MixinThread(t).asmStackLimit = value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static TransitionRecord* StackMarker(Thread t)
|
||
|
|
{
|
||
|
|
return MixinThread(t).asmStackMarker;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if X86
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
[StructLayout(LayoutKind.Sequential)]
|
||
|
|
internal unsafe struct TransitionRecord {
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal TransitionRecord *oldTransitionRecord;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr callAddr;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr stackBottom;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr EBX;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr EDI;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr ESI;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr EBP;
|
||
|
|
}
|
||
|
|
#elif AMD64
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
[StructLayout(LayoutKind.Sequential)]
|
||
|
|
internal unsafe struct TransitionRecord {
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal TransitionRecord *oldTransitionRecord;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr callAddr;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr stackBottom;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr EBX;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr EDI;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr ESI;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr EBP;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr R12;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr R13;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr R14;
|
||
|
|
[AccessedByRuntime("referenced from halforgc.asm")]
|
||
|
|
internal UIntPtr R15;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
internal static Thread threadBeingProcessed;
|
||
|
|
|
||
|
|
private struct CalleeSaveLocations {
|
||
|
|
|
||
|
|
#if SINGULARITY_KERNEL
|
||
|
|
internal void SetCalleeSaves(ThreadContext *context) {
|
||
|
|
EBX.SetCalleeReg(&context->ebx);
|
||
|
|
EDI.SetCalleeReg(&context->edi);
|
||
|
|
ESI.SetCalleeReg(&context->esi);
|
||
|
|
EBP.SetCalleeReg(&context->ebp);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if X86
|
||
|
|
internal void SetCalleeSaves(TransitionRecord *transitionRecord)
|
||
|
|
{
|
||
|
|
EBX.SetCalleeReg(&transitionRecord->EBX);
|
||
|
|
EDI.SetCalleeReg(&transitionRecord->EDI);
|
||
|
|
ESI.SetCalleeReg(&transitionRecord->ESI);
|
||
|
|
EBP.SetCalleeReg(&transitionRecord->EBP);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ClearCalleeSaves() {
|
||
|
|
EBX.ClearCalleeReg();
|
||
|
|
ESI.ClearCalleeReg();
|
||
|
|
EDI.ClearCalleeReg();
|
||
|
|
EBP.ClearCalleeReg();
|
||
|
|
}
|
||
|
|
|
||
|
|
internal
|
||
|
|
void ScanLiveRegs(uint mask,
|
||
|
|
NonNullReferenceVisitor referenceVisitor)
|
||
|
|
{
|
||
|
|
EDI.ScanLiveReg((mask >> 2) & 0x3, referenceVisitor);
|
||
|
|
ESI.ScanLiveReg((mask >> 4) & 0x3, referenceVisitor);
|
||
|
|
EBX.ScanLiveReg((mask >> 0) & 0x3, referenceVisitor);
|
||
|
|
EBP.ScanLiveReg((mask >> 6) & 0x3, referenceVisitor);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void PopFrame(UIntPtr *framePointer,
|
||
|
|
uint calleeSaveMask,
|
||
|
|
bool framePointerOmitted)
|
||
|
|
{
|
||
|
|
UIntPtr *calleeSaveStart;
|
||
|
|
if (framePointerOmitted) {
|
||
|
|
calleeSaveStart = framePointer - 1;
|
||
|
|
} else {
|
||
|
|
VTable.Assert((calleeSaveMask & 0x10) == 0,
|
||
|
|
"EBP should not be callee saved");
|
||
|
|
calleeSaveStart = framePointer;
|
||
|
|
EBP.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x1) != 0) {
|
||
|
|
calleeSaveStart -=
|
||
|
|
sizeof(TransitionRecord) / sizeof(UIntPtr);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Note: the order in which these appear is important!
|
||
|
|
if ((calleeSaveMask & 0x2) != 0) {
|
||
|
|
EBX.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x10) != 0) {
|
||
|
|
EBP.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x8) != 0) {
|
||
|
|
ESI.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x4) != 0) {
|
||
|
|
EDI.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ClearFrame(uint calleeSaveMask,
|
||
|
|
bool framePointerOmitted)
|
||
|
|
{
|
||
|
|
if (!framePointerOmitted) {
|
||
|
|
VTable.Assert((calleeSaveMask & 0x10) == 0,
|
||
|
|
"EBP should not be callee saved");
|
||
|
|
EBP.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x2) != 0) {
|
||
|
|
EBX.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x10) != 0) {
|
||
|
|
EBP.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x8) != 0) {
|
||
|
|
ESI.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x4) != 0) {
|
||
|
|
EDI.ClearFrameReg();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#elif AMD64
|
||
|
|
internal void SetCalleeSaves(TransitionRecord *transitionRecord)
|
||
|
|
{
|
||
|
|
EBX.SetCalleeReg(&transitionRecord->EBX);
|
||
|
|
EDI.SetCalleeReg(&transitionRecord->EDI);
|
||
|
|
ESI.SetCalleeReg(&transitionRecord->ESI);
|
||
|
|
EBP.SetCalleeReg(&transitionRecord->EBP);
|
||
|
|
R12.SetCalleeReg(&transitionRecord->R12);
|
||
|
|
R13.SetCalleeReg(&transitionRecord->R13);
|
||
|
|
R14.SetCalleeReg(&transitionRecord->R14);
|
||
|
|
R15.SetCalleeReg(&transitionRecord->R15);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ClearCalleeSaves() {
|
||
|
|
EBX.ClearCalleeReg();
|
||
|
|
ESI.ClearCalleeReg();
|
||
|
|
EDI.ClearCalleeReg();
|
||
|
|
EBP.ClearCalleeReg();
|
||
|
|
R12.ClearCalleeReg();
|
||
|
|
R13.ClearCalleeReg();
|
||
|
|
R14.ClearCalleeReg();
|
||
|
|
R15.ClearCalleeReg();
|
||
|
|
}
|
||
|
|
|
||
|
|
internal
|
||
|
|
void ScanLiveRegs(uint mask,
|
||
|
|
NonNullReferenceVisitor referenceVisitor)
|
||
|
|
{
|
||
|
|
EDI.ScanLiveReg((mask >> 2) & 0x3, referenceVisitor);
|
||
|
|
ESI.ScanLiveReg((mask >> 4) & 0x3, referenceVisitor);
|
||
|
|
EBX.ScanLiveReg((mask >> 0) & 0x3, referenceVisitor);
|
||
|
|
R12.ScanLiveReg((mask >> 6) & 0x3, referenceVisitor);
|
||
|
|
R13.ScanLiveReg((mask >> 8) & 0x3, referenceVisitor);
|
||
|
|
R14.ScanLiveReg((mask >> 10) & 0x3, referenceVisitor);
|
||
|
|
R15.ScanLiveReg((mask >> 12) & 0x3, referenceVisitor);
|
||
|
|
EBP.ScanLiveReg((mask >> 14) & 0x3, referenceVisitor);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void PopFrame(UIntPtr *framePointer,
|
||
|
|
uint calleeSaveMask,
|
||
|
|
bool framePointerOmitted)
|
||
|
|
{
|
||
|
|
UIntPtr *calleeSaveStart;
|
||
|
|
if (framePointerOmitted) {
|
||
|
|
calleeSaveStart = framePointer - 1;
|
||
|
|
} else {
|
||
|
|
VTable.Assert((calleeSaveMask & 0x100) == 0,
|
||
|
|
"EBP should not be callee saved");
|
||
|
|
calleeSaveStart = framePointer;
|
||
|
|
EBP.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x1) != 0) {
|
||
|
|
calleeSaveStart -=
|
||
|
|
sizeof(TransitionRecord) / sizeof(UIntPtr);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Note: the order in which these appear is important!
|
||
|
|
if ((calleeSaveMask & 0x2) != 0) {
|
||
|
|
EBX.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x100) != 0) {
|
||
|
|
EBP.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x8) != 0) {
|
||
|
|
ESI.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x4) != 0) {
|
||
|
|
EDI.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x10) != 0) {
|
||
|
|
R12.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x20) != 0) {
|
||
|
|
R13.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x40) != 0) {
|
||
|
|
R14.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x80) != 0) {
|
||
|
|
R15.PopFrameReg(ref calleeSaveStart);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ClearFrame(uint calleeSaveMask,
|
||
|
|
bool framePointerOmitted)
|
||
|
|
{
|
||
|
|
if (!framePointerOmitted) {
|
||
|
|
VTable.Assert((calleeSaveMask & 0x100) == 0,
|
||
|
|
"EBP should not be callee saved");
|
||
|
|
EBP.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x2) != 0) {
|
||
|
|
EBX.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x100) != 0) {
|
||
|
|
EBP.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x8) != 0) {
|
||
|
|
ESI.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x4) != 0) {
|
||
|
|
EDI.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x10) != 0) {
|
||
|
|
R12.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x20) != 0) {
|
||
|
|
R13.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x40) != 0) {
|
||
|
|
R14.ClearFrameReg();
|
||
|
|
}
|
||
|
|
if ((calleeSaveMask & 0x80) != 0) {
|
||
|
|
R15.ClearFrameReg();
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
internal UIntPtr GetFramePointer()
|
||
|
|
{
|
||
|
|
return EBP.value;
|
||
|
|
}
|
||
|
|
|
||
|
|
private struct RegLocation
|
||
|
|
{
|
||
|
|
|
||
|
|
[Inline]
|
||
|
|
internal void SetCalleeReg(UIntPtr *regField)
|
||
|
|
{
|
||
|
|
this.pending = false;
|
||
|
|
this.value = *regField;
|
||
|
|
this.head = regField;
|
||
|
|
*regField = UIntPtr.Zero;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ClearCalleeReg()
|
||
|
|
{
|
||
|
|
VTable.Deny(this.pending);
|
||
|
|
UIntPtr *scan = this.head;
|
||
|
|
while (scan != null) {
|
||
|
|
UIntPtr temp = *scan;
|
||
|
|
*scan = value;
|
||
|
|
scan = (UIntPtr *) temp;
|
||
|
|
}
|
||
|
|
this.head = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ScanLiveReg(uint kind,
|
||
|
|
NonNullReferenceVisitor visitor)
|
||
|
|
{
|
||
|
|
switch (kind) {
|
||
|
|
case 0: {
|
||
|
|
// Value is not a traceable heap pointer
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1: {
|
||
|
|
// Value is a pointer variable
|
||
|
|
VTable.Deny(this.head == null);
|
||
|
|
if (value != UIntPtr.Zero) {
|
||
|
|
fixed (UIntPtr *valueField = &this.value) {
|
||
|
|
visitor.Visit(valueField);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ClearCalleeReg();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 2: {
|
||
|
|
// Value is unchanged since function entry
|
||
|
|
VTable.Deny(this.pending);
|
||
|
|
this.pending = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 3:
|
||
|
|
default: {
|
||
|
|
VTable.NotReached("ScanLiveReg 3 or default");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void PopFrameReg(ref UIntPtr *calleeSaveStart)
|
||
|
|
{
|
||
|
|
if (this.head != null && !this.pending) {
|
||
|
|
ClearCalleeReg();
|
||
|
|
}
|
||
|
|
if (this.head == null) {
|
||
|
|
this.value = *calleeSaveStart;
|
||
|
|
} else {
|
||
|
|
VTable.Assert(this.pending, "pending should be true");
|
||
|
|
VTable.Assert(*calleeSaveStart == this.value,
|
||
|
|
"values are not equal");
|
||
|
|
}
|
||
|
|
this.pending = false;
|
||
|
|
*calleeSaveStart = (UIntPtr) this.head;
|
||
|
|
this.head = calleeSaveStart;
|
||
|
|
calleeSaveStart--;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ClearFrameReg() {
|
||
|
|
UIntPtr *scan = this.head;
|
||
|
|
while (scan != null) {
|
||
|
|
UIntPtr temp = *scan;
|
||
|
|
*scan = value;
|
||
|
|
scan = (UIntPtr *) temp;
|
||
|
|
}
|
||
|
|
this.head = null;
|
||
|
|
this.pending = false;
|
||
|
|
this.value = UIntPtr.Zero;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal bool pending;
|
||
|
|
internal UIntPtr value;
|
||
|
|
internal UIntPtr *head;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
#if X86
|
||
|
|
RegLocation EBX;
|
||
|
|
RegLocation EDI;
|
||
|
|
RegLocation ESI;
|
||
|
|
RegLocation EBP;
|
||
|
|
#elif AMD64
|
||
|
|
RegLocation EBX;
|
||
|
|
RegLocation EDI;
|
||
|
|
RegLocation ESI;
|
||
|
|
RegLocation EBP;
|
||
|
|
RegLocation R12;
|
||
|
|
RegLocation R13;
|
||
|
|
RegLocation R14;
|
||
|
|
RegLocation R15;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
[RequiredByBartok]
|
||
|
|
private static int callSiteTableCount;
|
||
|
|
[AccessedByRuntime("referenced from halexn.cpp")]
|
||
|
|
private static UIntPtr *codeBaseStartTable;
|
||
|
|
[RequiredByBartok]
|
||
|
|
private static UIntPtr **returnAddressToCallSiteSetNumbers;
|
||
|
|
[RequiredByBartok]
|
||
|
|
private static int **callSiteSetCount;
|
||
|
|
|
||
|
|
private static int CallSiteTableNumber(UIntPtr returnAddr)
|
||
|
|
{
|
||
|
|
UIntPtr address = returnAddr;
|
||
|
|
for (int i = 0; i < callSiteTableCount; i++) {
|
||
|
|
UIntPtr baseAddress = codeBaseStartTable[i];
|
||
|
|
if (address < baseAddress) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
UIntPtr relativeAddress = address - baseAddress;
|
||
|
|
UIntPtr *ptr = returnAddressToCallSiteSetNumbers[i];
|
||
|
|
int callSiteCount = *(callSiteSetCount[i]);
|
||
|
|
if (relativeAddress >= ptr[0] &&
|
||
|
|
relativeAddress <= ptr[callSiteCount]) {
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static int CallSiteSetNumber(UIntPtr returnAddr, int index)
|
||
|
|
{
|
||
|
|
UIntPtr codeBaseAddr = codeBaseStartTable[index];
|
||
|
|
UIntPtr relativeAddr = returnAddr - codeBaseAddr;
|
||
|
|
UIntPtr *callSiteTable = returnAddressToCallSiteSetNumbers[index];
|
||
|
|
int callSiteCount = *(callSiteSetCount[index]);
|
||
|
|
int left = 0;
|
||
|
|
int right = callSiteCount;
|
||
|
|
// Loop invariant:
|
||
|
|
// callSiteTable[left] <= returnAddress < callSiteTable[right]
|
||
|
|
while (left < right-1) {
|
||
|
|
int mid = (left + right)/2;
|
||
|
|
if (callSiteTable[mid] <= relativeAddr) {
|
||
|
|
left = mid;
|
||
|
|
} else {
|
||
|
|
right = mid;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return left;
|
||
|
|
}
|
||
|
|
|
||
|
|
[StructLayout(LayoutKind.Sequential)]
|
||
|
|
private struct FullDescriptor {
|
||
|
|
internal UIntPtr mask;
|
||
|
|
internal int variableData;
|
||
|
|
}
|
||
|
|
|
||
|
|
private const uint ESCAPE32_TAG = 0x0;
|
||
|
|
private const uint ESCAPE16_TAG = 0x1;
|
||
|
|
private const uint ESCAPE8_TAG = 0x2;
|
||
|
|
|
||
|
|
// Check whether the specified stack frame contains the
|
||
|
|
// transition record: if so then we're done scanning this
|
||
|
|
// segment of the stack. NB: the caller must ensure that the
|
||
|
|
// framePointer has been recomputed in a
|
||
|
|
// framePointerOmitted-method.
|
||
|
|
private static bool FrameContainsTransitionRecord(UIntPtr *framePointer,
|
||
|
|
UIntPtr *stackPointer,
|
||
|
|
TransitionRecord *stopMarker) {
|
||
|
|
bool result = false;
|
||
|
|
if ((framePointer >= stopMarker) && (stackPointer < stopMarker)) {
|
||
|
|
result = true;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns the return address in the calling method
|
||
|
|
private static
|
||
|
|
bool WalkStackFrame(ref UIntPtr *framePointer,
|
||
|
|
ref UIntPtr *stackPointer,
|
||
|
|
ref CalleeSaveLocations calleeSaves,
|
||
|
|
ref UIntPtr returnAddr,
|
||
|
|
NonNullReferenceVisitor threadReferenceVisitor,
|
||
|
|
NonNullReferenceVisitor pinnedReferenceVisitor,
|
||
|
|
UIntPtr frameDescriptorEntryPtr,
|
||
|
|
TransitionRecord *stopMarker,
|
||
|
|
Thread thread)
|
||
|
|
// BUGBUG: Remove thread argument when ThreadContext is on stack!
|
||
|
|
{
|
||
|
|
Trace.Log(Trace.Area.Stack,
|
||
|
|
"WalkStackFrame: fp={0:x}, sp={1:x}, returnAddr={2:x}, desc={3:x}",
|
||
|
|
__arglist(framePointer, stackPointer,
|
||
|
|
returnAddr, frameDescriptorEntryPtr));
|
||
|
|
bool framePointerOmitted;
|
||
|
|
uint liveRegs, calleeSaveMask;
|
||
|
|
//uint frameDescriptorEntry = (uint) frameDescriptorEntryPtr;
|
||
|
|
UIntPtr frameDescriptorEntry = frameDescriptorEntryPtr;
|
||
|
|
if ((frameDescriptorEntry & 0x1) != 0) {
|
||
|
|
// Compact descriptor
|
||
|
|
UIntPtr mask;
|
||
|
|
framePointerOmitted =
|
||
|
|
(((frameDescriptorEntry >> 1) & 0x1) != 0);
|
||
|
|
int inbetweenSlots;
|
||
|
|
if (framePointerOmitted) {
|
||
|
|
// No frame pointer
|
||
|
|
inbetweenSlots = Constants.InbetweenSlotsNoFP;
|
||
|
|
mask =
|
||
|
|
frameDescriptorEntry >> Constants.CompactStackBitMaskStartNoFP;
|
||
|
|
calleeSaveMask =
|
||
|
|
(uint)((frameDescriptorEntry >> Constants.CompactEntryMaskStart)
|
||
|
|
& Constants.CompactEntryMaskNoFP);
|
||
|
|
liveRegs = (uint)((frameDescriptorEntry >>
|
||
|
|
Constants.CompactCalleeSaveUseStartNoFP) &
|
||
|
|
Constants.CompactCalleeSaveUseMaskNoFP);
|
||
|
|
// when frame pointer is omitted, the stack top
|
||
|
|
// equals stackPointer plus frameSize
|
||
|
|
int frameSize =
|
||
|
|
unchecked((int)(frameDescriptorEntry >>
|
||
|
|
Constants.CompactFrameSizeStartNoFP) &
|
||
|
|
Constants.CompactFrameSizeMaskNoFP);
|
||
|
|
framePointer = stackPointer + frameSize;
|
||
|
|
} else {
|
||
|
|
// Use frame pointer
|
||
|
|
inbetweenSlots = Constants.InbetweenSlotsFP;
|
||
|
|
mask = frameDescriptorEntry >> Constants.CompactStackBitMaskStartFP;
|
||
|
|
calleeSaveMask =
|
||
|
|
(uint)((frameDescriptorEntry >> Constants.CompactEntryMaskStart)
|
||
|
|
& Constants.CompactEntryMaskFP);
|
||
|
|
liveRegs =
|
||
|
|
(uint) ((frameDescriptorEntry >>
|
||
|
|
Constants.CompactCalleeSaveUseStartFP) &
|
||
|
|
Constants.CompactCalleeSaveUseMaskFP);
|
||
|
|
}
|
||
|
|
|
||
|
|
Trace.Log(Trace.Area.Stack,
|
||
|
|
"Compact desc: fpo={0}, mask={1:x}, inbetweenSlots={2}, calleeSaveMask={3:x}, liveRegs={4:x}",
|
||
|
|
__arglist(framePointerOmitted, mask, inbetweenSlots,
|
||
|
|
calleeSaveMask, liveRegs));
|
||
|
|
if (FrameContainsTransitionRecord(framePointer,
|
||
|
|
stackPointer,
|
||
|
|
stopMarker)) {
|
||
|
|
return true; // true: done
|
||
|
|
}
|
||
|
|
uint stackArgSize =
|
||
|
|
(uint)((frameDescriptorEntry >> Constants.CompactArgMaskStart)
|
||
|
|
& Constants.CompactArgMask);
|
||
|
|
UIntPtr *p = framePointer + stackArgSize + inbetweenSlots;
|
||
|
|
Trace.Log(Trace.Area.Stack,
|
||
|
|
"Compact desc: stackArgSize={0:x}, p={1:x}",
|
||
|
|
__arglist(stackArgSize, p));
|
||
|
|
// Process the arguments
|
||
|
|
if (threadReferenceVisitor != null) {
|
||
|
|
for (int i = 0; mask != 0 && i <= stackArgSize; i++) {
|
||
|
|
if ((mask & 0x1) != 0 && *p != UIntPtr.Zero) {
|
||
|
|
// BUGBUG: threadReferenceVisitor.Visit(p);
|
||
|
|
VisitIfNotContext(thread, threadReferenceVisitor,
|
||
|
|
p);
|
||
|
|
}
|
||
|
|
mask >>= 1;
|
||
|
|
p--;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (int i = 0; mask != 0 && i <= stackArgSize; i++) {
|
||
|
|
mask >>= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Process the local variables
|
||
|
|
bool transitionRecord = ((calleeSaveMask & 0x1) != 0);
|
||
|
|
uint savedRegs = (uint) (calleeSaveMask >> 1);
|
||
|
|
uint countRegs = ((savedRegs & 1) +
|
||
|
|
((savedRegs >> 1) & 1) +
|
||
|
|
((savedRegs >> 2) & 1) +
|
||
|
|
((savedRegs >> 3) & 1) +
|
||
|
|
((savedRegs >> 4) & 1) +
|
||
|
|
((savedRegs >> 5) & 1) +
|
||
|
|
((savedRegs >> 6) & 1) +
|
||
|
|
((savedRegs >> 7) & 1));
|
||
|
|
int transitionRecordSize =
|
||
|
|
transitionRecord ?
|
||
|
|
sizeof(TransitionRecord)/sizeof(UIntPtr) :
|
||
|
|
0;
|
||
|
|
p = framePointer - 1 - countRegs - transitionRecordSize;
|
||
|
|
Trace.Log(Trace.Area.Stack,
|
||
|
|
"Compact desc: savedRegs={0:x}, countRegs={0:x}, transSize={0:x}, p={0:x}", __arglist(savedRegs, countRegs, transitionRecordSize));
|
||
|
|
if (threadReferenceVisitor != null) {
|
||
|
|
while (mask != 0) {
|
||
|
|
if ((mask & 1) != 0 && *p != UIntPtr.Zero) {
|
||
|
|
// BUGBUG: threadReferenceVisitor.Visit(p);
|
||
|
|
VisitIfNotContext(thread, threadReferenceVisitor,
|
||
|
|
p);
|
||
|
|
}
|
||
|
|
mask >>= 1;
|
||
|
|
p--;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Full descriptor
|
||
|
|
FullDescriptor *desc =
|
||
|
|
((FullDescriptor *) frameDescriptorEntryPtr);
|
||
|
|
UIntPtr mask = (UIntPtr) desc->mask;
|
||
|
|
framePointerOmitted = ((mask & 1) != 0);
|
||
|
|
bool pinnedVars;
|
||
|
|
uint frameTag;
|
||
|
|
if (framePointerOmitted) {
|
||
|
|
// no frame pointer
|
||
|
|
calleeSaveMask = (uint) ((mask >> Constants.FullEntryMaskStart) &
|
||
|
|
Constants.FullEntryMaskNoFP);
|
||
|
|
pinnedVars = (((mask >> Constants.FullPinnedPosNoFP) & 1) != 0);
|
||
|
|
liveRegs = (uint) (( mask >> Constants.FullCalleeSaveUseStartNoFP) &
|
||
|
|
Constants.FullCalleeSaveUseMaskNoFP);
|
||
|
|
frameTag = (uint) ((mask >> Constants.FullRecordSizePosNoFP) &
|
||
|
|
Constants.FullRecordMask);
|
||
|
|
// when frame pointer is omitted, the stack top
|
||
|
|
// equals stackPointer plus frameSize
|
||
|
|
int frameSize = unchecked((int)(mask >> Constants.FullFrameSizeStartNoFP));
|
||
|
|
framePointer = stackPointer + frameSize;
|
||
|
|
} else {
|
||
|
|
// use frame pointer
|
||
|
|
calleeSaveMask = (uint) ((mask >> Constants.FullEntryMaskStart) &
|
||
|
|
Constants.FullEntryMaskFP);
|
||
|
|
pinnedVars = (((mask >> Constants.FullPinnedPosFP) & 1) != 0);
|
||
|
|
liveRegs = (uint) (( mask >> Constants.FullCalleeSaveUseStartFP) &
|
||
|
|
Constants.FullCalleeSaveUseMaskFP);
|
||
|
|
frameTag = (uint) ((mask >> Constants.FullRecordSizePosFP) &
|
||
|
|
Constants.FullRecordMask);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FrameContainsTransitionRecord(framePointer,
|
||
|
|
stackPointer,
|
||
|
|
stopMarker)) {
|
||
|
|
return true; // true: done
|
||
|
|
}
|
||
|
|
switch (frameTag) {
|
||
|
|
case ESCAPE8_TAG: {
|
||
|
|
int count = *(byte *) &desc->variableData;
|
||
|
|
byte pinnedCount = *((byte*)&desc->variableData+1);
|
||
|
|
sbyte *offsets = (sbyte *)&desc->variableData+2;
|
||
|
|
if (threadReferenceVisitor != null) {
|
||
|
|
for (int i = 0; i < count; i++) {
|
||
|
|
UIntPtr *loc = framePointer + offsets[i];
|
||
|
|
if (*loc != UIntPtr.Zero) {
|
||
|
|
// BUGBUG: threadReferenceVisitor.Visit(loc);
|
||
|
|
VisitIfNotContext(thread, threadReferenceVisitor, loc);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (pinnedVars && pinnedReferenceVisitor != null) {
|
||
|
|
int last = count + pinnedCount;
|
||
|
|
for (int i = count; i < last; i++) {
|
||
|
|
UIntPtr *loc = framePointer + offsets[i];
|
||
|
|
if (*loc != UIntPtr.Zero) {
|
||
|
|
pinnedReferenceVisitor.Visit(loc);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case ESCAPE16_TAG: {
|
||
|
|
int count = *((short *) &desc->variableData);
|
||
|
|
short pinnedCount = *((short*)&desc->variableData+1);
|
||
|
|
short *offsets = (short *)&desc->variableData+2;
|
||
|
|
if (threadReferenceVisitor != null) {
|
||
|
|
for (int i = 0; i < count; i++) {
|
||
|
|
UIntPtr *loc = framePointer + offsets[i];
|
||
|
|
if (*loc != UIntPtr.Zero) {
|
||
|
|
// BUGBUG: threadReferenceVisitor.Visit(loc);
|
||
|
|
VisitIfNotContext(thread, threadReferenceVisitor, loc);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (pinnedVars && pinnedReferenceVisitor != null) {
|
||
|
|
int last = count + pinnedCount;
|
||
|
|
for (int i = count; i < last; i++) {
|
||
|
|
UIntPtr *loc = framePointer + offsets[i];
|
||
|
|
if (*loc != UIntPtr.Zero) {
|
||
|
|
pinnedReferenceVisitor.Visit(loc);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case ESCAPE32_TAG: {
|
||
|
|
int count = *((int *) &desc->variableData);
|
||
|
|
int pinnedCount = *((int *) &desc->variableData+1);
|
||
|
|
int *offsets = (int *) &desc->variableData+2;
|
||
|
|
if (threadReferenceVisitor != null) {
|
||
|
|
for (int i = 0; i < count; i++) {
|
||
|
|
UIntPtr *loc = framePointer + offsets[i];
|
||
|
|
if (*loc != UIntPtr.Zero) {
|
||
|
|
// BUGBUG: threadReferenceVisitor.Visit(loc);
|
||
|
|
VisitIfNotContext(thread, threadReferenceVisitor, loc);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (pinnedVars && pinnedReferenceVisitor != null) {
|
||
|
|
int last = count + pinnedCount;
|
||
|
|
for (int i = count; i < last; i++) {
|
||
|
|
UIntPtr *loc = framePointer + offsets[i];
|
||
|
|
if (*loc != UIntPtr.Zero) {
|
||
|
|
pinnedReferenceVisitor.Visit(loc);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: {
|
||
|
|
VTable.NotReached("GC mask switch failed");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (liveRegs != 0 && threadReferenceVisitor != null) {
|
||
|
|
calleeSaves.ScanLiveRegs(liveRegs, threadReferenceVisitor);
|
||
|
|
}
|
||
|
|
UIntPtr nextReturnAddr;
|
||
|
|
if (framePointerOmitted) {
|
||
|
|
nextReturnAddr = *framePointer;
|
||
|
|
stackPointer = framePointer + 1;
|
||
|
|
} else {
|
||
|
|
nextReturnAddr = *(framePointer + 1);
|
||
|
|
stackPointer = framePointer + 2;
|
||
|
|
}
|
||
|
|
// In Singularity, the final return address of a thread is zero
|
||
|
|
if (nextReturnAddr != UIntPtr.Zero) {
|
||
|
|
calleeSaves.PopFrame(framePointer, calleeSaveMask,
|
||
|
|
framePointerOmitted);
|
||
|
|
} else {
|
||
|
|
calleeSaves.ClearFrame(calleeSaveMask, framePointerOmitted);
|
||
|
|
}
|
||
|
|
UIntPtr *calcedfp = (UIntPtr *) calleeSaves.GetFramePointer();
|
||
|
|
if (calcedfp != null) {
|
||
|
|
framePointer = calcedfp;
|
||
|
|
}
|
||
|
|
returnAddr = nextReturnAddr;
|
||
|
|
return false; // false: not done scanning: proceed to next frame
|
||
|
|
}
|
||
|
|
|
||
|
|
#if SINGULARITY_PROCESS
|
||
|
|
// BUGBUG: Get rid of this when ThreadContext is on stack! --rusa
|
||
|
|
[Inline]
|
||
|
|
private static
|
||
|
|
void VisitIfNotContext(Thread thread,
|
||
|
|
NonNullReferenceVisitor threadReferenceVisitor,
|
||
|
|
UIntPtr *p)
|
||
|
|
{
|
||
|
|
if (*p != (UIntPtr) thread.context &&
|
||
|
|
(int *) *p != &thread.context->gcStates) {
|
||
|
|
threadReferenceVisitor.Visit(p);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
[Inline]
|
||
|
|
private static
|
||
|
|
void VisitIfNotContext(Thread thread,
|
||
|
|
NonNullReferenceVisitor threadReferenceVisitor,
|
||
|
|
UIntPtr *p)
|
||
|
|
{
|
||
|
|
threadReferenceVisitor.Visit(p);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
[RequiredByBartok]
|
||
|
|
private static ushort **callSetSiteNumberToIndex;
|
||
|
|
[RequiredByBartok]
|
||
|
|
private static UIntPtr **activationDescriptorTable;
|
||
|
|
|
||
|
|
[PreInitRefCounts]
|
||
|
|
internal static
|
||
|
|
int ScanStacks(NonNullReferenceVisitor VisitThreadReference,
|
||
|
|
NonNullReferenceVisitor VisitPinnedReference)
|
||
|
|
{
|
||
|
|
int limit = Thread.threadTable.Length;
|
||
|
|
int countThreads = 0;
|
||
|
|
for (int i = 0; i < limit; i++) {
|
||
|
|
Thread t = Thread.threadTable[i];
|
||
|
|
if (t != null) {
|
||
|
|
CollectorStatistics.Event(GCEvent.StackScanStart, i);
|
||
|
|
ScanStack(t, VisitThreadReference, VisitPinnedReference);
|
||
|
|
CollectorStatistics.Event(GCEvent.StackScanComplete, i);
|
||
|
|
countThreads++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return countThreads;
|
||
|
|
}
|
||
|
|
|
||
|
|
[PreInitRefCounts]
|
||
|
|
internal static
|
||
|
|
uint ScanStack(Thread thread,
|
||
|
|
NonNullReferenceVisitor VisitThreadReference,
|
||
|
|
NonNullReferenceVisitor VisitPinnedReference)
|
||
|
|
{
|
||
|
|
Trace.Log(Trace.Area.Stack,
|
||
|
|
"Scanning stack for thread {0:x}",
|
||
|
|
__arglist(thread.threadIndex));
|
||
|
|
|
||
|
|
uint numStackFrames = 0;
|
||
|
|
threadBeingProcessed = thread;
|
||
|
|
CalleeSaveLocations calleeSaves = new CalleeSaveLocations();
|
||
|
|
#if SINGULARITY_KERNEL
|
||
|
|
TransitionRecord *marker = (TransitionRecord *) thread.context.stackMarkers;
|
||
|
|
#elif SINGULARITY_PROCESS
|
||
|
|
TransitionRecord *marker = null;
|
||
|
|
if (thread.context != null) {
|
||
|
|
marker = (TransitionRecord *) thread.context->stackMarkers;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
TransitionRecord *marker = (TransitionRecord *)
|
||
|
|
MixinThread(thread).asmStackMarker;
|
||
|
|
#endif
|
||
|
|
while (marker != null) {
|
||
|
|
Trace.Log(Trace.Area.Stack,
|
||
|
|
"Transition record: old={0:x}, callAddr={1:x}, stackBottom={2:x}, EBX={3:x}, EDI={4:x}, ESI={5:x}, EBP={6:x}", __arglist(marker->oldTransitionRecord, marker->callAddr, marker->stackBottom, marker->EBX, marker->EDI, marker->ESI, marker->EBP));
|
||
|
|
|
||
|
|
TransitionRecord *stopMarker = marker->oldTransitionRecord;
|
||
|
|
UIntPtr returnAddr = marker->callAddr;
|
||
|
|
UIntPtr *fp = (UIntPtr *) marker->EBP;
|
||
|
|
UIntPtr *sp = (UIntPtr *) marker->stackBottom;
|
||
|
|
calleeSaves.SetCalleeSaves(marker);
|
||
|
|
numStackFrames +=
|
||
|
|
ScanStackSegment(ref calleeSaves, returnAddr, fp, sp,
|
||
|
|
stopMarker, VisitThreadReference,
|
||
|
|
VisitPinnedReference, thread);
|
||
|
|
marker = marker->oldTransitionRecord;
|
||
|
|
}
|
||
|
|
threadBeingProcessed = null;
|
||
|
|
return numStackFrames;
|
||
|
|
}
|
||
|
|
|
||
|
|
[PreInitRefCounts]
|
||
|
|
private static
|
||
|
|
uint ScanStackSegment(ref CalleeSaveLocations calleeSaves,
|
||
|
|
UIntPtr returnAddr,
|
||
|
|
UIntPtr *fp,
|
||
|
|
UIntPtr *sp,
|
||
|
|
TransitionRecord *stopMarker,
|
||
|
|
NonNullReferenceVisitor VisitThreadReference,
|
||
|
|
NonNullReferenceVisitor VisitPinnedReference,
|
||
|
|
Thread thread)
|
||
|
|
// BUGBUG: Remove thread argument when ThreadContext is on stack!
|
||
|
|
{
|
||
|
|
#if SINGULARITY
|
||
|
|
UIntPtr unlinkBegin;
|
||
|
|
UIntPtr unlinkLimit;
|
||
|
|
|
||
|
|
fixed (byte *begin =
|
||
|
|
&Microsoft.Singularity.Memory.Stacks.UnlinkStackBegin) {
|
||
|
|
unlinkBegin = (UIntPtr)begin;
|
||
|
|
}
|
||
|
|
fixed (byte *limit =
|
||
|
|
&Microsoft.Singularity.Memory.Stacks.UnlinkStackLimit) {
|
||
|
|
unlinkLimit = (UIntPtr)limit;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
uint numStackFrames = 0;
|
||
|
|
while (true) {
|
||
|
|
#if SINGULARITY
|
||
|
|
if (returnAddr >= unlinkBegin && returnAddr <= unlinkLimit) {
|
||
|
|
returnAddr = WalkStack(ref fp, ref sp);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Exit loop if we have reached the of the stack segment
|
||
|
|
if (fp >= stopMarker && sp < stopMarker) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
int tableIndex = CallSiteTableNumber(returnAddr);
|
||
|
|
if (tableIndex < 0) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
int callSiteSet = CallSiteSetNumber(returnAddr, tableIndex);
|
||
|
|
if (callSiteSet < 0) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
ushort *callSiteToIndexTable =
|
||
|
|
callSetSiteNumberToIndex[tableIndex];
|
||
|
|
int activationIndex = (int) callSiteToIndexTable[callSiteSet];
|
||
|
|
VTable.Assert(activationIndex >= 0);
|
||
|
|
UIntPtr *descriptorTable =
|
||
|
|
activationDescriptorTable[tableIndex];
|
||
|
|
UIntPtr frameDescriptorEntry = descriptorTable[activationIndex];
|
||
|
|
bool done = WalkStackFrame(ref fp, ref sp, ref calleeSaves,
|
||
|
|
ref returnAddr,
|
||
|
|
VisitThreadReference,
|
||
|
|
VisitPinnedReference,
|
||
|
|
frameDescriptorEntry,
|
||
|
|
stopMarker, thread);
|
||
|
|
if (done) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
numStackFrames++;
|
||
|
|
}
|
||
|
|
calleeSaves.ClearCalleeSaves();
|
||
|
|
return numStackFrames;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static UIntPtr WalkStack(ref UIntPtr *framePointer,
|
||
|
|
ref UIntPtr *stackPointer) {
|
||
|
|
// the frame pointer points to the ebp in the old frame
|
||
|
|
// since at the end of WalkStackFrame, it sets return addr
|
||
|
|
// and pop up a frame. However, since we are using linked
|
||
|
|
// stack, "pop up a frame" didn't actually set the frame
|
||
|
|
// to the caller's frame, it just goes from new frame to the
|
||
|
|
// old frame, therefore, we need to get return addr and pop
|
||
|
|
// a frame again.
|
||
|
|
stackPointer = framePointer + 2;
|
||
|
|
UIntPtr returnAddr = *(framePointer + 1);
|
||
|
|
framePointer = (UIntPtr*) *framePointer;
|
||
|
|
return returnAddr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|