Inline assembly doesn't work with FP constraint

[alexchandel]

The following code:

pub fn log(x: f64) -> f64
{
    let out: f64;
    unsafe {
    asm!("fldln2
        fldl $1
        fyl2x" : "=t"(out) : "m"(x));}
    out
}

errors with the message:

error: couldn't allocate output register for constraint 't' at line 27

The constraint t refers to the top of the floating point stack in GCC's inline assembly, and the unsafe guide says our constraints mirror theirs.

[huonw]

Our constraints do not duplicate GCC; its just that we implement several of the same constraints GCC supports.

t is evidently one of the ones that is not implemented.

It is a bug in the unsafe guide if it says that we match GCC entirely.

[alexchandel]

I wish constraints were documented somewhere.

How do we implement constraints for registers on the floating point stack?

[klutzy]

We currently just translates asm! into llvm inline asm.

Clang-3.4 translates "=t" to "={st}". So we can use "={st}" as well, but I think we may have to do what clang does..

[klutzy]

Relevant clang code

[steveklabnik]

The chapter of the book says that we're "Like GCC and Clang" and points to the LLVM inline asm stuff, so I'm going to give this one a close.

[klutzy]

@steveklabnik This is still an issue; we currently don't do like "GCC and Clang". We do like llvm IR which is different from GCC/Clang.

For given GCC/Clang inline asm:

__asm__("fldln2; fldl %1; fyl2x" : "=t"(out) : "m"(x));

Clang-3.7 emits the following LLVM IR:

%2 = call double asm "fldln2; fldl $1; fyl2x",
"={st},*m,~{dirflag},~{fpsr},~{flags}"(double* %1) #2, !srcloc !1

where "=t" (GCC x86 constraint) is converted to "={st}" (LLVM IR constraint; undocumented?).

Currently we simply pass asm!() arguments without such conversion, so only "={st}" works.

[alexchandel]

@steveklabnik I agree with @klutzy, this is exactly what I found confusing initially.

We could actually be "Like GCC and Clang" and translate "=t" to "={st}", which is what I'd assume after reading the phrase "Like GCC and Clang", or we could say we're like LLVM IR.

[steveklabnik]

Okay, sorry for missing the boat here.

[alexchandel]

@steveklabnik nw. I don't even know whether rustc should support GCC/Clang inline assembly, though it might improve ease of use. It just felt like a papercut to find out the hard way that it doesn't.