https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109484
Bug ID: 109484
Summary: [Wrong Code][inline-asm] output operands overlap with
output
Product: gcc
Version: 13.0
Status: UNCONFIRMED
Severity: normal
Priority: P3
Component: middle-end
Assignee: unassigned at gcc dot gnu.org
Reporter: 570070308 at qq dot com
Target Milestone: ---
For code:
```c
void kkk(void **const pp)
{
void *temp;
__asm__ volatile (
"movq %1, %0\n\t"
"movq $0, %1"
:"=r"(temp), "+m"(*pp)
:
:);
__asm__ volatile(""::"D"(temp):);
}
```
After compile with -O3:
```assemble
kkk:
movq (%rdi), %rdi
movq $0, (%rdi) # %rdi overlap, abort if %rdi == NULL
ret
```
I think there's nothing wrong with this c code according to gcc inline asm doc:
``` From GCC DOC
GCC may allocate the output operand in the same register as an unrelated input
operand, on the assumption that the assembler code consumes its inputs before
producing outputs.
```
The C code do read *pp first, then write the output.
I think according to gcc's doc, an output operand(without'&') will only overlap
to input operands.
``` From GCC DOC
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.
Use the ‘&’ constraint modifier (see Modifiers) on all output operands that
must not overlap an input. Otherwise, GCC may allocate the output operand in
the same register as an unrelated input operand, on the assumption that the
assembler code consumes its inputs before producing outputs. This assumption
may be false if the assembler code actually consists of more than one
instruction.
The same problem can occur if one output parameter (a) allows a register
constraint and another output parameter (b) allows a memory constraint. The
code generated by GCC to access the memory address in b can contain registers
which might be shared by a, and GCC considers those registers to be inputs to
the asm. As above, GCC assumes that such input registers are consumed before
any outputs are written. This assumption may result in incorrect behavior if
the asm statement writes to a before using b. Combining the ‘&’ modifier with
the register constraint on a ensures that modifying a does not affect the
address referenced by b. Otherwise, the location of b is undefined if a is
modified before using b.
```
