Float64 位问题冷杉取消引用类型双关指针将破坏严格别名规则 [-Wstrict-aliasing]

Question

I'm trying the below code to get lower and higher 32-bit parts of Float64 bit value.

#define LSL_HI(x) *(1+(sInt32*)&x)
#define LSL_LO(x) *(sInt32*)&x

---

//warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing] 
sInt32 lx = LSL_LO(1111.2222); 

The [-Wstrict-aliasing] option is part of -O2 optimization and I don't have to disable this.

What is the solution to fix this issue?

This macro I have taken from GCC math lib itself.

Answer 1

If you want the literal bytes of a float 64 you can do this:

#include <cstdint>
static_assert(double == 8, "non 64-bit double!");

int 
main()
{
    double x = 1111.2222;
    uint32_t lo = static_cast<uint32_t>(reinterpret_cast<uint64_t>(x) & 0x00000000FFFFFFFF);
    uint32_t hi = static_cast<uint32_t>((reinterpret_cast<uint64_t>(x) & 0xFFFFFFFF00000000) >> (8*4));
    return 0;
}

I don't think this is what you are trying to do. If you instead want the fractional part of the double and the whole part you will need to try something else.

Answer 2

I'm not sure what you are trying to accomplish, same as what Dylan mentioned.

If you want to rip apart a double (assuming an IEEE 754 double), you could do this (I'm using ANSI escape sequences, which may be unsuitable for your environment). I've got both "ripping apart into hex bytes" and "ripping apart into sign / exponent / fraction":

#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>

using std::cout;
using std::fpclassify;
using std::memcpy;
using std::nan;
using std::numeric_limits;
using std::reverse;
using std::setw;
using std::size_t;
using std::string;
using std::stringstream;
using std::uint32_t;
using std::uint64_t;

namespace {

uint32_t low32_from(double d) {
    char const* p = reinterpret_cast<char const*>(&d);
    uint32_t result;
    memcpy(&result, p, sizeof result);
    return result;
}

uint32_t high32_from(double d) {
    char const* p = reinterpret_cast<char const*>(&d);
    p += 4;
    uint32_t result;
    memcpy(&result, p, sizeof result);
    return result;
}

string hexstr(uint32_t value) {
    char hex[] = "0123456789ABCDEF";
    unsigned char buffer[4];
    memcpy(buffer, &value, sizeof buffer);
    auto p = &buffer[0];
    stringstream ss;
    char const* sep = "";
    for (size_t i = 0; i < sizeof buffer; ++i) {
        ss << sep << hex[(*p >> 4) & 0xF] << hex[*p & 0xF];
        sep = " ";
        ++p;
    }

    return ss.str();
}

string bits(uint64_t v, size_t len) {
    string s;
    int group = 0;
    while (len--) {
        if (group == 4) { s.push_back('\''); group = 0; }
        s.push_back(v & 1 ? '1' : '0');
        v >>= 1;
        ++group;
    }
    reverse(s.begin(), s.end());
    return s;
}

string doublebits(double d) {
    auto dx = fpclassify(d);
    unsigned char buffer[8];
    memcpy(buffer, &d, sizeof buffer);
    stringstream ss;
    uint64_t s = (buffer[7] >> 7) & 0x1;
    uint64_t e = ((buffer[7] & 0x7FU) << 4) | ((buffer[6] >> 4) & 0xFU);
    uint64_t f = buffer[6] & 0xFU;
    f = (f << 8) + (buffer[5] & 0xFFU);
    f = (f << 8) + (buffer[4] & 0xFFU);
    f = (f << 8) + (buffer[3] & 0xFFU);
    f = (f << 8) + (buffer[2] & 0xFFU);
    f = (f << 8) + (buffer[1] & 0xFFU);
    f = (f << 8) + (buffer[0] & 0xFFU);

    ss << "sign:\033[0;32m" << bits(s, 1) << "\033[0m ";
    if (s) ss << "(-) ";
    else ss << "(+) ";

    ss << "exp:\033[0;33m" << bits(e, 11) << "\033[0m ";
    ss << "(" << setw(5) << (static_cast<int>(e) - 1023) << ") ";


    ss << "frac:";

    // 'i' for implied 1 bit, '.' for not applicable (so things align correctly).
    if (dx == FP_NORMAL) ss << "\033[0;34mi";
    else ss << "\033[0;37m.\033[34m";

    ss << bits(f, 52) << "\033[0m";

    if (dx == FP_INFINITE) ss << " \033[35mInfinite\033[0m";
    else if (dx == FP_NAN) ss << " \033[35mNot-A-Number\033[0m";
    else if (dx == FP_NORMAL) ss << " \033[35mNormal\033[0m";
    else if (dx == FP_SUBNORMAL) ss << " \033[35mDenormalized\033[0m";
    else if (dx == FP_ZERO) ss << " \033[35mZero\033[0m";

    ss << " " << d;

    return ss.str();
}

} // anon

int main() {
    auto lo = low32_from(1111.2222);
    auto hi = high32_from(1111.2222);
    cout << hexstr(lo) << "\n";
    cout << hexstr(hi) << "\n";
    cout << doublebits(1111.2222) << "\n";
    cout << doublebits(1.0) << "\n";
    cout << doublebits(-1.0) << "\n";
    cout << doublebits(+0.0) << "\n";
    cout << doublebits(-0.0) << "\n";
    cout << doublebits(numeric_limits<double>::infinity()) << "\n";
    cout << doublebits(-numeric_limits<double>::infinity()) << "\n";
    cout << doublebits(nan("")) << "\n";

    double x = 1.0;
    while (x > 0.0) {
        cout << doublebits(x) << "\n";
        x = x / 2.0;
    }
}

Answer 3

The ability to cast a pointer and use the freshly-cast pointer to perform type punning "in a documented fashion characteristic of the environment" is one the Standards Committee referred to as a "popular extension" [see page 11 of the Rationale]. The Standard deliberately refrains from requiring that even compilers that are not intended to be suitable for low-level programming tasks (such as decomposing 64-bit floating-point values directly into 32-bit chunks) must support it, but instead it allows compilers to support such constructs or not, based upon customers' needs or any other criteria the compiler writers see fit, and it allows such constructs to be used in programs in programs that seek merely to be "conforming" rather than "strictly conforming".

Implementations that make a bona fide effort to be maximally suitable for low-level programming tasks will support that extension by processing such constructs "in a documented fashion characteristic of the environment". GCC is issuing a warning because it is not configured to be suitable for such usage; adding the compilation flag -fno-strict-aliasing will configure it properly and thus eliminate the warning.

While compilers designed for low-level programming nned not guarantee that all possible situations involving type punning will be processed in the manner implied by object representations, they should have no difficulty supporting situations where casts a pointer and immediately dereferences it as the new type for the purposes of accessing an object of the original type. Implementations which do not seek to be maximally suitable for low-level programming, however, may require the use of clunkier constructs which, depending upon the target platform, may or may not be processed as efficiently. When invoked without the -fno-strict-aliasing flag, the optimizers of clang and gcc fall into the latter category.

As a general principle, optimizations that assume a program won't do X may be useful in cases where there is no need to do X, but counter-productive for code whose purpose could best be described using X. If a program would benefit from being able to use low-level type punning constructs, documenting that it is only suitable for use with compiler configurations that support them is better than trying to work around their absence, especially given that clang and gcc don't reliably uphold the Standard in corner cases that would arise when trying to work around their lack of low-level programming support.