Re: Inline assembly and value extensions

[Segher Boessenkool <segher@kernel.crashing.org>]

On Sat, Oct 03, 2020 at 09:42:40PM +0100, Harald van Dijk via Gcc-help wrote:
> On 22/08/2020 16:30, Harald van Dijk wrote:
> >This function gets an extra "movl %eax, %eax" between the hand-written 
> >movl and the generated ret, which can be seen online at 
> ><https://godbolt.org/z/T8bGPo>. This extra movl is there to ensure the 
> >high bits of %rax are zero, but the initial movl already achieves that. 
> >How can I inform GCC that it does not need to emit that extra movl?

If your asm returns a 32-bit value, then GCC will not know what is in
the top 32 bits of the 64-bit register.

> >Likewise, is there an easy way to provide an inline assembly statement 
> >with a zero-extended pointer input? This one I am able to work around, 
> >as it is possible to instead of passing in a pointer value p, pass in an 
> >integer value (uint64_t)(uint32_t)p, but the workaround is kind of hard 
> >to read and I would like to avoid that if possible.

You can use much less chatty names for those very basic types (like u64
and u32), that makes it more readable.  Hiding what you do will not make
it more readable, that is just obfuscation, so using macros is not such
a good idea.  Inline asm is hard enough when you can see all there is
right in front of your eyes.

> >I looked the documentation for either relevant inline assembly 
> >constraints or relevant variable / type attributes, but was unable to 
> >find any. The most promising search result was the mode attribute, I was 
> >hoping it might be possible to give result a mode(DI) attribute, but the 
> >compiler rejects that.

Constraints just say which register (or memory addressed how, or what
kind of constnt).  The normal way to say something should have a certain
mode is by giving it a corresponding type in C (so SImode is "int" in C,
and DImode is "long long"; "long" is either, it depends on your ABI;
"u64" and "u32" should always be clear ;-) )

> I have now found that forcing a different mode appears to be exactly how 
> the zero-extension of arguments and return values is implemented: that 
> is what ix86_promote_function_mode does.
> 
> The fact that this is not an option through variable attributes or 
> inline assembly constraints looks like an unfortunate limitation of the 
> inline assembly functionality, there is currently just no way to do what 
> I am after. I very much hope to be proved wrong, but will try to just 
> pick a workaround that does not look too bad.
> 
> >Is there another approach that I can use instead?

You use a 64-bit expression (or preferably even a 64-bit variable).  The
same is true for outputs from the asm.

One way of making the code easier to read is to actually use 64-bit
variables for all these things in the asm, and then assign them from and
to the 32-bit things.

  int x;
  char *p;
  u64 xx = x;
  u64 pp = (u64)p;
  asm("smth %0,%1" : "+r"(pp), "+r"(xx));
  p = (char *)pp;
  x = xx;


Segher