DDE inline assembler in C

It seems like the DDE C compiler includes an inline assembler but where is the documentation?

Hey André,
AFAIK there isn’t much, I had to figure out all the bits. You should find some documentation in the DDE manuals to get you started.

If you need an example of use that is very easy to read, please have a look at my uCLib sources here:

https://github.com/RISC-OS-Community/uCLib/blob/develop/src/c/uCLib_base

Also if you fancy, feel free to join me on that project. It’s an alternative “micro C library” to be used with transient executable builds with both DDE and GCC.

Hope this helps

I was actually looking at inlining fixed point multiplications like “(a*b) >> 23” and stuff like that but all the examples I have seen use fixed registers. In GCC it seems you can tell it to use the register corresponding to a variable.

IIRC there was some notes on using it in either the changes file or maybe in the c99 docs files. These were in the DDE archive, not the PDFs.

There are some notes in the “C implementation details” chapter of the C/C++ manual, under “Inline assembler” (page 122 in my copy). I’m not sure whether or not you saw that; it’s not hugely detailed but is hopefully enough to get on with.

André,
I am not sure what you mean, anyway here is an example using variables:

#include <stdio.h>

int mul(int x, int y)
{
  int rval;

  __asm
  {
    MUL rval,x,y
  }

  return rval;
}

int main(void)
{
  printf("result: %i", mul(5,7));
  return 0;
}

I used integers and a simple operation just to keep the code short. However the example is “real-world useful”, in the sense that I used this approach to initially implement my Forth compiler for RISC OS and then replaced it with ObjAsm so that the primitives are all writen in optimised ARM ASM. So, each dictionary word become just an address (typical forth hybrid between interpreter and compiler).

Hope this helps

P.S. DDE’s inline ASM is not as complete as GCC’s one and also seems to be kinda “controlled” by the compiler anyway. It’s definitely nothing like the BBC BASIC assembler (just to avoid confusions).

The manual says to avoid using registers whenever possible (“For best practice, BL and SWI are the only reason you should use physical registers”). Can those three assembly instructions be consolidated down to “MUL rval,x,y” or doesn’t it work like that? I’m not an assembly guru :)

@ Chris

Can those three assembly instructions be consolidated down to “MUL rval,x,y” or doesn’t it work like that?

Indeed they can be converted to a single line `MUL rval,x,y`, but it’s just “syntax sugar”, it will be (obviously) converted into the MOVs and MUL.

Anyway updated the code on my previous post if that’s what André is seeking for.

Thanks Paolo, much simplier than the GCC stuff.

I have now converted all the stuff. I just have a problem with the following macro:

#define arm_mul(x, y, SCALEBITS) \

    uint32_t hi; \

    uint32_t lo; \

    uint32_t result; \

    __asm \

    { \

        smull lo, hi, x, y; \

        movs  lo, lo, lsr #SCALEBITS; \

        adc   result, lo, hi, lsl #(32 – SCALEBITS) \

    } \

    return result;

which gives the cryptic error “operand of # not macro formal parameter”.

Have you tried it without the #? It’s a compiler that understands some assembler, it isn’t an assembler, so the syntax will be slightly different.

cpp will try to make #SCALEBITS into a string. Maybe try a space after the #

Or compile with -S, and look at the .s file.

Did it compile outside the macro? If so could try using an inline function rather than a macro.

I forgot the # had some effect inside macros.
In the end I just replaced the macros by direct code in the little functions that used it.

Bonjour André,

Documentation

I don’t know if this keeps up with the latest updates, but the syntax remains the same.

That’s almost word-for-word identical to the text in the C/C++ manual.

In the end I just replaced the macros by direct code in the little functions that used it.

Good choice, you can always ifdef the function if you need replacements and define it as always inline if you want to reduce function call overhead.