使用（float＆）int可以进行类型修剪，（float const＆）int可以像（float）int那样转换吗？

时间：2019-01-31 06:28:32

标签： c++ assembly visual-c++ sse intrinsics

VS2019，x86版本。

template <int i> float get() const {
    int f = _mm_extract_ps(fmm, i);
    return (float const&)f;
}

使用return (float&)f;编译器时使用

extractps m32, ...
movss xmm0, m32

。正确的结果

使用return (float const&)f;编译器时使用

extractps eax, ...
movd xmm0, eax

。错误的结果

T＆和T const＆首先是T，然后是const的主要思想。 const只是程序员的某种协议。您知道可以解决它。但是汇编代码中没有任何const，只能输入float IS。而且我认为对于float＆和float const＆，它都必须是汇编中的float表示形式（cpu寄存器）。我们可以使用中间int reg32，但最终解释必须是float。

此时，它看起来像回归，因为以前效果很好。而且在这种情况下使用float＆绝对是奇怪的，因为我们不应该涉及float const＆安全性，但是float＆的temp var确实值得怀疑。

微软回答：

  

您好，Truthfinder，感谢您提供的独立复制程序。当它发生的时候，   这种行为实际上是正确的。作为我的同事@范凡[MSFT]   在内部电子邮件中描述：

     

[c样式强制转换]执行的转换尝试以下操作   顺序：   （4.1）— const_cast（7.6.1.11），   （4.2）— static_cast（7.6.1.9），   （4.3）— static_cast后跟const_cast，   （4.4）-reinterpret_cast（7.6.1.10），或   （4.5）—重新解释后跟const_cast，

     

如果可以用以上列出的多种方法来解释转换   以上，使用的是列表中第一个出现的解释。

     

因此，在您的情况下，（const float＆）将转换为static_cast，其作用是“初始值设定项表达式为   隐式转换为类型“ cv1 T1”的prvalue。临时的   应用实现转换，并且引用绑定到   结果。”

     

但在另一种情况下，（float＆）转换为   reinterpret_cast，因为static_cast无效，   与reinterpret_cast（＆operand）相同。

     

您观察到的实际“错误”是一个强制转换：   将float类型的值“ 1.0”转换为等效的int类型的值“ 1””，   而另一位演员表示“将1.0的位表示形式   浮动，然后将这些位解释为int”。

     

基于这个原因，我们建议您不要使用c样式的强制类型转换。

     

谢谢！

MS论坛链接：https://developercommunity.visualstudio.com/content/problem/411552/extract-ps-intrinsics-bug.html

有什么想法吗？

P.S。我真正想要的是什么：

float val = _mm_extract_ps(xmm, 3);

在手动汇编中，我可以编写：extractps val, xmm0, 3，其中val是float 32内存变量。只有一个！指令。我想在编译器生成的汇编代码中看到相同的结果。请勿乱序或其他过多指示。最糟糕的情况是：extractps reg32, xmm0, 3; mov val, reg32。

关于T＆和T const＆的观点： 两种情况下，变量的类型必须相同。但是现在float&会将m32解释为float32，而float const&会将m32解释为int32。

int main() {
    int z = 1;
    float x = (float&)z;
    float y = (float const&)z;
    printf("%f %f %i", x, y, x==y);
    return 0;
}
  

输出：0.000000 1.000000 0

真的可以吗？

最好的问候， 真相发现者

4 个答案:

答案 0 :(得分：10)

关于C ++强制转换语义存在一个有趣的问题（Microsoft已经为您简短地回答了这个问题），但是它与您误用_mm_extract_ps混合在一起，导致首先需要进行类型双关。 / strong>（并且仅显示等价的asm，省略int-> float转换。）如果其他人想在其他答案中扩展标准语言，那就太好了。

TL：DR：改用它：0或1 shufps。没有提取物，没有类型修饰。

