[SOLVED] Input parameter index when using "+" modifier in extended asm output parameter?

Issue

Extended asm gives the following description regarding the "+" modifier:

Operands using the ‘+’ constraint modifier count as two operands (that is, both as input and output) towards the total maximum of 30 operands per asm statement.

So I assume that it is not necessary to mention output operand with the "+" modifier in the input section again, but it is not specified how to determine their index. I wrote the following example Godbolt :

#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>

void asm_add(uint64_t o1, uint64_t o2, uint64_t o3){
    __asm__ volatile (
        "addq %2, %3\n\
        addq %2, %4":    
        "+r" (o2), "+r" (o3):
        "r" (o1):
        "cc"
    );
    printf("o2 = %" PRIu64 "\n", o2);
    printf("o3 = %" PRIu64 "\n", o3);
}


int main(void){
    asm_add(20, 30, 40);
}

Which printed

o2 = 50
o3 = 60

Is the template using +

__asm__ volatile (
   "addq %2, %3\n\
    addq %2, %4":    
    "+r" (o2), "+r" (o3):
    "r" (o1):
    "cc"
);

exactly the same as

__asm__ volatile (
    "addq %2, %3\n\
    addq %2, %4":    
    "+r" (o2), "+r" (o3):
    "r" (o1), "0" (o2), "1" (o3):
    "cc"
);

where all inputs are specified explicitly? So in the first example the "implicit" inputs are appended.

Solution

By using "+r" (o2), you are saying that this parameter needs to contain o2 on entry to the asm block, and will contain an updated value on exit.

In other words, %0 describes both input and output. The fact that you can (apparently?) reference indices greater than the number of parameters is an undocumented quirk. Don't depend upon it.

You might also consider using symbolic names, which (I find) are easier to read, especially as the number of asm lines goes up. Names are particularly useful when you are first creating the asm and there's the potential for adding/removing parameters. Having to renumber everything is painful and error prone:

__asm__ volatile (
    "addq %[o1], %[o2]\n\
    addq %[o1], %[o3]":    
    [o2] "+r" (o2), [o3] "+r" (o3):
    [o1] "r" (o1):
    "cc"
);

Lastly, consider not using inline asm for anything beyond educational purposes. And even then, inline asm is the hardest possible way to learn asm.

Answered By - David Wohlferd