RISC-V inline assembly

Question

I'm quite new to inline assembly, so I need your help to be sure that I use it correctly. I need to add assembly code inside my C code that is compiled with the Risc-v toolchain. Please consider the following code:

int bar = 0xFF00;

int main(){
    volatile int result;
    int k;
    k = funct();
    int* ptr;
    ptr = &bar;
    asm volatile (".insn r 0x33, 0, 0, a4, a5, a3":
                       "=m"(*ptr), "=r"(result):
                       [a5] "m"(*ptr), [a3] "r"(k) :
                      );
        
    }
...

What I want to do is bar = bar+k. Actually, I want to change the content of the memory location that bar resides in. But the code that I wrote gets the address of bar and adds it to k. Does anybody know what the problem is?

Answer 1

Unfortunately, you have misunderstood the syntax.

In the assembler string, you can either refer to an argument using %0, %1, where the number is the n:th argument passed to the asm directive. Alternatively, you can use the symbolic name, %[myname] which refers to the argument in the form [myname]"r"(k).

Note that the symbolic name is the same as using the number, the name itself doesn't imply anything. In you example, one could get the impression that you are forcing the code to use a specific processor register. (There is another syntax for that, if you really need to use it.)

For example, if you write something like:

int bar = 0xFF00;

int main(){
    volatile int result;
    int k;
    k = funct();
    int* ptr;
    ptr = &bar;
    asm volatile (".insn r 0x33, 0, 0, %[res], %[res], %[ptr]":
                  [res]"+r"(result) : [ptr]"r"(ptr));
}

The IAR compiler will emit the following. As you can see a0 has been assigned the result variable (using the symbolic name res) and a1 assigned the variable ptr (here, the symbolic name is the same as the variable name).

   \   000014 0001'2503    lw        a0, 0x0(sp)
   \   000018 0000'05B7    lui       a1, %hi(bar)
   \   00001C 0005'8593    addi      a1, a1, %lo(bar)
   \   000020 00B5'0533    .insn r 0x33, 0, 0, a0, a0, a1
   \   000024 00A1'2023    sw        a0, 0x0(sp)

You can read more about the IAR inline assembly syntax in the book "IAR C/C++ Development Guide Compiling and linking for RISC-V", in chapter "Assembler Language Interface". The book is provided as a PDF, which you can access from within IAR Embedded Workbench.

Answer 2

Based on the snippet provided in your question, I tried the following code with the IAR C/C++ Compiler for RISC-V:

int funct();
int funct() { return 0xA5; } // stub

int bar = 0xFF00;

int main() {
    int k = funct();
    int* ptr = &bar;
    asm volatile (".insn r 0x33, 0, 0, %[res], %[ptr], %[k]"
                    : [res]"=r"(*ptr)
                    : [ptr]"r"(*ptr), [k]"r"(k));
}

In this case, the .insn directive will generate add r,r,r which is effectively *ptr = *ptr + k.

In an earlier version of this answer it was assumed that there would be a requirement to be explicit about which registers to use. For that, explicit register selectors were used as the IAR compiler simply allows it (e.g., "a3", ="a3", "a4", "a5", etc.). At that point, as noted by @PeterCordes in the comments, GCC offered a different set of constraints and would require a different solution. However, if there is no need to be explicit about the registers, it is better to let the compiler decide which ones can be used directly. It will generally impose less overhead.