So I wrote a ARv6-M assembler in python.

[pysselmedheg]

I think it's really cool that micropython supports inline assembler. The mix of python coding for most stuff, and then assembler for some tight time critical loops tickles my brains. But I got a bit frustrated that there are several missing instructions, and not just the really odd ones.

So I wrote my own assembler decorator. It has the full ARMv6-M instruction set (like in RP2040), and it's not as restrictive as @micropython.asm_thumb regarding use of python variables, or even python code as a preprocessor.

It's still in beta and needs a lot more testing. But so far it looks promising.

Now to the questions.

Right now, I'm generating an array.array('H', [0xabcd, ...]) with the resulting code. The only way I have to actually run it is to send the address of it to a launcher written with @micropython.asm_thumb. That seem like an kludge, and also means I'm down to only two function arguments (Yes, I know that it can be solved with arrays). Does anyone know a way to more directly generate a native code function.

Has anyone seen some kind of test suite for this assembler set. I mean, I can write something myself and just repeat the same mistakes once more, but if it comes from another source than me I'd feel more confident. :-)

And yes, it will end up on github, but I want it to be less unpolished first.

[peterhinch]

A possible solution to the argument problem would be to write a loader. This would accept a machine code array as created by your assembler and a number of args. The loader would create a machine code preamble to the array, containing instructions to move the args to registers. It would then run the combined file.

load(array, arg0, arg1)  # Would use *args internally

would create machine code to put arg0 in R0, arg1 in R1, followed by the rest of the code. It would then run it.

As for running it the only other option apart from the decorator might be a loadable C module.

[peterhinch]

If you're going to write a loader then using asm_thumb internally seems simpler than using a C module.

You might want to include an option to assemble Arm V7: this is used in RP2 V2 and STM (Pyboards) and includes hardware FP support.

[pysselmedheg]

I think I've settled for a method. I'll do it like I said before, except that I send parameters in argc/argv format all the way to the users assembler, and instead provide a function that can be used in python preprocessing to unpack the arguments there.
User code would look like this:

import armv6m_asm

@armv6m_asm.asm_thumb
def my_func():        # <<< No args here, since the decorator can't see it anyways in micropython AFAIK.
    args_to_regs(2)   # Expands to: ldr(r0, [r7, 0])
                      #             ldr(r1, [r7, 4])
    adds(r2, r1, r0)
    adds(r0, r1, r2)

del armv6m_asm        # Not necessary, but possible if RAM is scarce

from armv6m_native import run_native   # Runtime part. Smaller module than armv6m_asm. 

# Simple usage
run_native(my_func, 11, 22)

# Usage if you want to send data both ways through the array
args = array.array('I', (11, 22))
run_native(my_func, args)

And just for the fun of it, here's the core part of the args_to_regs function. (Minus error checking, and assembler directives). Just to show how fun it is to have a python preprocessor. Yes, this works. :-)

 def args_to_regs(n):
    for i in range(n):
        ldr(r0 + i, [r7, 4*i])  # r0 + 3 is r3, referring to register index, not register value

Regarding ARMv7: Yes, it would be a good idea to implement that set too. And it's fairly easy to add more stuff to the code, as long as the assembler set is fairly similar. Considering that it's still ARM, it should probably be easy.

[pysselmedheg]

I took a glance on Cortex-M33 (RP2350), and it looked like it is the ARMv8-M instruction set. (Did I miss something?)
That's a lot of instructions. Probably still doable, but I don't think I'll give it high priority.

[peterhinch]

I'm no expert on the various ARM version instruction sets but I have written assembler modules for STM which is ARMV7 (FIR flters and fourier transforms). The FIR module runs on any RP2 and Fourier runs on RP2 V2 (it requires floating point).

On that non-rigorous basis it would seem that each version is a superset of its predecessor. A key benefit of V7 is enabling FP instructions. Such applications are a prime target of assembler use.

I didn't realise RP2 V2 supported V8 - I must look into this.

Incidentally it is possible to pass args to decorators - but your approach looks fine.

[pysselmedheg]

Back from another side quest. :-)
I'm no expert either. But yes, it seems like ARMv6-M < ARMv7-M < ARMv7E-M < ARMv8-M.
I looked a bit more on the bigger sets, and I don't think I'll write a full ARMv7-M assembler unless I'll manage to extract the instructions from the reference manual pdf, I have little faith that I could do it without lots of errors otherwise.

But at least I've put the ARMv6-M version here: https://github.com/pysselmedheg/micropython_libs