Re: Stealing a Great Idea from the 6600

BGB wrote:

On 4/26/2024 8:25 AM, MitchAlsup1 wrote:

>

How does one use a frame pointer without negative displacements ??
 [FP+disp] accesses callee save registers
[FP-disp] accesses local stack variables and descriptors
 [SP+disp] accesses argument and result values
 

In my case, all of these are [SP+Disp], granted, there is no frame pointer and stack frames are fixed-size in BGBCC.

I only have FP when the base language is block structured and scoped.
Not C, C++ or FORTRAN, but Algol, ADA, Pascal: Yes.

This is typically with a frame layout like:
   Argument/Spill space
   -- Frame Top
   Register Save
   (Stack Canary)
   Local arrays/structs
   Local variables
   Argument/Spill Space
   -- Frame Bottom

     Previous Argument/Result space
   { Register Save area
     Return Pointer     }
FP-> Local Descriptors -------------------\
     Local Variables                      |
     Dynamically allocated Stack space <--/
SP-> My Argument/Result space
When safe stack is in use, Register Save area and return pointer are
placed on a separate stack not accessible with LD/ST instructions.

Contrast with traditional x86 layout, which puts saved registers and local variables near the frame-pointer, which points near the top of the stack frame.

Though, in a majority of functions, the MOV.L and MOV.Q functions have a big enough displacement to cover the whole frame (excludes functions which have a lot of local arrays or similar, though overly large local arrays are auto-folded to using heap allocation, but at present this logic is based on the size of individual arrays rather than on the total combined size of the stack frame).

By making a Local Descriptor area on the stack, one can access the descriptors off of FP and access the dynamic stuff via that pointer.
Both Local Descriptors and Local Variables may be allocated into registers and not actually exist on the stack.