Use proper stack and frame pointer procedures provided by the compiler

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@8558 8c9fc860-2736-0410-a75d-ab315db34111

source/ARM.Objects.Mod

@@ -543,14 +543,14 @@ BEGIN
 	END;
 	(* save current state *)
 	running.state.PC := SYSTEM.PC();(*Machine.CurrentPC ();*)	(* for GC *) (* ug *)
-	running.state.SP := SYSTEM.SP();(*Machine.CurrentSP ();*)	(* for GC *)
-	running.state.BP := SYSTEM.FP();(*Machine.CurrentBP ();*)	(* save state *)
+	running.state.SP := SYSTEM.SP();(*SYSTEM.GetStackPointer ();*)	(* for GC *)
+	running.state.BP := SYSTEM.FP();(*SYSTEM.GetFramePointer ();*)	(* save state *)
 	Machine.FPUSaveMin(running.sse);
 	running := new; new.mode := Running;
 	IF Preempted IN new.flags THEN
 		EXCL(new.flags, Preempted);
 		perfTsc[id] := Machine.GetTimer ();
-		(*Machine.SetSP (new.state.SP);*) (* for UpdateState - run on new stack (EBP on old) *)
+		(*SYSTEM.SetStackPointer (new.state.SP);*) (* for UpdateState - run on new stack (EBP on old) *)
 		SYSTEM.SETSP(new.state.SP);
 		Machine.PushState(new.state);
 		Machine.FPURestoreFull(new.sse);