template <int i> float get(__m128 input) {
    __m128 tmp = input;
    if (i)     // constexpr i means this branch is compile-time-only
        tmp = _mm_shuffle_ps(tmp,tmp,i);  // shuffle it to the bottom.
    return _mm_cvtss_f32(tmp);
}

如果您实际上有一个内存目标用例，则应该在asm中查找需要一个float*输出arg的函数，而不是需要xmm0中的结果的函数。 （是的，这是extractps指令的用例，但可以说不是_mm_extract_ps内在函数。优化extractps时，gcc和clang使用*out = get<2>(in)，尽管MSVC错过了仍然使用shufps + movss。）

您显示的两个asm块只是将xmm0的低32位复制到某个地方，而没有转换为int。您忽略了重要的区别，只展示了无用的部分，它以两种不同的方式（注册或存储）无用地从xmm0中复制了float位模式，然后又将其复制回来。 movd是未经修改的位的纯副本，就像movss负载一样。

在强制编译器完全使用extractps之后，使用编译器进行选择。通过寄存器来回执行比通过存储/重新加载来的延迟要短，但是要处理更多的ALU。

(float const&)进行双打的尝试确实包括从FP到整数的转换，您没有显示。好像我们需要更多的理由来避免指针/引用强制转换进行类型操作一样，这的确意味着不同：（float const＆）f采用整数位模式（来自_mm_extract_ps）作为int 并将其转换为float。

我输入了您的代码on the Godbolt compiler explorer，以查看您遗漏的内容。 

float get1_with_extractps_const(__m128 fmm) {
    int f = _mm_extract_ps(fmm, 1);
    return (float const&)f;
}

;; from MSVC -O2 -Gv  (vectorcall passes __m128 in xmm0)
float get1_with_extractps_const(__m128) PROC   ; get1_with_extractps_const, COMDAT
    extractps eax, xmm0, 1   ; copy the bit-pattern to eax

    movd    xmm0, eax      ; these 2 insns are an alternative to pxor xmm0,xmm0 + cvtsi2ss xmm0,eax to avoid false deps and zero the upper elements
    cvtdq2ps xmm0, xmm0    ; packed conversion is 1 uop
    ret     0

GCC这样编译：

get1_with_extractps_const(float __vector(4)):    # gcc8.2 -O3 -msse4
        extractps       eax, xmm0, 1
        pxor    xmm0, xmm0            ; cvtsi2ss has an output dependency so gcc always does this
        cvtsi2ss        xmm0, eax     ; MSVC's way is probably better for float.
        ret

显然，MSVC确实定义了用于类型处理的指针/引用转换的行为。普通ISO C ++不会（严格别名UB），其他编译器也不会。使用memcpy进行双打或联合（C ++中的GNU C和MSVC支持作为扩展名）。当然，在这种情况下，将要向量的矢量元素类型化为整数然后返回是可怕的。

gcc仅针对(float &)f发出有关严格混叠违规的警告。 GCC / clang同意MSVC，只有该版本是类型双关语，而不是通过隐式转换实现float。 C ++很奇怪！

float get1_with_extractps_nonconst(__m128 fmm) {
    int f = _mm_extract_ps(fmm, 1);
    return (float &)f;
}

<source>: In function 'float get_with_extractps_nonconst(__m128)':
<source>:21:21: warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
     return (float &)f;
                     ^

gcc完全优化了extractps。

# gcc8.2 -O3 -msse4
get1_with_extractps_nonconst(float __vector(4)):
    shufps  xmm0, xmm0, 85    ; 0x55 = broadcast element 1 to all elements
    ret

Clang使用SSE3 movshdup将元素1复制到0。（并将元素3复制到2）。 但是MSVC没有，这是永远不要使用它的另一个原因：

float get1_with_extractps_nonconst(__m128) PROC
    extractps DWORD PTR f$[rsp], xmm0, 1     ; store
    movss   xmm0, DWORD PTR f$[rsp]          ; reload
    ret     0

请勿为此使用_mm_extract_ps

