如何创建不会破坏严格混叠的uint8_t数组

How to create an uint8_t array that does not undermine strict aliasing?

本文关键字：uint8 数组 何创建 创建      更新时间：2023-10-16

我最近问了这个问题：

使用此指针会导致热循环中出现奇怪的去优化

问题是我正在写入一个 uint8_t 类型的数组，编译器将其视为可以使用方法(类型 struct T*(的this指针进行别名，因为void*和char*(= uint8_t*(总是可以在C++中为任何其他指针别名。此行为导致错失优化机会。当然，我想避免这种情况。所以问题是：我是否可以声明一个强制严格混叠的uint8_t数组，即编译器将其视为从不与其他类型的任何指针混叠？即，我正在寻找类似strict_uint8_t类型的东西，它是一种具有特殊混叠行为的uint8_t。有没有办法实现这一目标？

示例代码来显示我的意思，借用其他问题并简化。有关更多详细信息，请阅读链接的问题及其接受的答案：

struct T{
   uint8_t* target;
   void unpack3bit(char* source, int size) {
        while(size > 0){
           uint64_t t = *reinterpret_cast<uint64_t*>(source);
           /** `this->target` cannot be cached in a register here but has
               to be reloaded 16 times because the compiler
               thinks that `this->target` could alias with `this` itself.
               What I want is a special uint8_t type that does not trigger
               this behaviour. */
           this->target[0] = t & 0x7; 
           this->target[1] = (t >> 3) & 0x7;
           this->target[2] = (t >> 6) & 0x7;
           this->target[3] = (t >> 9) & 0x7;
           this->target[4] = (t >> 12) & 0x7;
           this->target[5] = (t >> 15) & 0x7;
           this->target[6] = (t >> 18) & 0x7;
           this->target[7] = (t >> 21) & 0x7;
           this->target[8] = (t >> 24) & 0x7;
           this->target[9] = (t >> 27) & 0x7;
           this->target[10] = (t >> 30) & 0x7;
           this->target[11] = (t >> 33) & 0x7;
           this->target[12] = (t >> 36) & 0x7;
           this->target[13] = (t >> 39) & 0x7;
           this->target[14] = (t >> 42) & 0x7;
           this->target[15] = (t >> 45) & 0x7;
           source+=6;
           size-=6;
           target+=16;
        }
}
};

可以使用基类型 uint8_t 的固定大小枚举：

enum strict_uint8_t : uint8_t {};

如果您希望能够以透明的方式与uint8_t进行转换，则可以将其包装在带有转换构造函数和转换运算符的struct中：

struct strict_uint8_t {
    enum : uint8_t {} i;
    strict_uint8_t(uint8_t i) : i{i} {}
    operator uint8_t() const { return i; }
};

这似乎消除了 gcc 和 clang 中的混叠悲观化：https://godbolt.org/g/9Ta98b

(注意：以前的方法使用位域，在 gcc 中有效，但在 clang 中不起作用。

在Visual Studio中，你可以对函数使用__declspec(restict)，对变量使用__restrict来告诉编译器指针是无别名的。我相信在像GCC这样的其他编译器中，有一个__restrict__属性(但我不确定(。欲了解更多信息，请参阅此处

我相信

，如果您通过一个函数传递两个指针，其中指针都声明为 restrict，您将摆脱别名。不过，这是非标准的编译器扩展，例如在 g++ 的情况下：

#include <cstdint>
#include <climits>
struct T{
   uint8_t* target;
  private:
    void unpack3bit(char*__restrict__ source, int size, uint8_t*__restrict__ dst) {
        while(size > 0){
           uint64_t t = *source;
           dst[0] = t & 0x7; 
           dst[1] = (t >> 3) & 0x7;
           dst[2] = (t >> 6) & 0x7;
           dst[3] = (t >> 9) & 0x7;
           dst[4] = (t >> 12) & 0x7;
           dst[5] = (t >> 15) & 0x7;
           dst[6] = (t >> 18) & 0x7;
           dst[7] = (t >> 21) & 0x7;
           dst[8] = (t >> 24) & 0x7;
           dst[9] = (t >> 27) & 0x7;
           dst[10] = (t >> 30) & 0x7;
           dst[11] = (t >> 33) & 0x7;
           dst[12] = (t >> 36) & 0x7;
           dst[13] = (t >> 39) & 0x7;
           dst[14] = (t >> 42) & 0x7;
           dst[15] = (t >> 45) & 0x7;
           source+=6;
           size-=6;
           target+=16;
        }
    }
public:
   void unpack3bit(char* source, int size) {
       unpack3bit(source,size,this->target);
   }
};
void f(int i, T& t, char* source) {
  t.unpack3bit(source, i); 
}

在线： http://goo.gl/SCjpL6

相关文章：