[Bug middle-end/109484] New: [Wrong Code][inline-asm] output operands overlap with output

["570070308 at qq dot com" <gcc-bugzilla@gcc.gnu.org>]

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.
```