Module Error

Hi!
I’m programming a Module. I divided the work into two parts, in the first one I just created the “Help and command decoding table” and it worked properly. The problem is when I add SWIs, and I think it comes from using this instruction:

ORRS PC, R14, #Overflow_Flag

How do I implement #Overflow_Flag in BASIC? If I leave the “SWI entry” as if it was a normal routine, I get the exception:

Module ‘X’ is not 32-bit compatible (while RMFlag is declared in the Header).

I may add the SWI part to this post if you think it could be another problem.
Thank you very much.

I’m programming a Module.

What are you using as your reference? Whatever it is, it is OUTDATED and should not be used.

That sort of code simply won’t run on ARM processors any more. The Processor Status Register is no longer a part of the Program Counter.

ORRS PC, R14, #Overflow_Flag

As said, the PSR and PC are not the same thing on 32 bit ARM. What you are attempting here will set PC to whatever R14 is and also set bit 28. It will work, but it will have a very different outcome to what you expect. ;-)

Ditto, if your reference says to exit with MOVS PC, R14 or LDMFD R13!, {Rxx-Ryy, R14}^, or you do anything with TEQP etc etc. All of these things are relics of the past. MSR, MRS and the CPSR – those are what you need.

https://www.riscosopen.org/wiki/documentation/show/Converting older software to run on 32 bit systems

I ought to get around to finishing that. ;-)

How do I implement #Overflow_Flag in BASIC?

Assuming “#Overflow_Flag” is &10000000 (or 1<<28):

MSR CPSR_f, #Overflow_Flag

[ http://www.heyrick.co.uk/armwiki/The_Status_register – but note that it says “CPSR_flg”, the terminology has changed, it should be “CPSR_f” these days…]

Module ‘X’ is not 32-bit compatible (while RMFlag is declared in the Header).

How are you declaring it? The word at +48 is a pointer to a word containing the flags. If you are expanding from a source written for an earlier version of RISC OS, note that there is an extra word in there → +44 is a Messages pointer.
See https://www.riscosopen.org/wiki/documentation/show/File%20formats:%20Relocatable%20Module

What are you using as your reference? Whatever it is, it is OUTDATED and should not be used.

Heyrick pages? :)

Neutral and 32 bit examples needed.

Heyrick pages? :)

If you look at the page on modules, you’ll see that was covered (briefly) back in 2004, and the example module is clearly marked as not being 32 bit safe. ;)

examples needed

Yes. For now though:

Go up to parent folder (/resfinder) for description and other files (headers etc).

Duh. That wasn’t a module, was it. :-/

Well, I’m following this tutorial: http://www.heyrick.co.uk/assembler/modcode.html#swihandler

I’ve changed the Overflow part, and I still get the incompatibility error.
In the module header I have the offset 44 (although I don’t use it) and 48.
This is the SWI code I added:

.SWIbaseNumber
EQUD &C0000
;——————————————————————————————————
.SWIentry
STR R14, [R13, #-4]!
LDR R12, [R12] ; get workspace pointer
CMP R11, #(EndOfJumpTable – JumpTable) / 4
ADDLO PC, PC, R11, LSL #2 ; dispatch if in range
B UnknownSWIerror ; unknown SWI

.JumpTable
B SWI_0
B SWI_1
.EndOfJumpTable

.SWI_0
; SWI code
LDR R15, [R13], #4

.SWI_1
; SWI code
LDR R15, [R13], #4

.UnknownSWIerror
ADR R0, ErrToken
MOV R1, #0
MOV R2, #0
ADR R4, ModuleTitle ; from module header
SWI “XMessageTrans_ErrorLookup”
MOV R0, #&10000000
MSR CPSR_f, R0
LDR PC, [R13], #4

.ErrToken
EQUD &1E6 ; same as system message
EQUS “BadSWI” ; token to look up
EQUB 0
ALIGN
;————————————————————————————————————————————
.SWIname
EQUS “Function”
EQUB 0
EQUS “One”
EQUB 0
EQUS “Two”
EQUB 0
EQUB 0
ALIGN

I think the incompatibility is because the 32 bit word is wrong.

In true Internet style, what follows is completely untested and was written my me, here, in the browser editor. Hence, there may be a billion “issues”; the first of which is that it is written for objasm and not BASIC. I don’t remember the OPT settings for making modules in BASIC as I use objasm these days…

Hope this helps, anyway. Maybe tomorrow I’ll give it a whirl, see if it actually works. 8-)

