内联装配; 浮点按位运算; 这里出了什么问题？

Question

This simple piece of code is my problem:

Extended asm (gcc); Intel syntax (-masm=intel); Platform - x86

What it should do: Return a float with length of one and the sign (+-) the same as x's.

    float signf(float x)
    {
      float r = 1;
      asm volatile (
            "and %1,0x80000000;"
            "or %0,%1;"
            :"=r"(r):"r"(x));
      return r;
    }

Calling it with an arbitrary random number chosen by a fair dice roll gives:

    signf of -1352353.3253: -5.60519e-045

Answer 1

The actual problem with your inline asm is that you declare r as output only, so the compiler will optimize away the initialization. You should use "+r" constraint instead of "=r" and it should work.

A better optimized version could look like:

float signf(float x)
{
    float r;
    __asm__  __volatile__ (
            "and %0, 0x80000000;"
            "or %0, 0x3f800000;"
            :"=r"(r):"0"(x));
    return r;
}

Note that this function involves float->int->float conversion (through memory) which may affect performance.

The C version of the above code is:

float signf(float x)
{
    union { float f; int i; } tmp, res;
    tmp.f = x;
    res.f = 1;
    res.i |= tmp.i & 0x80000000;
    return res.f;
}

This generates identical code for me (using gcc 4.4.5).

The simple C approach return x < 0 ? -1 : 1; return x < 0 ? -1 : 1; generates full FPU code without conversion or memory accesses (except for loading the operand) so might perform better. It also uses fcmov if available to avoid branching. Needs some benchmarking.

Answer 2

There are two C++ functions for this in C++11:

bool std::signbit (x);

http://en.cppreference.com/w/cpp/numeric/math/signbit

or,

float f = std::copysign (1.0f, x);

http://en.cppreference.com/w/cpp/numeric/math/copysign

Answer 3

This seems to work well (AT&T syntax):

float signf(float x)
{
  float r = 1;
  asm ("andl $0x80000000, %1\n"
       "\torl %1, %0\n"
       :"+r"(r):"r"(x));
  return r;
}

TBH, I would use copysignf() as suggested by others. What you are trying to do is unportable both because it is tied only to IA-32 platform and C++ compilers that can do this asm() statement.

EDIT 1

BTW, the following version works the same (and generates pretty much the same instructions as the above asm() statement) and is free of non-portable stuff and type aliasing issues (unlike the union based or reinterpret_cast<> based versions suggested by others).

float signf3(float x)
{
  unsigned u;
  std::memcpy(&u, &x, sizeof (u)) ;

  float r = 1.f;
  unsigned uone;
  std::memcpy(&uone, &r, sizeof (uone));

  uone |= u & 0x80000000;

  std::memcpy(&r, &uone, sizeof (r));
  return r;
}

Answer 4

这个问题标记为C ++，因此我将提供两个C ++建议，您可以让编译器进行优化：

• return x < 0.0f ? -1.0f : 1.0f;
• return x / std::abs(x); // I believe self-division shouldn't cause 'almost 1.0' numbers to be genereated

Answer 5

You do not need to use asm for this. The following does what you tried to do (even the correct result for -0.0f).

float signf(float x) {
    bool sign=(0!=(*(reinterpret_cast<uint32_t *>(&x)) & 0x80000000));
    return sign? -1.0f : 1.0f;
}