Вектор реинтерпретировать литой ARM Neon

Question

У меня есть векторный регистр ARM NEON uint32x4_t. Я хочу "перемешать" эти 4 uint32_t с vtbx2 и vext

Интерфейс для ожиданий поиска в таблице uint8x8_t, Это представляется возможным с помощью приведения, особенно потому, что в документации говорится, что

"[...] преобразования не изменяют битовую комбинацию, представленную вектором".

Я попробовал это с помощью следующего кода:

#include <iostream>
#include <arm_neon.h>
#include <bitset>

int main() {
   uint32_t* data = new uint32_t[4];
   uint32_t* result = new uint32_t[4];
   //00 00 0A 0A
   data[0] = 2570;
   //00 0A 00 0A
   data[1] = 655370;
   //0A 0A 0A 0A
   data[2] = 168430090;
   //00 00 00 0A
   data[3] = 10;

   //load data
   uint32x4_t dataVec = vld1q_u32(data);
   //cast to uint8
   uint8x16_t dataVecByteTmp = vreinterpretq_u8_u32(dataVec);

   uint32_t* tmpData = new uint32_t[4];
   //store original data
   vst1q_u32(tmpData, dataVec);

   std::cout << "Orig Data:" << std::endl;
   for(int i = 0; i < 4; ++i) {
      std::bitset<32> f(tmpData[i]);
      std::cout << f << std::endl;
   }

   uint8_t* high = new uint8_t[16];
   //store uint8 data
   vst1q_u8(high, dataVecByteTmp);

   std::cout << "unsigned output" << std::endl;
   for(int i = 0; i < 16; ++i) {
      std::cout << (unsigned)high[i] << std::endl;
   }
   std::cout << "bitwise output" << std::endl;
   for(int i = 0; i < 16; ++i) {
      std::bitset<8> b(high[i]);
      std::cout << b << std::endl;
   }
   delete[] tmpData;
   delete[] high;    
   delete[] data;
   delete[] result;
   return 0;
}

Можно скомпилировать это с:

g ++ -march = native -mfpu = neon -std = C++14 main.cpp

Выход выглядит следующим образом:

Orig Data:
00000000000000000000101000001010
00000000000010100000000000001010
00001010000010100000101000001010
00000000000000000000000000001010

unsigned output
10 
10 
0 
0 
10 
0 
10 
0 
10 
10 
10 
10 
10 
0 
0 
0 

bitwise output
00001010
00001010
00000000
00000000
00001010
00000000
00001010
00000000
00001010
00001010
00001010
00001010
00001010
00000000
00000000
00000000

Для лучшего обзора я немного изменил форматирование:

Orig (uint32_t):
00000000 00000000 00001010 00001010
00000000 00001010 00000000 00001010
00001010 00001010 00001010 00001010
00000000 00000000 00000000 00001010

New (uint8_t):
10 10 0   0 
10  0 10  0 
10 10 10 10 
10  0  0  0

New (uint8_t bitwise):
00001010 00001010 00000000 00000000
00001010 00000000 00001010 00000000
00001010 00001010 00001010 00001010
00001010 00000000 00000000 00000000

Как видно, результат не такой, как ожидалось. Кто-нибудь знает, сделал ли я что-то не так или это просто ошибка?

Искренне