I have used SWI chunk &16F00 and module title, *command, and SWI prefix MyModule. These are not officially allocated and are for example purposes only. Any module you plan to release should be allocated – details here: https://www.riscosopen.org/content/allocate

        AREA     |Module$Code|, CODE
	ENTRY

entrypoint
        ; Standard RISC OS module header
        DCD      0                            ; Start code
        DCD      (initialise - entrypoint)    ; Initialise code
        DCD      (finalise - entrypoint)      ; Finalise code
        DCD      0                            ; Service call
        DCD      (titlestring - entrypoint)   ; Module title string
        DCD      (helpstring - entrypoint)    ; Module help string
        DCD      (command - entrypoint)       ; help/command keywords
        DCD      &16F00                       ; SWI chunk **NOT ALLOCATED**
        DCD      (swicode - entrypoint)       ; SWI handler code
        DCD      (switable - entrypoint)      ; SWI decoding table
        DCD      0                            ; SWI decoding code
        DCD      0                            ; Messages file
        DCD      (thirtytwo - entrypoint)     ; 32bit flag word

titlestring
        =        "ModuleName", 0
        ALIGN

helpstring
        =        "ModuleName", 9, "0.01 (31-Jan-2014)", 0
        ALIGN

thirtytwo
        ; Bit zero set indicates this is a 32bit-compatible module...
        DCD      1