您的两个版本都很糟糕，因为这不是_mm_extract_ps或extractps的目标。 Intel SSE: Why does `_mm_extract_ps` return `int` instead of `float`?

寄存器中的float与向量的低位元素相同。高元素不需要清零。如果这样做的话，您可能想使用insertps，它可以根据立即数执行xmm，xmm和零元素。

使用_mm_shuffle_ps将所需的元素移到寄存器的低位，然后 是标量浮点数。 （您可以使用_mm_cvtss_f32告诉C ++编译器）。这应该只编译为shufps xmm0,xmm0,2，不 extractps或任何mov。

template <int i> float get() const {
    __m128 tmp = fmm;
    if (i)                               // i=0 means the element is already in place
        tmp = _mm_shuffle_ps(tmp,tmp,i);  // else shuffle it to the bottom.
    return _mm_cvtss_f32(tmp);
}

（我跳过使用_MM_SHUFFLE(0,0,0,i)，因为它等于i。）

如果您的fmm在内存中，而不是在寄存器中，那么希望编译器可以优化改组而仅优化movss xmm0, [mem]。 MSVC 19.14确实做到了这一点，至少对于堆栈情况下的function-arg而言。我没有测试其他编译器，但是clang应该可以设法优化_mm_shuffle_ps；很好看透了。

测试用例证明了这一点可以有效地编译

例如一个测试用例，其中包含您的函数的非类成员版本，以及一个调用程序，用于内联特定的i：

#include <immintrin.h>

template <int i> float get(__m128 input) {
    __m128 tmp = input;
    if (i)                  // i=0 means the element is already in place
        tmp = _mm_shuffle_ps(tmp,tmp,i);  // else shuffle it to the bottom.
    return _mm_cvtss_f32(tmp);
}

// MSVC -Gv (vectorcall) passes arg in xmm0
// With plain dumb x64 fastcall, arg is on the stack, and it *does* just MOVSS load without shuffling
float get2(__m128 in) {
    return get<2>(in);
}

From the Godbolt compiler explorer，MSVC，clang和gcc的asm输出：

;; MSVC -O2 -Gv
float get<2>(__m128) PROC               ; get<2>, COMDAT
        shufps  xmm0, xmm0, 2
        ret     0
float get<2>(__m128) ENDP               ; get<2>

;; MSVC -O2  (without Gv, so the vector comes from memory)
input$ = 8
float get<2>(__m128) PROC               ; get<2>, COMDAT
        movss   xmm0, DWORD PTR [rcx+8]
        ret     0
float get<2>(__m128) ENDP               ; get<2>

# gcc8.2 -O3 for x86-64 System V (arg in xmm0)
get2(float __vector(4)):
        shufps  xmm0, xmm0, 2   # with -msse4, we get unpckhps
        ret

# clang7.0 -O3 for x86-64 System V (arg in xmm0)
get2(float __vector(4)):
        unpckhpd        xmm0, xmm0      # xmm0 = xmm0[1,1]
        ret

clang的随机优化器简化为unpckhpd，在某些旧CPU上速度更快。不幸的是，它没有注意到它可以使用movhlps xmm0,xmm0，它也很快并且短了1个字节。

答案 1 :(得分：8)

  

我对T&和T const&的观点：两种情况下变量的类型必须相同。

正如Microsoft的支持人员试图解释的那样，所有这些都不相同。这就是C ++的工作方式。

您使用的是C样式的强制转换( ... )，在C ++中，它分解为一系列尝试，以降低安全性的顺序使用不同的C ++强制转换：

  • （4.1）—一个const_cast
  • （4.2）—一个static_cast
  • （4.3）-static_cast后跟const_cast
  • （4.4）—一个reinterpret_cast
  • （4.5）-reinterpret_cast后跟const_cast

对于 (float const&) b （其中b是int）：

  • 我们尝试const_cast<float const&>(b);-不走运（float与int）
  • 我们尝试static_cast<float const&>(b);-瞧！ （在将b隐式转换为临时float之后，请记住，C ++允许自己对每个表达式implicitly执行两次标准转换和一次用户定义转换）

