打印__m128i变量(print a __m128i variable)

我想了解使用内部函数的代码和下面是不添加代码

compiler used: icc

#include<stdio.h>
#include<emmintrin.h>
int main()
{
        __m128i a = _mm_set_epi32(1,2,3,4);
        __m128i b = _mm_set_epi32(1,2,3,4);
        __m128i c;
        c = _mm_add_epi32(a,b);
        printf("%d\n",c[2]);
        return 0;
}

我得到下面的错误：

test.c(9): error: expression must have pointer-to-object type
        printf("%d\n",c[2]);

如何打印变量中的值c这类型的__m128i

Answer 1:

使用此功能可以打印出来：

void print128_num(__m128i var)
{
    uint16_t *val = (uint16_t*) &var;
    printf("Numerical: %i %i %i %i %i %i %i %i \n", 
           val[0], val[1], val[2], val[3], val[4], val[5], 
           val[6], val[7]);
}

你打印前分裂128位到16位（或32位）。

这是64位的分裂，如果你有64位支持可打印的一种方式：

void print128_num(__m128i var) 
{
    int64_t *v64val = (int64_t*) &var;
    printf("%.16llx %.16llx\n", v64val[1], v64val[0]);
}

Answer 2:

跨GCC /铛/ ICC / MSVC，C和C ++便携式的。
没有指针别名 （不像大多数其他的答案）：与所有的优化级别全面安全
打印十六进制为U8，U16，U32，U64或元素（基于@ AG1的答案）
在存储器预定打印（至少-显著元件第一，像_mm_setr_epiX ）。如果以相同的顺序英特尔手册使用，其中最显著元素是在左边（如喜欢印刷扭转数组索引_mm_set_epiX ）。相关阅读：会议显示向量寄存器

使用__m128i*从阵列加载int是安全的，因为__m128类型被定义为允许混叠。（例如，在gcc的标头，该定义包括__attribute__((may_alias))

反之并不安全的（一个__m128i对象和int指针）。它可能发生在大多数情况下工作，但为什么要冒险呢？

(uint32_t*) &my_vector违反了C和C ++重叠规则，并且不保证工作，你所希望的方式 。保存到本地数组，然后访问它保证是安全的。它甚至可以优化掉大部分的编译器，让您得到movq / pextrq直接从XMM到整数寄存器，而不是实际的存储/重装，例如。

在Godbolt编译探险来源+ ASM输出：证明它编译与MSVC等。

#include <immintrin.h>
#include <stdint.h>
#include <stdio.h>

#ifndef __cplusplus
#include <stdalign.h>   // C11 defines _Alignas().  This header defines alignas()
#endif

void p128_hex_u8(__m128i in) {
    alignas(16) uint8_t v[16];
    _mm_store_si128((__m128i*)v, in);
    printf("v16_u8: %x %x %x %x | %x %x %x %x | %x %x %x %x | %x %x %x %x\n",
           v[0], v[1],  v[2],  v[3],  v[4],  v[5],  v[6],  v[7],
           v[8], v[9], v[10], v[11], v[12], v[13], v[14], v[15]);
}

void p128_hex_u16(__m128i in) {
    alignas(16) uint16_t v[8];
    _mm_store_si128((__m128i*)v, in);
    printf("v8_u16: %x %x %x %x,  %x %x %x %x\n", v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
}

void p128_hex_u32(__m128i in) {
    alignas(16) uint32_t v[4];
    _mm_store_si128((__m128i*)v, in);
    printf("v4_u32: %x %x %x %x\n", v[0], v[1], v[2], v[3]);
}

void p128_hex_u64(__m128i in) {
    alignas(16) unsigned long long v[2];  // uint64_t might give format-string warnings with %llx; it's just long in some ABIs
    _mm_store_si128((__m128i*)v, in);
    printf("v2_u64: %llx %llx\n", v[0], v[1]);
}

如果需要移植到C99或C ++ 03或更早版本（即没有C11 / C ++ 11），除去alignas()和使用storeu ，而不是store 。或者使用__attribute__((aligned(16)))或__declspec( align(16) )来代替。

（如果你正在编写与内部函数的代码，你应该使用最新编译器版本。新的编译器通常做出更好的ASM比老的编译器，包括SSE / AVX内部函数。但也许你想使用gcc-6.3 -std=gnu++03 C ++ 03模式的代码库还没有准备好C ++ 11或什么的。）

从调用的所有4种功能的示例输出

// source used:
__m128i vec = _mm_setr_epi8(1, 2, 3, 4, 5, 6, 7,
                            8, 9, 10, 11, 12, 13, 14, 15, 16);

// output:

v2_u64: 0x807060504030201 0x100f0e0d0c0b0a09
v4_u32: 0x4030201 0x8070605 0xc0b0a09 0x100f0e0d
v8_u16: 0x201 0x403 0x605 0x807  | 0xa09 0xc0b 0xe0d 0x100f
v16_u8: 0x1 0x2 0x3 0x4 | 0x5 0x6 0x7 0x8 | 0x9 0xa 0xb 0xc | 0xd 0xe 0xf 0x10

如果你想垫与一致的输出宽度前导零调整格式字符串。见printf(3)

Answer 3:

我知道这个问题被标记C，而是寻找一个C ++解决同样的问题时，这是最好的搜索结果也。

所以，这可能是一个C ++实现：

#include <string>
#include <cstring>
#include <sstream>

#if defined(__SSE2__)
template <typename T>
std::string __m128i_toString(const __m128i var) {
    std::stringstream sstr;
    T values[16/sizeof(T)];
    std::memcpy(values,&var,sizeof(values)); //See discussion below
    if (sizeof(T) == 1) {
        for (unsigned int i = 0; i < sizeof(__m128i); i++) { //C++11: Range for also possible
            sstr << (int) values[i] << " ";
        }
    } else {
        for (unsigned int i = 0; i < sizeof(__m128i) / sizeof(T); i++) { //C++11: Range for also possible
            sstr << values[i] << " ";
        }
    }
    return sstr.str();
}
#endif

用法：

#include <iostream>
[..]
__m128i x
[..]
std::cout << __m128i_toString<uint8_t>(x) << std::endl;
std::cout << __m128i_toString<uint16_t>(x) << std::endl;
std::cout << __m128i_toString<uint32_t>(x) << std::endl;
std::cout << __m128i_toString<uint64_t>(x) << std::endl;

结果：

141 114 0 0 0 0 0 0 151 104 0 0 0 0 0 0
29325 0 0 0 26775 0 0 0
29325 0 26775 0
29325 26775

注：存在一个简单的方法，以避免if (size(T)==1)见https://stackoverflow.com/a/28414758/2436175

Answer 4:

#include<stdio.h>
#include<emmintrin.h>
int main()
{
    __m128i a = _mm_set_epi32(1,2,3,4);
    __m128i b = _mm_set_epi32(1,2,3,4);
    __m128i c;

    const int32_t* q; 
    //add a pointer 
    c = _mm_add_epi32(a,b);

    q = (const int32_t*) &c;
    printf("%d\n",q[2]);
    //printf("%d\n",c[2]);
    return 0;
}

试试这个代码。

文章来源: print a __m128i variable