initialise
        ; This is where the module initialises itself. Here, we can
        ; freely use registers R0-R6. R12 will be used as a pointer
        ; to our workspace. R13 points to the SVC stack. R14 is the
        ; return address. We're in SVC mode.

        ; We're in SVC mode, so preserve return address
        STR      R14, [R13, #-4]!

        ; If we have any hardware dependencies (RPi or such), check 'em
        ; first so we can fault as soon as possible.
        ; To fault, set R0 to point to an error block, set V, and then
        ; return with LDR PC, [R13], #4

        ; Here, we would check to see if R12 pointed to something. If
        ; so, we are being reinited with existing workspace. If NOT,
        ; we should claim some workspace and stash a pointer to it in
        ; R12 so the OS will pass it to us as and when...

        ; Now we do any initialisation that we require. Claiming
        ; events, prodding hardware, blah blah.

        ; Finally, return (with V unset) to finish the
        ; module initialisation.
        LDR      PC, [R13], #4


finalise
        ; This is where the module closes itself down. Here, we can
        ; freely use registers R0-R6. R12 points to our private
        ; word (which points to our workspace). R13 is the SVC stack.
        ; R14 is the return address. We're in SVC mode.
        ; [R10 and R11 have meaning for more complicated uses]

        STR      R14, [R13, #-4]!

        ; If we stashed a pointer to our workspace in R12, we can
        ; obtain the true workspace address like this:
        LDR      R12, [R12]

        ; Now we need to undo anything that we set up in the
        ; initialisation part - event claims and such; and
        ; *then* release the workspace block.
 
        ; Be careful with the order here - an event *could* fire
        ; at this point, so you should remove the events and such
        ; before freeing the workspace.

        ; Once all that has been done, we can finish up.
        LDR      PC, [R13], #4

        ; You can refuse to die by setting R0 and returning with
        ; V set.
        ; Your module will be delinked from the module chain at
        ; this point, so you cannot call your own SWIs.

switable
        ; SWI decoding table
        =        "MyModule", 0
        =        "One", 0
        =        "Two", 0
        =        "Three", 0
        DCB      0                            ; no more SWIs
        ALIGN

swicode
        ; This is called when a SWI is to be dealt with.
        ;   R0 - R8 as for caller
        ;   R9  = Is corrupted on entry?
        ;   R10 = Not defined - RO stack frame?
        ;   R11 = SWI number AND 63
        ;   R12 = Private word pointer
        ;   R13 = SVC stack
        ;   R14 = Return address
        ; We're in SVC mode.

        STMFD    R13!, {R9, R10, R14}         ; preserve R9 and R10, all else "don't care"

        ; check our SWI is within range
        CMP      R11, #unused_swi
        ADDLT    PC, PC, R11, LSL #2
        B        swicall_invalid

min_swi
        B        swicall_one                  ; MyModule_One
        B        swicall_two                  ; MyModule_Two
        B        swicall_three                ; MyModule_Three
max_swi
unused_swi       * (max_swi - min_swi) / 4

swicall_invalid
        ; just return...
        LDMFD    R13!, {R9, R10, PC}
        ; Normally you'd branch to some code to set R0 to point to
        ; an error block and return with V set. I'm being lazy... ;-)

swicall_one
        ; SWI &16F00 MyModule_One

        ; Do stuff.
        LDMFD    R13!, {R9, R10, PC}

swicall_two
        ; SWI &16F01 MyModule_Two

        ; Do stuff.
        LDMFD    R13!, {R9, R10, PC}

swicall_three
        ; SWI &16F02 MyModule_Three

        ; Do stuff.
        LDMFD    R13!, {R9, R10, PC}

command
        ; *command keyword table
        =        "MyModule", 0                ; "*MyModule"
        ALIGN
        DCD      (mymodcode - entrypoint)     ; pointer to code
        DCD      &00010000                    ; No flags, 0-1 parameters, no GSTrans.
        DCD      (mymodsyntax - entrypoint)   ; Syntax message
        DCD      (mymodhelp - entrypoint)     ; Help message
        DCD      0                            ; [end of list]

mymodsyntax
        =        "Syntax: *MyModule [yes|no]", 0
        ALIGN

mymodhelp
        =        "Example command. Has an optional parameter.", 0
        ALIGN

mymodcode
        ; This is called when *MyModule is entered at the command line.
        ; R0 points to the command tail (read only). R1 is the number
        ; of parameters as counted by OSCLI. R12 points to our private
        ; word (which points to our workspace). R13 is SVC stack. R14
        ; is the return address. We are in SVC mode.

        STR      R14, [R13, #-4]!
        ; code to deal with the command *MyModule goes here
        SWI      OS_NewLine
        ; (for example, just output a newline)
        LDR      PC, [R13], #4
        ; Return with V set if there was an error.


        ; **DONE**

        END

[stupid piece of XXXX forum threw away my took-a-long-time-to-write post but HA! I KEPT A COPY! Nerr nerr ner-nerr nerr!]

In true Internet style, what follows is completely untested and was written my me, here, in the browser editor.

Done in your head, just like a lecturer told me couldn’t be done¹ about 30 years ago.

   OS_NewLine	EQU &03    ; Ensures it works pretty much as is (standalone)
                           ; with a
                           ; "objasm -throwback examplecode exampleobj
                           ; link -m -o mymodule exampleobj "

   AREA     |Module$Code|, CODE
   ENTRY
.
.
.
   END
   ;			 ; ensures you have a line feed after the END
			 ; otherwise objasm sulks about there being "no END"

¹ He was wrong of course, as the wadge of split beermats² with Z80 assembler he had to mark testified.
² I’d forgotten an assignment and was up the pub but knew I could write up the notes in a free period in the morning – unfortunately he was off in the afternoon and wanted the work or notes first thing

In true Internet style, what follows is completely untested and was written my me, here, in the browser editor.

You’re brave, given our site’s tendency to throw forum posts away by logging you out for no obvious reason…

You’re brave, given our site’s tendency to throw forum posts away by logging you out for no obvious reason…

Bottom line of my long post reads:

[stupid piece of XXXX forum threw away my took-a-long-time-to-write post but HA! I KEPT A COPY! Nerr nerr ner-nerr nerr!]

Forewarned is forearmed, as they say. Bet I could get more done if I had four arms… ;-)

Bet I could get more done if I had four ARMs… ;-)

Surely you’d have to update the kernel first?

Rick, my Module works correctly now.
I just changed the chunk number part. It seems to be that you cannot set a label in the offset 28, you have to specify the number directly.

Thank you very much.