对于 (float&) b （同样b是int的情况）：

  • 我们尝试const_cast<float&>(b);-不走运
  • 我们尝试static_cast<float&>(b);-不走运（在将b隐式标准转换为临时float之后，它不会绑定到非const左值引用）
  • 我们尝试const_cast<float&>(static_cast<float&>(b));-不走运
  • 我们尝试reinterpret_cast<float&>(b);-瞧！

除了严格的别名规则 1 ，下面的示例演示了此行为：

#include <iostream>

int main() {
    float a = 1.2345f;
    int b = reinterpret_cast<int&>(a); // this type-pun is built into _mm_extract_ps
    float nc = (float&)b;
    float cc = (float const&)b;
    float rc = reinterpret_cast<float&>(b);
    float sc = static_cast<float const&>(b);
    std::cout << "a=" << a << " b=" << b << std::endl;
    std::cout << "nc=" << nc << " cc=" << cc << std::endl;
    std::cout << "rc=" << rc << " sc=" << sc << std::endl;
}

打印：

a=1.2345 b=1067320345
nc=1.2345 cc=1.06732e+09
rc=1.2345 sc=1.06732e+09

LIVE DEMO

这就是为什么您不应该在C ++中使用C样式的强制转换。打字少，但头痛得多。

也不要使用_mm_extract_ps-它返回int的原因是因为extractps指令将float复制到通用寄存器-这是不是您想要的内容，因为要使用一个float，必须将其复制回浮点寄存器。因此，这样做是在浪费时间。正如彼得·科德（Peter Cordes）解释的那样，请改用_mm_cvtss_f32(_mm_shuffle_ps())，它会编译为一条指令。

1 从技术上讲，使用reinterpret_cast来规避C ++类型系统（也称为punning）是ISO C ++中未定义的行为。但是，MSVC放宽了此规则作为编译器扩展。因此，该代码是正确的，只要它是使用MSVC或可以关闭strict aliasing rule的其他地方（例如-fno-strict-aliasing）编译的。不打入严格的别名陷阱的标准输入方式是通过memcpy()。

答案 2 :(得分：0)

我看到有人喜欢设置负号。看来我对*(float*)&几乎是正确的。但是，更好的方法当然是使用 standard intrin .h解决方案进行交叉编译。 MSVS，smmintrin.h：

#define _MM_EXTRACT_FLOAT(dest, src, ndx) \
        *((int*)&(dest)) = _mm_extract_ps((src), (ndx))

如您所见，有一个用于此目的的官方宏。当然，其他平台也可能有所不同。仍然想知道为什么英特尔选择了这样的解决方案，但这还是另一个问题。

答案 3 :(得分：-2)

好的。听起来像无法将float val = _mm_extract_ps(xmm, 3)编译为单个extractps val, xmm0, 3指令的想法。

我仍然使用*(float*)&intval，因为它可以在任何msvc版本上正常工作。

对于int _mm_extract_ps来说，这绝对是糟糕的设计。 _ps用于浮点类型，而epi32用于int32类型。指令提取没有输入，因此必须是两个不同的函数int _mm_extract_epi32(__m128i(), 3)和float _mm_extract_ps(__m128(), 3)。

P.S。 http://aras-p.info/blog/2018/12/28/Modern-C-Lamentations/

我不知道为什么语言委员会或其他任何人采用此解决方案，但是memcpy只是not beautiful。而且我敢肯定，这会给编译器带来其他问题，并且无法获得单指令结果。据我了解，推荐的解决方案是int i = _mm_extract_ps(...); float f; std::memcpy(&f, &i, sizeof(f));。对于我来说，float f = static_cast<float const&>(_mm_extract_ps(...));更为简洁明了。 Ref是因为函数返回值而不是指针，const是因为您无法更改它。看起来像是直观的解决方案。 Const只是编译器问题，最终汇编中没有任何const指令。

相关问题
最新问题