Proposed new macros

From looking through the ROOL sources, I noticed regs stored by the Entry/EntryS macro defined in Export.APCS-32.Hdr.Global.Proc are often directly accessed via the Proc_RegOffset or Proc_Local offsets.

        Entry   "r0-r7" 
        ; do work that corrupts r2

        LDR     r2,[sp, #Proc_RegOffset + 2*4]  ;restore original r2 from frame

Or:

        SETV
        ADR     r0,errblk
        STR     r0,[sp, #Proc_LocalStack + 0*4] ;change R0 on return
        EXIT

Firstly it should always be Proc_RegOffset instead incase EntryS is being used.

I’ve created some macros to automate this and hopefully make it more bullet proof.

• It will automatically calculate the correct offset, even if you use a non-continuous group of registers in Entry/EntryS.
• It will generate an error if you try to access a register that hasn’t been saved on the stack frame.
• You can easily load/store to a different register than the one you want on the stack easily

The syntax is FRAMLDR/FRAMSTR armreg,cond,framereg

• armreg is the register that is being loaded/stored.
• cond is an arm condition code.
• framereg is the register slot on the stack that you are accessing.

• If cond is omitted it is assumed to be AL
• If framereg is omitted it is assumed to be the same as armreg.

        FRAMLDR r1                              ;restore r1
        FRAMSTR r8,VS,r0                        ;if VS store r8 into stacked r0

        GBLA Proc_Offset  ;offset to load/store particular reg
        GBLS Fram_Regstr
        GBLS Fram_Copyregs
        GBLS Fram_Lowregstr

        MACRO
        FRAMSPL $origvar,$newvar,$sep

$newvar SETS "" 
        WHILE (($origvar):CC:" ":LEFT:1 <> "$sep"):LAND:($origvar >"")
$newvar SETS $newvar:CC:($origvar:LEFT:1)
        [ ($origvar >"")
$origvar SETS $origvar:RIGHT:(:LEN:$origvar-1)
        ]

        WEND
        ;skip remaining seperator
        [ ($origvar >"")
$origvar SETS $origvar:RIGHT:(:LEN:$origvar-1)
        ]

        MEND

        MACRO
        FRAMCOM $dstreg,$framereg
        LCLA actframe
        LCLA counter

actframe SETA $dstreg
        [ "$framereg" <>"" 
actframe SETA $framereg
        ]

        LCLA regmask
Fram_Copyregs SETS Proc_RegList
        WHILE Fram_Copyregs > "" 

        FRAMSPL "Fram_Copyregs","Fram_Regstr","," 

        ;regno =r0-r8 or a single reg r5
        LCLA lowreg
        LCLA highreg

        FRAMSPL "Fram_Regstr","Fram_Lowregstr","-" 
lowreg  SETA $Fram_Lowregstr
        [ Fram_Regstr ="" 
highreg SETA lowreg
        |
highreg SETA $Fram_Regstr
        ]

        ;set bits between lowreg and highreg in our mask
        WHILE lowreg <=highreg
regmask SETA regmask:OR:(1:SHL:lowreg)
lowreg  SETA lowreg +1
        WEND

        WEND

         ;calculate Proc_Offset using regmask
Proc_Offset SETA 0
        LCLA counter

        WHILE counter <actframe
        [ (regmask:AND:(1:SHL:counter)) >0
Proc_Offset SETA Proc_Offset+4
        ]
counter SETA counter +1
        WEND

        [ (regmask:AND:(1:SHL:counter)) =0
        LCLS tempstr
        [ actframe >9
actframe SETA actframe -10
tempstr SETS "1" 
        ]
        !       1,"r$tempstr":CC:("$actframe":RIGHT:1):CC:" not in frame!" 
        ]

        MEND

        MACRO
$label  FRAMLDR $dstreg,$cond,$framereg
$label  FRAMCOM $dstreg,$framereg
        LDR$cond $dstreg,[sp ,#Proc_RegOffset +Proc_Offset]
        MEND

        MACRO
$label  FRAMSTR $dstreg,$cond,$framereg
$label  FRAMCOM $dstreg,$framereg
        STR$cond $dstreg,[sp ,#Proc_RegOffset +Proc_Offset]
        MEND

Does anyone have any objections/opinions on using these macros?

From examining the listing of Export.APCS-32.Hdr.Global.Proc I believe EXIT could be simplified (untested):

$label
 [ Proc_SavedCPSR
        ADD$cond sp, sp, #Proc_LocalStack + 4
 |
 [ Proc_LocalStack <> 0
        ADD$cond sp, sp, #Proc_LocalStack
 ]

Would be simpler as:

 [ Proc_RegOffset <> 0
        ADD$cond sp, sp, #Proc_RegOffset
 ]

I like the sound of that. You could try replacing the said instructions in a few places with your macros to see if it results in the same binary. If so, then I’m all for it.