@@ -1045,7 +1045,7 @@ VAR bp: ADDRESS; p: Process;
 BEGIN
 	p := running[Machine.ID ()];
 	ASSERT(p.oldReturnPC # -1);
-	bp := Machine.CurrentBP ();
+	bp := SYSTEM.GetFramePointer ();
 	SYSTEM.PUT (bp + AddressSize, p.oldReturnPC);
 	CASE haltCode OF
 		|halt: HALT(halt);
@@ -1056,18 +1056,18 @@ END HaltAltPC;
 PROCEDURE HaltReturn;
 VAR bp: ADDRESS;
 BEGIN
-	bp := Machine.CurrentBP ();
+	bp := SYSTEM.GetFramePointer ();
 	SYSTEM.GET (bp, bp); (* Get the dynamic link *)
-	Machine.SetBP (bp); (* Undo the actual paf *)
+	SYSTEM.SetFramePointer (bp); (* Undo the actual paf *)
 	HaltAltPC(halt);
 END HaltReturn;
 
 PROCEDURE HaltUnbreakableReturn;
 VAR bp: ADDRESS;
 BEGIN
-	bp := Machine.CurrentBP ();
+	bp := SYSTEM.GetFramePointer ();
 	SYSTEM.GET (bp, bp); (* Get the dynamic link *)
-	Machine.SetBP (bp); (* Undo the actual paf *)
+	SYSTEM.SetFramePointer (bp); (* Undo the actual paf *)
 	HaltAltPC(haltUnbreakable);
 END HaltUnbreakableReturn;
 
@@ -1718,8 +1718,8 @@ BEGIN (* interrupts off *)
 	ASSERT(t # NIL);
 	IF t # NIL THEN
  		t.state.PC := Machine.CurrentPC(); (* ug: required information for GC with meta data for stack inspection *)
- 		t.state.SP := Machine.CurrentSP(); (* ug: not necessarily needed for GC *)
- 		t.state.BP := Machine.CurrentBP(); (* ug: necessary information for GC with meta data for stack inspection *)
+ 		t.state.SP := SYSTEM.GetStackPointer(); (* ug: not necessarily needed for GC *)
+ 		t.state.BP := SYSTEM.GetFramePointer(); (* ug: necessary information for GC with meta data for stack inspection *)
 	END;
 	Machine.Release(Machine.Objects)
 END UpdateState;
@@ -1837,7 +1837,7 @@ BEGIN
 	InitGCHandling;
 	Heaps.gcStatus := GCStatusFactory();
 	(* create a process for rest of init code, which runs at user level *)
-	entry := Machine.CurrentBP ();
+	entry := SYSTEM.GetFramePointer ();
 	SYSTEM.GET (entry+AddressSize, entry);	(* return address into linker-generated call table *)
 	NEW(initObject);
 	NewProcess(SYSTEM.VAL (Body, entry-ReturnStackDisplacement), {Resistant}, initObject, init); (* create init process *)

source/BIOS.Objects.Mod

@@ -532,8 +532,8 @@ BEGIN
 	END;
 	(* save current state *)
 	running.state.PC := Machine.CurrentPC ();	(* for GC *) (* ug *)
-	running.state.SP := Machine.CurrentSP ();	(* for GC *)
-	running.state.BP := Machine.CurrentBP ();	(* save state *)
+	running.state.SP := SYSTEM.GetStackPointer ();	(* for GC *)
+	running.state.BP := SYSTEM.GetFramePointer ();	(* save state *)
 	IF Machine.SSESupport THEN Machine.SSESaveMin(running.sseAdr)
 	ELSE Machine.FPUSaveMin(running.sse)
 	END;
@@ -542,7 +542,7 @@ BEGIN
 		ASSERT(new.state.CS MOD 4 = Machine.UserLevel); (* switching to user mode *)
 		EXCL(new.flags, Preempted);
 		perfTsc[id] := Machine.GetTimer ();
-		Machine.SetSP (new.state.SP); (* for UpdateState - run on new stack (EBP on old) *)
+		SYSTEM.SetStackPointer (new.state.SP); (* for UpdateState - run on new stack (EBP on old) *)
 		Machine.PushState(new.state);
 		IF Machine.SSESupport THEN Machine.SSERestoreFull(new.sseAdr)
 		ELSE Machine.FPURestoreFull(new.sse)
@@ -554,8 +554,8 @@ BEGIN
 		ELSE Machine.FPURestoreMin(new.sse)
 		END;
 		perfTsc[id] := Machine.GetTimer ();
-		Machine.SetSP (new.state.SP); (* run on new stack *)
-		Machine.SetBP (new.state.BP);
+		SYSTEM.SetStackPointer (new.state.SP); (* run on new stack *)
+		SYSTEM.SetFramePointer (new.state.BP);
 		Machine.Release(Machine.Objects);
 	END;
 (*
@@ -1053,7 +1053,7 @@ VAR bp: ADDRESS; p: Process;
 BEGIN
 	p := running[Machine.ID ()];
 	ASSERT(p.oldReturnPC # -1);
-	bp := Machine.CurrentBP ();
+	bp := SYSTEM.GetFramePointer ();
 	SYSTEM.PUT (bp + AddressSize, p.oldReturnPC);
 	CASE haltCode OF
 		|halt: HALT(halt);
@@ -1064,18 +1064,18 @@ END HaltAltPC;
 PROCEDURE HaltReturn;
 VAR bp: ADDRESS;
 BEGIN
-	bp := Machine.CurrentBP ();
+	bp := SYSTEM.GetFramePointer ();
 	SYSTEM.GET (bp, bp); (* Get the dynamic link *)
-	Machine.SetBP (bp); (* Undo the actual paf *)
+	SYSTEM.SetFramePointer (bp); (* Undo the actual paf *)
 	HaltAltPC(halt);
 END HaltReturn;
 
 PROCEDURE HaltUnbreakableReturn;
 VAR bp: ADDRESS;
 BEGIN
-	bp := Machine.CurrentBP ();
+	bp := SYSTEM.GetFramePointer ();
 	SYSTEM.GET (bp, bp); (* Get the dynamic link *)
-	Machine.SetBP (bp); (* Undo the actual paf *)
+	SYSTEM.SetFramePointer (bp); (* Undo the actual paf *)
 	HaltAltPC(haltUnbreakable);
 END HaltUnbreakableReturn;
 
@@ -1713,8 +1713,8 @@ BEGIN (* interrupts off *)
 	t := running[Machine.ID ()];
 	IF t # NIL THEN
  		t.state.PC := Machine.CurrentPC(); (* ug: required information for GC with meta data for stack inspection *)
- 		t.state.SP := Machine.CurrentSP(); (* ug: not necessarily needed for GC *)
- 		t.state.BP := Machine.CurrentBP(); (* ug: necessary information for GC with meta data for stack inspection *)
+ 		t.state.SP := SYSTEM.GetStackPointer(); (* ug: not necessarily needed for GC *)
+ 		t.state.BP := SYSTEM.GetFramePointer(); (* ug: necessary information for GC with meta data for stack inspection *)
 	END;
 	Machine.Release(Machine.Objects)
 END UpdateState;
@@ -1824,7 +1824,7 @@ BEGIN
 	InitGCHandling;
 	Heaps.gcStatus := GCStatusFactory();
 	(* create a process for rest of init code, which runs at user level *)
-	entry := Machine.CurrentBP ();
+	entry := SYSTEM.GetFramePointer ();
 	SYSTEM.GET (entry+AddressSize, entry);	(* return address into linker-generated call table *)
 	NEW(initObject);
 	NewProcess(SYSTEM.VAL (Body, entry), {Resistant}, initObject, init); (* create init process *)

source/Coop.Heaps.Mod

@@ -253,7 +253,7 @@ BEGIN
 	IF systemBlockAdr # 0 THEN
 		INC (systemBlockAdr, BlockHeaderSize);
 		SYSTEM.PUT(systemBlockAdr + TypeDescOffset, systemBlockTag);
-		SYSTEM.GET(Machine.CurrentBP()+SIZEOF(ADDRESS),pc);
+		SYSTEM.GET(SYSTEM.GetFramePointer()+SIZEOF(ADDRESS),pc);
 		SYSTEM.PUT(systemBlockAdr + HeapBlockOffset,pc);
 		dataBlockAdr := systemBlockAdr + systemBlockSize (* - BlockHeaderSize + BlockHeaderSize *);
 		SYSTEM.PUT(dataBlockAdr + TypeDescOffset, NilVal);		(* no type descriptor *)
@@ -296,7 +296,7 @@ BEGIN
 	SYSTEM.GET (typeInfoAdr + FlagsOfs, flags);
 	IF ProtTypeBit IN flags THEN
 		NewProtRec(p, tag, isRealtime);
-		SYSTEM.GET(Machine.CurrentBP()+SIZEOF(ADDRESS), pc);
+		SYSTEM.GET(SYSTEM.GetFramePointer()+SIZEOF(ADDRESS), pc);
 		SetPC2(p,pc);
 	ELSE
 		SYSTEM.GET(tag, size);
@@ -309,7 +309,7 @@ BEGIN
 		IF recordBlockAdr # 0 THEN
 			INC (recordBlockAdr, BlockHeaderSize);
 			SYSTEM.PUT(recordBlockAdr + TypeDescOffset, recordBlockTag);
-			SYSTEM.GET(Machine.CurrentBP()+SIZEOF(ADDRESS),pc);
+			SYSTEM.GET(SYSTEM.GetFramePointer()+SIZEOF(ADDRESS),pc);
 			SYSTEM.PUT(recordBlockAdr + HeapBlockOffset,pc);
 			dataBlockAdr := recordBlockAdr + SIZEOF(RecordBlockDesc) + BlockHeaderSize;
 			SYSTEM.PUT(dataBlockAdr + TypeDescOffset, tag);
@@ -348,7 +348,7 @@ BEGIN
 	IF protRecBlockAdr # 0 THEN
 		INC (protRecBlockAdr, BlockHeaderSize);
 		SYSTEM.PUT(protRecBlockAdr + TypeDescOffset, protRecBlockTag);
-		SYSTEM.GET(Machine.CurrentBP()+SIZEOF(ADDRESS),pc);
+		SYSTEM.GET(SYSTEM.GetFramePointer()+SIZEOF(ADDRESS),pc);
 		SYSTEM.PUT(protRecBlockAdr + HeapBlockOffset,pc);
 		dataBlockAdr := protRecBlockAdr + SIZEOF(ProtRecBlockDesc) + BlockHeaderSize;
 		SYSTEM.PUT(dataBlockAdr + TypeDescOffset, tag);
@@ -393,7 +393,7 @@ BEGIN
 	arrSize := numElems * elemSize;
 	IF arrSize = 0 THEN
 		NewSys(p, numDims * AddressSize + 3 * AddressSize, isRealtime); (* no data, thus no specific alignment *)
-		SYSTEM.GET(Machine.CurrentBP()+SIZEOF(ADDRESS), pc);
+		SYSTEM.GET(SYSTEM.GetFramePointer()+SIZEOF(ADDRESS), pc);
 		SetPC2(p,pc);
 	ELSE
 		ASSERT(BlockHeaderSize MOD ArrayAlignment = 0);
@@ -403,7 +403,7 @@ BEGIN
 		IF ptrOfs = MinPtrOfs - AddressSize THEN (* no pointers in element type *)
 			size := arrayDataOffset + arrSize;
 			NewSys(p, size, isRealtime);
-			SYSTEM.GET(Machine.CurrentBP()+SIZEOF(ADDRESS), pc);
+			SYSTEM.GET(SYSTEM.GetFramePointer()+SIZEOF(ADDRESS), pc);
 			SetPC2(p, pc);
 		ELSE
 			arrayBlockSize := BlockHeaderSize + SIZEOF(ArrayBlockDesc);
@@ -414,7 +414,7 @@ BEGIN
 			IF arrayBlockAdr # 0 THEN
 				INC (arrayBlockAdr, BlockHeaderSize);
 				SYSTEM.PUT(arrayBlockAdr + TypeDescOffset, arrayBlockTag);
-				SYSTEM.GET(Machine.CurrentBP()+SIZEOF(ADDRESS),pc);
+				SYSTEM.GET(SYSTEM.GetFramePointer()+SIZEOF(ADDRESS),pc);
 				SYSTEM.PUT(arrayBlockAdr + HeapBlockOffset,pc);
 				dataBlockAdr := arrayBlockAdr + arrayBlockSize (* - BlockHeaderSize + BlockHeaderSize *);
 				SYSTEM.PUT(dataBlockAdr + TypeDescOffset, elemTag);

source/DataErrors.Mod

@@ -303,7 +303,7 @@ CONST
 	PROCEDURE ErrorCaller( VAR m: Modules.Module;  VAR pc, ebp, eip: NbrInt.Integer );
 	VAR i, reg: NbrInt.Integer;  timer: Kernel.Timer;
 	BEGIN
-		reg := LONGINT(Machine.CurrentBP ());
+		reg := LONGINT(SYSTEM.GetFramePointer ());
 		SYSTEM.GET( reg, ebp );   (* stack frame of caller *)
 		SYSTEM.GET( ebp + 4, eip );   (* return address from caller *)
 		m := Modules.ThisModuleByAdr( eip );
@@ -319,7 +319,7 @@ CONST
 	PROCEDURE WarningCaller( VAR m: Modules.Module;  VAR pc, ebp, eip: NbrInt.Integer );
 	VAR reg: NbrInt.Integer;  timer: Kernel.Timer;
 	BEGIN
-		reg := LONGINT(Machine.CurrentBP ());
+		reg := LONGINT(SYSTEM.GetFramePointer ());
 		SYSTEM.GET( reg, ebp );   (* stack frame of caller *)
 		SYSTEM.GET( ebp + 4, eip );   (* return address from caller *)
 		m := Modules.ThisModuleByAdr( eip );

source/DebugLog.Mod

@@ -203,7 +203,7 @@ BEGIN
 	END;
 
 	(* Find the caller outside of this module *)
-	bp := Machine.CurrentBP ();
+	bp := SYSTEM.GetFramePointer ();
 	REPEAT
 		SYSTEM.GET(bp + SIZEOF (ADDRESS), pc);
 		module := Modules.ThisModuleByAdr(pc);

source/Debugging.Mod

@@ -57,7 +57,7 @@ VAR
 	PROCEDURE Stack*(CONST s: ARRAY OF CHAR);
 	VAR bp,oldbp: ADDRESS;
 	BEGIN
-		bp := Machine.CurrentBP();
+		bp := SYSTEM.GetFramePointer();
 		oldbp := CallerBP(bp);
 		ViewStack(oldbp,bp+4*SIZEOF(ADDRESS),s);
 	END Stack;
@@ -74,7 +74,7 @@ VAR
 	PROCEDURE TraceBack*;   (* do a stack trace back starting at the calling instruction position *)
 	BEGIN
 		Enter;
-		TraceBackThis( Machine.CurrentPC(), Machine.CurrentBP(), Machine.CurrentSP(), Objects.GetStackBottom(Objects.CurrentProcess()) );
+		TraceBackThis( Machine.CurrentPC(), SYSTEM.GetFramePointer(), SYSTEM.GetStackPointer(), Objects.GetStackBottom(Objects.CurrentProcess()) );
 		Exit;
 	END TraceBack;
 

source/FoxInterpreterSymbols.Mod

@@ -289,13 +289,13 @@ TYPE
 			p: P; 
 		BEGIN
 			p := SYSTEM.VAL(P, adr);
-			esp := Machine.CurrentSP();
-			Machine.SetSP(esp-size);
+			esp := SYSTEM.GetStackPointer();
+			SYSTEM.SetStackPointer(esp-size);
 			IF size > 0 THEN 
 				SYSTEM.MOVE(ADDRESS OF data[pos], esp-size, size);
 			END;
 			p();
-			Machine.SetSP(esp);
+			SYSTEM.SetStackPointer(esp);
 		END Call; 
 
 		PROCEDURE CallH(adr: ADDRESS): HUGEINT;
@@ -306,13 +306,13 @@ TYPE
 			p: P; 
 		BEGIN
 			p := SYSTEM.VAL(P, adr);
-			esp := Machine.CurrentSP();
-			Machine.SetSP(esp-size);
+			esp := SYSTEM.GetStackPointer();
+			SYSTEM.SetStackPointer(esp-size);
 			IF size > 0 THEN 
 				SYSTEM.MOVE(ADDRESS OF data[pos], esp-size, size);
 			END;
 			res := p();
-			Machine.SetSP(esp);
+			SYSTEM.SetStackPointer(esp);
 			RETURN res;
 		END CallH; 
 
@@ -324,13 +324,13 @@ TYPE
 			p: P; 
 		BEGIN
 			p := SYSTEM.VAL(P, adr);
-			esp := Machine.CurrentSP();
-			Machine.SetSP(esp-size);
+			esp := SYSTEM.GetStackPointer();
+			SYSTEM.SetStackPointer(esp-size);
 			IF size > 0 THEN 
 				SYSTEM.MOVE(ADDRESS OF data[pos], esp-size, size);
 			END;
 			res := p();
-			Machine.SetSP(esp);
+			SYSTEM.SetStackPointer(esp);
 			RETURN res;
 		END CallR; 
 
@@ -342,13 +342,13 @@ TYPE
 			p: P; 
 		BEGIN
 			p := SYSTEM.VAL(P, adr);
-			esp := Machine.CurrentSP();
-			Machine.SetSP(esp-size);
+			esp := SYSTEM.GetStackPointer();
+			SYSTEM.SetStackPointer(esp-size);
 			IF size > 0 THEN 
 				SYSTEM.MOVE(ADDRESS OF data[pos], esp-size, size);
 			END;
 			res := p();
-			Machine.SetSP(esp);
+			SYSTEM.SetStackPointer(esp);
 			RETURN res;
 		END CallX; 
 	END Callstack;

source/Heaps.Mod

@@ -1313,7 +1313,7 @@ PROCEDURE SetPC*(p: DataBlockU);
 VAR bp: ADDRESS;
 BEGIN
 	IF p # NIL THEN
-		bp := CheckBP(Machine.CurrentBP()); 
+		bp := CheckBP(SYSTEM.GetFramePointer()); 
 		SYSTEM.GET(bp, bp); 
 		bp := CheckBP(bp);
 		SYSTEM.GET(bp+SIZEOF(ADDRESS), p.heapBlock.heapBlock);

source/Info.Mod

@@ -320,7 +320,7 @@ VAR time: HUGEINT; bp: ADDRESS; i: LONGINT;pc: ADDRESS;
 BEGIN
 	time := Machine.GetTimer();
 
-	bp := Machine.CurrentBP();
+	bp := SYSTEM.GetFramePointer();
 
 	SYSTEM.GET(bp+SIZEOF(ADDRESS),pc);
 

source/Oberon.Profiler.Mod

@@ -383,7 +383,7 @@ BEGIN
 
 	(* perform *)
 	max := 0;  n := times;
-	stopBP := Machine.CurrentBP ();
+	stopBP := SYSTEM.GetFramePointer ();
 	WHILE n > 0 DO
 		FOR i := 0 TO Machine.MaxCPU-1 DO tracePos[i] := 0 END;
 		Machine.InstallEventHandler(HandleTimer);

source/Oberon.antsPortability.Mod

@@ -320,7 +320,7 @@ PROCEDURE IdentifyCaller*(VAR m: Modules.Module; VAR pc: LONGINT);
 (* note: proc works correct only, if caller has been a command *) 
 VAR ebp, eip: LONGINT; i,adr: LONGINT; 
 BEGIN
-  ebp := Machine.CurrentBP();
+  ebp := SYSTEM.GetFramePointer();
   SYSTEM.GET(ebp, ebp);  (* stack frame of caller *)
   SYSTEM.GET(ebp+4, eip);  (* return address from caller *)
   m := AosModules.ThisModuleByAdr(eip);

source/PCDebug.Mod

@@ -119,7 +119,7 @@ MODULE PCDebug; (** AUTHOR "prk"; PURPOSE "Parallel Compiler: low-level trace fu
 	PROCEDURE ToDo*(class: LONGINT);
 		VAR pc, bp: ADDRESS; p, q: List; name: ARRAY 64 OF CHAR;
 	BEGIN {EXCLUSIVE}
-		bp := Machine.CurrentBP ();
+		bp := SYSTEM.GetFramePointer ();
 		SYSTEM.GET (bp + SIZEOF(ADDRESS), pc);
 		p := pclist;
 		WHILE (p.next # NIL) & (p.next.pc < pc) DO p := p.next END;

source/PCM.Mod

@@ -344,7 +344,7 @@ IMPORT
 
 	PROCEDURE TraceBack*;   (* do a stack trace back starting at the calling instruction position *)
 	BEGIN
-		TraceBackThis( Machine.CurrentPC(), Machine.CurrentBP() );
+		TraceBackThis( Machine.CurrentPC(), SYSTEM.GetFramePointer() );
 	END TraceBack;
 
 	PROCEDURE Error* (err: WORD; pos: LONGINT;  CONST msg: ARRAY OF CHAR);

source/Unix.Objects.Mod

@@ -202,8 +202,8 @@ TYPE
 			IF mode # Terminated THEN
 				
 				IF SELF = CurrentProcess() THEN
-					state.SP := Machine.CurrentSP( );
-					state.BP := Machine.CurrentBP( );
+					state.SP := S.GetStackPointer( );
+					state.BP := S.GetFramePointer( );
 				END;
 				sp := state.SP; bp := state.BP; 
 			
@@ -327,8 +327,8 @@ TYPE
 			IF value THEN
 				Machine.Acquire( Machine.Objects );	
 				Machine.Acquire( Machine.Heaps );
-				cur.state.SP := Machine.CurrentSP();
-				cur.state.BP := Machine.CurrentBP();
+				cur.state.SP := S.GetStackPointer();
+				cur.state.BP := S.GetFramePointer();
 				cur.state.PC := ADDRESSOF( GCLoop );
 					
 				SuspendActivities;
@@ -352,7 +352,7 @@ TYPE
 			p := newProcess;  newProcess := NIL;
 			Unix.WriteKey( processPointer, p );
 			p.id := nextPID;  INC( nextPID );
-			p.stackBottom := Machine.CurrentBP( );
+			p.stackBottom := S.GetFramePointer( );
 			S.GET( p.stackBottom, prevBP );
 			S.PUT( prevBP, S.VAL( ADDRESS, 0 ) );	(* for terminating Reflection.StackTraceBack *)
 			Unix.MtxLock( processList );
@@ -415,8 +415,8 @@ TYPE
 		ASSERT( exclusive );   (* shared not implemented yet *)
 		S.GET( S.VAL( ADDRESS, obj ) + Heaps.HeapBlockOffset, hdr );
 		p := CurrentProcess();
-		p.state.SP := Machine.CurrentSP( );
-		p.state.BP := Machine.CurrentBP( );
+		p.state.SP := S.GetStackPointer( );
+		p.state.BP := S.GetFramePointer( );
 		p.state.PC := Machine.CurrentPC( );
 		p.mode := AwaitingLock;
 
@@ -451,8 +451,8 @@ TYPE
 		hdr.lockedBy := c;
 		IF c # NIL THEN  Unix.CondSignal( c.continue )  ELSE  Unix.CondSignal( lock.enter )  END;
 
-		p.state.SP := Machine.CurrentSP( );
-		p.state.BP := Machine.CurrentBP( );
+		p.state.SP := S.GetStackPointer( );
+		p.state.BP := S.GetFramePointer( );
 		p.state.PC := Machine.CurrentPC( );
 		Unix.CondWait( p.continue, lock.mtx );   
 		
@@ -754,8 +754,8 @@ TYPE
 	BEGIN 
 		IF p.threadId = Unix.ThrThis( ) THEN
 			p.state.PC := Machine.CurrentPC( );
-			p.state.BP := Machine.CurrentBP( );
-			p.state.SP := Machine.CurrentSP( )	
+			p.state.BP := S.GetFramePointer( );
+			p.state.SP := S.GetStackPointer( )	
 		ELSE
 			IF p.mode = Running THEN
 				timerStopped := TRUE;
@@ -824,7 +824,7 @@ TYPE
 		IF clock = NIL THEN  RETURN  END;
 		cur := CurrentProcess();
 		IF cur # NIL THEN 
-			bp := Machine.CurrentBP();
+			bp := S.GetFramePointer();
 			S.GET( bp, n );
 			IF ODD( n ) THEN S.GET( bp + SIZEOF( ADDRESS ), bp )  ELSE  bp := n  END;
 			cur.state.BP := bp;

source/Windows.Objects.Mod

@@ -180,7 +180,7 @@ TYPE
 			END;
 						
 			IF CurrentProcess() = SELF THEN
-				sp := Machine.CurrentSP();  bp :=Machine.CurrentBP(); pc := Machine.CurrentPC(); 
+				sp := SYSTEM.GetStackPointer();  bp :=SYSTEM.GetFramePointer(); pc := Machine.CurrentPC(); 
 			ELSE
 				res := Kernel32.SuspendThread(handle); (* can suspend a suspended thread -- no problem at all *)
 				state.ContextFlags := Kernel32.ContextControl + Kernel32.ContextInteger;
@@ -761,8 +761,8 @@ BEGIN
 	t := lpParameter(Process);  obj := t.obj;
 	ASSERT(res # 0);
 	SetPriority(t.priority);
-	bp := Machine.CurrentBP();
-	sp := Machine.CurrentSP();
+	bp := SYSTEM.GetFramePointer();
+	sp := SYSTEM.GetStackPointer();
 	t.restartSP := sp;
 	t.stackBottom := bp;
 	IF t.restartPC = SYSTEM.VAL(ADDRESS, terminateProc) THEN DEC(t.restartSP, SIZEOF(ADDRESS))
@@ -1339,7 +1339,7 @@ BEGIN
 
 	cur := CurrentProcess();
 	IF cur # NIL THEN 
-		ebp := Machine.CurrentBP();
+		ebp := SYSTEM.GetFramePointer();
 		SYSTEM.GET(ebp, n);
 		IF ODD(n) THEN SYSTEM.GET(ebp + SIZEOF(ADDRESS), ebp) ELSE ebp := n END;
 		cur.gcContext.last[cur.gcContext.nextPos] := ebp;