modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/Kernel/Singularity/Memory/Stacks.cs

989 lines
40 KiB
C#
Raw Normal View History

RDK 1.1
2008-03-05 09:52:00 -05:00
////////////////////////////////////////////////////////////////////////////////
//
// Microsoft Research Singularity
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// File: Stacks.cs - Primitive stack segment manager
//
// Note:
//
//#define TEST_STACK_LINKING
//#define DEBUG_STACK_VERBOSE
#define NO_TRACE_STACKS
namespace Microsoft.Singularity.Memory
{
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;
using System.GCs;
using Microsoft.Singularity;
using Microsoft.Singularity.X86;
[NoCCtor]
[CLSCompliant(false)]
[RequiredByBartok]
internal class Stacks
{
// This constant gives a reasonable size for an initial stack
// chunk, leaving room for the metadata that will be added to
// the top of the stack (sizeof(StackHead)).
internal const int InitialStackSize = 0x1f00;
[AccessedByRuntime("referenced from halstack.asm")]
internal static int GetCount;
internal static int ReturnCount;
[StructLayout(LayoutKind.Sequential)]
internal struct StackHead
{
internal UIntPtr prevBegin;
internal UIntPtr prevLimit;
internal UIntPtr esp;
};
internal static unsafe void Initialize()
{
Tracing.Log(Tracing.Debug, "Stacks.Initialize() called");
GetCount = 0;
ReturnCount = 0;
}
internal static unsafe void Finalize()
{
unchecked {
Tracing.Log(Tracing.Debug, "Stacks.Finalize() GetStackSegment called {0} times.",
(UIntPtr)(uint)GetCount);
}
PrintCounts();
}
internal static void PrintCounts()
{
unchecked {
Tracing.Log(Tracing.Debug, "Segments: {1} links, {2} outstanding",
(UIntPtr)(uint)GetCount,
(UIntPtr)(uint)(GetCount - ReturnCount));
}
}
[AccessedByRuntime("referenced from halstack.asm")]
[NoStackLinkCheck]
internal static unsafe UIntPtr GetStackSegment(UIntPtr size,
ref ThreadContext context)
{
return GetStackSegment(size, ref context, false);
}
[NoStackLinkCheck]
internal static unsafe UIntPtr GetInitialStackSegment(ref ThreadContext context)
{
// The first stack segment is always in kernel memory
return GetStackSegment(0, ref context, true);
}
[NoStackLinkCheck]
internal static unsafe UIntPtr GetStackSegment(UIntPtr size,
ref ThreadContext context,
bool forceToKernel)
{
UIntPtr begin = context.stackBegin;
UIntPtr limit = context.stackLimit;
#if NO_TRACE_STACKS
#else
Kernel.Waypoint(666);
#endif
StackHead *head = GetStackSegmentRaw(size, ref context, forceToKernel);
if (head != null) {
head->prevBegin = begin;
head->prevLimit = limit;
head->esp = 0;
}
return (UIntPtr)head;
}
[NoStackLinkCheck]
internal static unsafe StackHead * GetStackSegmentRaw(UIntPtr size,
ref ThreadContext context,
bool forceToKernel)
{
// Allocate a new chunk, making room for StackHead at the top.
// If you change these constants to add more data, see the
// comment about InitialStackSize at the top of this file!
#if NO_TRACE_STACKS
#else
Kernel.Waypoint(667);
#endif
if (size == UIntPtr.Zero) {
size = InitialStackSize;
}
size = MemoryManager.PagePad(size + sizeof(StackHead));
UIntPtr chunk;
Process owner = Process.GetProcessByID(context.processId);
/*
// NOTE here's where we should be clever about
// whether to allocate a stack chunk in the user range
// or the kernel range. Except, if we switch contexts
// during an ABI call while using a user-range stack
// segment on a paging machine, we die. Gloss over
// this hackily by always getting stack segments
// from the kernel range.
if (forceToKernel || (owner == Process.kernelProcess)) {
chunk = MemoryManager.KernelAllocate(
MemoryManager.PagesFromBytes(size), owner, 0, PageType.Stack);
} else {
chunk = MemoryManager.UserAllocate(
MemoryManager.PagesFromBytes(size), owner, 0, PageType.Stack);
}
*/
chunk = MemoryManager.KernelAllocate(
MemoryManager.PagesFromBytes(size), owner, 0, PageType.Stack);
if (chunk != UIntPtr.Zero) {
// NB: We do _not_ zero out stack memory!
// We assume that Bartok prevents access to prev contents.
StackHead *head = (StackHead *)(chunk + size - sizeof(StackHead));
context.stackBegin = chunk + size;
context.stackLimit = chunk;
#if DEBUG_STACK_VERBOSE
Tracing.Log(Tracing.Debug, "GetStackSegmentRaw(size={0:d}) -> [{1,8:x}..{2,8:x}",
size, context.stackLimit, context.stackBegin);
#endif
GetCount++;
return head;
}
else {
// Stack allocation failed. In the future, we should
// trigger a kernel exception; for now, we break to the
// debugger.
DebugStub.Break();
return null;
}
}
[AccessedByRuntime("reference from halstack.asm")]
[NoStackLinkCheck]
// NB: This function must execute in low-stack conditions!
// See the comment at the top of this file.
// Returns the address of the stack with argsN pushed.
internal static unsafe UIntPtr GetStackSegmentAndCopy(UIntPtr size,
ref ThreadContext context,
uint *arg2,
uint args,
UIntPtr esp,
UIntPtr begin,
UIntPtr limit)
{
#if NO_TRACE_STACKS
#else
Kernel.Waypoint(668);
#endif
#if DEBUG_STACK_VERBOSE
fixed (ThreadContext *ptr = &context) {
DebugStub.Print("GetStackSegmentAndCopy(" +
"size={0},cxt={1:x8},arg={2:x8},num={3}," +
"esp={4:x8},beg={5:x8},lim={6:x8}\n",
__arglist((int)size,
(UIntPtr)ptr,
(UIntPtr)arg2,
(int)args,
esp,
begin,
limit));
}
#endif
StackHead *head = GetStackSegmentRaw(size, ref context, false);
if (head == null) {
// We are in serious trouble...
DebugStub.Break();
return (UIntPtr)head;
}
head->prevBegin = begin;
head->prevLimit = limit;
head->esp = esp;
arg2 += args;
uint *nsp = (uint *)head;
for (uint n = 0; n < args; n++) {
*--nsp = *--arg2;
}
#if DEBUG_STACK_VERBOSE
DebugStub.Print(" [old {0:x8}..{1:x8}..{2:x8}] {3:x8} {4:x8} {5:x8}\n",
__arglist(limit, (UIntPtr)(arg2 - 2), begin,
arg2[-2], arg2[-1], arg2[0]));
DebugStub.Print(" [raw {0:x8}..{1:x8}..{2:x8}]\n",
__arglist(context.stackLimit,
(UIntPtr)head,
context.stackBegin));
DebugStub.Print(" [new {0:x8}..{1:x8}..{2:x8}] {3:x8} {4:x8} {5:x8}\n",
__arglist(context.stackLimit,
(UIntPtr)nsp,
context.stackBegin,
nsp[0], nsp[1], nsp[2]));
DebugStub.Print(" [ret {0:x8}] {1:x8} {2:x8}\n",
__arglist((UIntPtr)(arg2 + args - 5),
arg2[-2], arg2[-1]));
#endif
return (UIntPtr)nsp;
}
[AccessedByRuntime("referenced from halstack.asm")]
[NoStackLinkCheck]
[NoStackOverflowCheck]
internal static unsafe void ReturnStackSegmentRaw(ref ThreadContext context,
UIntPtr begin,
UIntPtr limit)
{
StackHead *head = (StackHead *)(begin - sizeof(StackHead));
#if NO_TRACE_STACKS
#else
Kernel.Waypoint(669);
#endif
UIntPtr addr = limit;
UIntPtr size = begin - limit;
#if DEBUG_STACK_VERBOSE
fixed (ThreadContext *ptr = &context) {
DebugStub.Print("ReturnStackSegmentRaw(ctx={0:x8},beg={1:x8},lim={2:x8}\n",
__arglist((UIntPtr)ptr, begin, limit));
}
#if TEST_STACK_LINKING
DumpStack(Processor.GetFramePointer());
#endif
#endif
#if !PAGING
context.stackBegin = head->prevBegin;
context.stackLimit = head->prevLimit;
#else
//context.stackBegin = head->prevBegin;
//context.stackLimit = head->prevLimit;
// Moved below, because of the following scenario:
// - call UnlinkStack
// - UnlinkStack switches to the scheduler stack
// - UnlinkStack calls ReturnStackSegmentRaw, which calls
// various other methods
// - one of the other methods invokes write barrier code
// - the write barrier code performs a stack link check
// - If context.stackLimit is already set to head->prevLimit,
// then it may appear that we're out of stack space,
// even if we're really not, so we jump to LinkStack
// - LinkStack overwrites the scheduler stack
// TODO: really fix this.
UIntPtr stackBegin = head->prevBegin;
UIntPtr stackLimit = head->prevLimit;
#endif
Process owner = Process.GetProcessByID(context.processId);
/*
// See note above in GetStackSegmentRaw
if ((owner != Process.kernelProcess) &&
(addr >= BootInfo.KERNEL_BOUNDARY)) {
MemoryManager.UserFree(addr, MemoryManager.PagesFromBytes(size), owner);
} else {
MemoryManager.KernelFree(addr, MemoryManager.PagesFromBytes(size), owner);
}
*/
MemoryManager.KernelFree(addr, MemoryManager.PagesFromBytes(size), owner);
ReturnCount++;
#if DEBUG_STACK_VERBOSE
DebugStub.Print("ReturnStackSegment({0:x8}, {1:x8}\n",
__arglist(addr, size));
#endif
#if PAGING
// See comments above.
context.stackBegin = stackBegin;
context.stackLimit = stackLimit;
#endif
}
[AccessedByRuntime("referenced from halstack.asm")]
[NoStackLinkCheck]
[NoStackOverflowCheck]
// NB: This function must execute in low-stack conditions!
// See the comment at the top of this file.
internal static unsafe void ReturnStackSegment(ref ThreadContext context)
{
ReturnStackSegmentRaw(ref context, context.stackBegin, context.stackLimit);
}
internal static unsafe void WalkStack(UIntPtr ebp)
{
System.GCs.CallStack.TransitionRecord *kernMarker;
System.GCs.CallStack.TransitionRecord *procMarker;
kernMarker = Processor.GetCurrentThreadContext()->stackMarkers;
procMarker = Processor.GetCurrentThreadContext()->processMarkers;
UIntPtr ebpKern = kernMarker != null ? kernMarker->EBP : UIntPtr.Zero;
UIntPtr ebpProc = procMarker != null ? procMarker->EBP : UIntPtr.Zero;
#if DEBUG_STACK_VERBOSE
fixed (byte * begin = &LinkedStackBegin) {
fixed (byte * limit = &LinkedStackLimit) {
DebugStub.Print("LinkedStack: {0:x8}..{1:x8}\n",
__arglist((UIntPtr)begin, (UIntPtr)limit));
}
}
fixed (byte * begin = &LinkStackBegin) {
fixed (byte * limit = &LinkStackLimit) {
DebugStub.Print("LinkStack: {0:x8}..{1:x8}\n",
__arglist((UIntPtr)begin, (UIntPtr)limit));
}
}
fixed (byte * begin = &UnlinkStackBegin) {
fixed (byte * limit = &UnlinkStackLimit) {
DebugStub.Print("UnlinkStack: {0:x8}..{1:x8}\n",
__arglist((UIntPtr)begin, (UIntPtr)limit));
}
}
#endif
DebugStub.Print("EBP={0:x8}, kernMarkers={1:x8}, procMarkers={2:x8}\n",
__arglist(ebp, (UIntPtr)kernMarker, (UIntPtr)procMarker));
DebugStub.Print("EBP.....: EBP..... EIP..... transitn nexttran stbottom\n");
while (ebp != UIntPtr.Zero) {
if (ebp == ebpKern) {
DebugStub.Print("--kern--: {0:x8} {1:x8} {2:x8} {3:x8} {4:x8}\n",
__arglist(ebpKern,
(UIntPtr)kernMarker,
kernMarker->callAddr,
(UIntPtr)kernMarker->oldTransitionRecord,
kernMarker->stackBottom));
kernMarker = kernMarker->oldTransitionRecord;
ebpKern = kernMarker != null ? kernMarker->EBP : UIntPtr.Zero;
}
if (ebp == ebpProc) {
DebugStub.Print("--proc--: {0:x8} {1:x8} {2:x8} {3:x8} {4:x8}: \n",
__arglist(ebpProc,
(UIntPtr)procMarker,
procMarker->callAddr,
(UIntPtr)procMarker->oldTransitionRecord,
procMarker->stackBottom));
procMarker = procMarker->oldTransitionRecord;
ebpProc = procMarker != null ? procMarker->EBP : UIntPtr.Zero;
}
DebugStub.Print("{0:x8}: {1:x8} {2:x8}\n",
__arglist(ebp,
((UIntPtr*)ebp)[0], ((UIntPtr*)ebp)[1]));
if (((UIntPtr*)ebp)[1] == UIntPtr.Zero) {
break;
}
ebp = ((UIntPtr*)ebp)[0];
}
// DebugStub.Break();
}
//////////////////////////////////////////////////// LinkStackN Stubs.
//
// Note: As per the description in SDN20, the LinkStackN stubs use
// a non-standard calling convention. However, they are
// provided here to given Bartok a symbol to reference.
//
[ExternalStaticData]
internal static byte LinkedStackBegin;
[ExternalStaticData]
internal static byte LinkStackBegin;
[ExternalStaticData]
internal static byte LinkStackLimit;
[ExternalStaticData]
internal static byte UnlinkStackBegin;
[ExternalStaticData]
internal static byte UnlinkStackLimit;
[ExternalStaticData]
internal static byte LinkedStackLimit;
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[RequiredByBartok]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack0(); // Copy 0 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[RequiredByBartok]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack4(); // Copy 4 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[RequiredByBartok]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack8(); // Copy 8 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack12(); // Copy 12 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack16(); // Copy 16 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack20(); // Copy 20 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack24(); // Copy 24 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack28(); // Copy 28 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack32(); // Copy 32 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack36(); // Copy 36 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack40(); // Copy 40 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack44(); // Copy 44 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack48(); // Copy 48 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack52(); // Copy 52 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack56(); // Copy 56 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack60(); // Copy 60 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[RequiredByBartok]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void LinkStack64(); // Copy 64 bytes of arguments on stack.
////////////////////////////////////////////////// UnlinkStackN Stubs.
//
// Note: As per the description in SDN20, the UnlinkStackN stubs use
// a non-standard calling convention and should be referenced
// only by the LinkStackN stubs which insert them into the stack.
// However, they are provided here for completeness.
//
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack0(); // Remove 0 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack4(); // Remove 4 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack8(); // Remove 8 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack12(); // Remove 12 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack16(); // Remove 16 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack20(); // Remove 20 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack24(); // Remove 24 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack28(); // Remove 28 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack32(); // Remove 32 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack36(); // Remove 36 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack40(); // Remove 40 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack44(); // Remove 44 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack48(); // Remove 48 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack52(); // Remove 52 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack56(); // Remove 56 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack60(); // Remove 60 bytes of arguments on stack.
[StackBound(64)]
[NoStackLinkCheck]
[NoStackOverflowCheck]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void UnlinkStack64(); // Remove 64 bytes of arguments on stack.
#if TEST_STACK_LINKING
[NoStackLinkCheck]
internal static unsafe void TestStack()
{
ThreadContext *thread = Processor.GetCurrentThreadContext();
ProcessorContext *processor = Processor.GetCurrentProcessorContext();
UIntPtr oldLimit = thread->stackLimit;
UIntPtr newLimit = (Processor.GetStackPointer() - 512);
DebugStub.Print("************************************************************\n");
DebugStub.Print("threadContext={0:x8}, stackBegin={1:x8}, "+
"stackLimit={2:x8}, "+
"esp={3:x8}, stackLimit={4:x8}\n",
__arglist(
(UIntPtr)thread,
thread->stackBegin,
oldLimit,
Processor.GetStackPointer(),
newLimit));
DebugStub.Print("processorContext={0:x8}, "+
"schedulerStackBegin={1:x8},"+
"schedulerStackLimit={2:x8}\n",
__arglist(
(UIntPtr)processor,
processor->schedulerStackBegin,
processor->schedulerStackLimit));
DebugStub.Print("[TestStack.\n");
Test1(1);
DebugStub.Print(".TestStack]\n");
thread->stackLimit = oldLimit;
}
internal static unsafe void DumpStack(UIntPtr ebp)
{
ThreadContext *thread = Processor.GetCurrentThreadContext();
UIntPtr begin = thread->stackBegin;
DebugStub.Print(" [{0:x8}..{1:x8}]: "+
"{2:x8} {3:x8} {4:x8} {5:x8} {6:x8} {7:x8} {8:x8} {8:x8}\n",
__arglist(
ebp,
begin,
((uint*)ebp)[0],
((uint*)ebp)[1],
((uint*)ebp)[2],
((uint*)ebp)[3],
((uint*)ebp)[4],
((uint*)ebp)[5],
((uint*)ebp)[6],
((uint*)ebp)[7]));
}
[NoInline]
[StackLinkCheck]
internal static int Test1(int a)
{
DebugStub.Print("[Test1. ({0})\n", __arglist(a));
DumpStack(Processor.GetFramePointer());
TestStackLink1024();
a = Test2(a, a + 1) + 1;
DebugStub.Print(".Test1] = {0}\n", __arglist(a));
return a;
}
[OutsideGCDomain]
[NoInline]
[StackLinkCheck]
internal static int Test2(int a, int b)
{
DebugStub.Print("[Test2. ({0}, {1})\n",
__arglist(a, b));
DumpStack(Processor.GetFramePointer());
TestStackLink4096(); //TestStackLink1024();
a = Test3(a, a + 1, a + 2) + 1;
DebugStub.Print(".Test2] = {0}", __arglist(a));
return a;
}
[NoInline]
[StackLinkCheck]
internal static int Test3(int a, int b, int c)
{
DebugStub.Print("[Test3. ({0},{1},{2})",
__arglist(a, b, c));
DumpStack(Processor.GetFramePointer());
TestStackLink4096(); //TestStackLink1024();
a = Test4(a, a + 1, a + 2, a + 3) + 1;
DebugStub.Print(".Test3] = {0}", __arglist(a));
return a;
}
[OutsideGCDomain]
[NoInline]
[StackLinkCheck]
internal static int Test4(int a, int b, int c, int d)
{
DebugStub.Print("[Test4. ({0},{1},{2},{3})",
__arglist(a, b, c, d));
DumpStack(Processor.GetFramePointer());
TestStackLink4096(); //TestStackLink2048();
a = Test5(a, a + 1, a + 2, a + 3, a + 4) + 1;
DebugStub.Print(".Test4] = {0}", __arglist(a));
return a;
}
[NoInline]
[StackLinkCheck]
internal static int Test5(int a, int b, int c, int d, int e)
{
DebugStub.Print("[Test5. ({0},{1},{2},{3},{4})",
__arglist(a, b, c, d, e));
DumpStack(Processor.GetFramePointer());
TestStackLink4096(); //TestStackLink2048();
a = Test6(a, a + 1, a + 2, a + 3, a + 4, a + 5) + 1;
DebugStub.Print(".Test5] = {0}", __arglist(a));
return a;
}
[OutsideGCDomain]
[NoInline]
[StackLinkCheck]
internal static int Test6(int a, int b, int c, int d, int e, int f)
{
DebugStub.Print("[Test6. ({0},{1},{2},{3},{4},{5})",
__arglist(a, b, c, d, e, f));
DumpStack(Processor.GetFramePointer());
TestStackLink4096(); //TestStackLink2048();
a = Test7(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6) + 1;
DebugStub.Print(".Test6] = {0}", __arglist(a));
return a;
}
[NoInline]
[StackLinkCheck]
internal static int Test7(int a, int b, int c, int d, int e, int f,
int g)
{
DebugStub.Print("[Test7. ({0},{1},{2},{3},{4},{5},{6})",
__arglist(a, b, c, d, e, f, g));
DumpStack(Processor.GetFramePointer());
TestStackLink4096();
a = Test8(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7) + 1;
DebugStub.Print(".Test7] = {0}", __arglist(a));
return a;
}
[OutsideGCDomain]
[NoInline]
[StackLinkCheck]
internal static int Test8(int a, int b, int c, int d, int e, int f,
int g, int h)
{
DebugStub.Print("[Test8. ({0},{1},{2},{3},{4},{5},{6},{7})",
__arglist(a, b, c, d, e, f, g, h));
DumpStack(Processor.GetFramePointer());
TestStackLink4096();
a = Test9(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7,
a + 8) + 1;
DebugStub.Print(".Test8] = {0}", __arglist(a));
return a;
}
[NoInline]
[StackLinkCheck]
internal static int Test9(int a, int b, int c, int d, int e, int f,
int g, int h, int i)
{
DebugStub.Print("[Test9. ({0},{1},{2},{3},{4},{5},{6},{7},{8})",
__arglist(a, b, c, d, e, f, g, h, i));
DumpStack(Processor.GetFramePointer());
TestStackLink4096();
a = Test10(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7,
a + 8, a + 9) + 1;
DebugStub.Print(".Test9] = {0}", __arglist(a));
return a;
}
[OutsideGCDomain]
[NoInline]
[StackLinkCheck]
internal static int Test10(int a, int b, int c, int d, int e, int f,
int g, int h, int i, int j)
{
DebugStub.Print("[Test10. ({0},{1},{2},{3},{4},{5},{6},{7},{8},"+
"{9})",
__arglist(a, b, c, d, e, f, g, h, i, j));
DumpStack(Processor.GetFramePointer());
TestStackLink4096();
a = Test11(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7,
a + 8, a + 9, a + 10) + 1;
DebugStub.Print(".Test10] = {0}", __arglist(a));
return a;
}
[NoInline]
[StackLinkCheck]
internal static int Test11(int a, int b, int c, int d, int e, int f,
int g, int h, int i, int j, int k)
{
DebugStub.Print("[Test11. ({0},{1},{2},{3},{4},{5},{6},{7},{8},"+
"{9},{10})",
__arglist(a, b, c, d, e, f, g, h, i, j, k));
DumpStack(Processor.GetFramePointer());
TestStackLink4096();
a = Test12(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7,
a + 8, a + 9, a + 10, a + 11) + 1;
DebugStub.Print(".Test11] = {0}", __arglist(a));
return a;
}
[OutsideGCDomain]
[NoInline]
[StackLinkCheck]
internal static int Test12(int a, int b, int c, int d, int e, int f,
int g, int h, int i, int j, int k, int l)
{
DebugStub.Print("[Test12. ({0},{1},{2},{3},{4},{5},{6},{7},{8},"+
"{9},{10},{11})",
__arglist(a, b, c, d, e, f, g, h, i, j, k, l));
DumpStack(Processor.GetFramePointer());
TestStackLink4096();
a = Test13(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7,
a + 8, a + 9, a + 10, a + 11, a + 12) + 1;
DebugStub.Print(".Test12] = {0}", __arglist(a));
return a;
}
[NoInline]
[StackLinkCheck]
internal static int Test13(int a, int b, int c, int d, int e, int f,
int g, int h, int i, int j, int k, int l,
int m)
{
DebugStub.Print("[Test13. ({0},{1},{2},{3},{4},{5},{6},{7},{8},"+
"{9},{10},{11},{12})",
__arglist(a, b, c, d, e, f, g, h, i, j, k, l, m));
DumpStack(Processor.GetFramePointer());
TestStackLink4096();
a = Test14(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7,
a + 8, a + 9, a + 10, a + 11, a + 12, a + 13) + 1;
DebugStub.Print(".Test13] = {0}", __arglist(a));
return a;
}
[OutsideGCDomain]
[NoInline]
[StackLinkCheck]
internal static int Test14(int a, int b, int c, int d, int e, int f,
int g, int h, int i, int j, int k, int l,
int m, int n)
{
DebugStub.Print("[Test14. ({0},{1},{2},{3},{4},{5},{6},{7},{8},"+
"{9},{10},{11},{12},{13})",
__arglist(a, b, c, d, e, f, g, h, i, j, k, l,
m, n));
DumpStack(Processor.GetFramePointer());
TestStackLink4096();
a = Test15(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7,
a + 8, a + 9, a + 10, a + 11, a + 12, a + 13, a + 14) + 1;
DebugStub.Print(".Test14] = {0}", __arglist(a));
return a;
}
[NoInline]
[StackLinkCheck]
internal static int Test15(int a, int b, int c, int d, int e, int f,
int g, int h, int i, int j, int k, int l,
int m, int n, int o)
{
DebugStub.Print("[Test15. ({0},{1},{2},{3},{4},{5},{6},{7},{8},"+
"{9},{10},{11},{12},{13},{14})",
__arglist(a, b, c, d, e, f, g, h, i, j, k, l,
m, n, o));
DumpStack(Processor.GetFramePointer());
TestStackLink8192();
a = Test16(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7,
a + 8, a + 9, a + 10, a + 11, a + 12, a + 13, a + 14,
a + 15) + 1;
DebugStub.Print(".Test15] = {0}", __arglist(a));
return a;
}
[OutsideGCDomain]
[NoInline]
[StackLinkCheck]
internal static int Test16(int a, int b, int c, int d, int e, int f,
int g, int h, int i, int j, int k, int l,
int m, int n, int o, int p)
{
DebugStub.Print("[Test16. ({0},{1},{2},{3},{4},{5},{6},{7},{8},"+
"{9},{10},{11},{12},{13},{14},{15})",
__arglist(a, b, c, d, e, f, g, h, i, j, k, l,
m, n, o, p));
DumpStack(Processor.GetFramePointer());
TestStackLink8192();
a = Test17(a, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7,
a + 8, a + 9, a + 10, a + 11, a + 12, a + 13, a + 14,
a + 15, a + 16) + 1;
DebugStub.Print(".Test16] = {0}", __arglist(a));
return a;
}
[NoInline]
[StackLinkCheck]
internal static int Test17(int a, int b, int c, int d, int e, int f,
int g, int h, int i, int j, int k, int l,
int m, int n, int o, int p, int q)
{
DebugStub.Print("[Test17. ({0},{1},{2},{3},{4},{5},{6},{7},{8},"+
"{9},{10},{11},{12},{13},{14},{15},{16})",
__arglist(a, b, c, d, e, f, g, h, i, j, k, l,
m, n, o, p, q));
DumpStack(Processor.GetFramePointer());
TestStackLink8192();
a = a + 1;
WalkStack(Processor.GetFramePointer());
DebugStub.Print(".Test17] = {0}", __arglist(a));
return a;
}
[AccessedByRuntime("output to header : defined in stacks.cpp")]
[StackBound(1024)]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void TestStackLink1024();
[AccessedByRuntime("output to header : defined in stacks.cpp")]
[StackBound(2048)]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void TestStackLink2048();
[AccessedByRuntime("output to header : defined in stacks.cpp")]
[StackBound(4096)]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void TestStackLink4096();
[AccessedByRuntime("output to header : defined in stacks.cpp")]
[StackBound(8192)]
[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern void TestStackLink8192();
#endif
}
}