注意
これは私の「厳格なエイリアシングルールとは何か、なぜ私たちは気にするのか」からの抜粋です。書き上げる。
厳密なエイリアスとは何ですか？
CおよびC ++では、エイリアシングは、格納された値へのアクセスを許可されている式のタイプに関係しています。CとC ++の両方で、標準では、どの型にエイリアスを付けることができる式の型が指定されています。コンパイラとオプティマイザは、エイリアシングルールに厳密に従っていることを前提としているため、厳密なエイリアシングルールと呼ばれます。許可されていないタイプを使用して値にアクセスしようとすると、未定義の動作（UB）として分類されます。未定義の動作が発生すると、すべての賭けが無効になり、プログラムの結果は信頼できなくなります。
残念ながら、厳密なエイリアシング違反があると、予想どおりの結果が得られることが多く、新しい最適化を備えたコンパイラの将来のバージョンでは、有効であると考えたコードが壊れる可能性があります。これは望ましくないことであり、厳密なエイリアシングルールとその違反を回避する方法を理解することは価値のある目標です。
なぜ私たちが気にするのかをさらに理解するために、厳密なエイリアシングルールに違反するときに発生する問題について説明します。
予備的な例
いくつかの例を見てみましょう。次に、規格の発言について正確に話し、さらにいくつかの例を調べて、厳密なエイリアシングを回避し、見逃した違反をキャッチする方法を確認します。これは驚くべきことではない例です（実例）：
int x = 10;
int *ip = &x;
std::cout << *ip << "\n";
*ip = 12;
std::cout << x << "\n";
我々は持っているのint *メモリを指すが、によって占めint型とこれが有効なエイリアスです。オプティマイザは、ipによる割り当てがxが占める値を更新できると想定する必要があります。
次の例は、未定義の動作につながるエイリアスを示しています（実際の例）：
int foo( float *f, int *i ) {
*i = 1;
*f = 0.f;
return *i;
}
int main() {
int x = 0;
std::cout << x << "\n"; // Expect 0
x = foo(reinterpret_cast<float*>(&x), &x);
std::cout << x << "\n"; // Expect 0?
}
関数fooでは、int *とfloat *を受け取ります。この例では、fooを呼び出し、両方のパラメーターを、この例ではintを含む同じメモリー位置を指すように設定します。reinterpret_castは、テンプレートパラメーターで指定された型があるかのように式を扱うようにコンパイラーに指示していることに注意してください。この場合、式＆xをfloat *型であるかのように扱うように指示しています。単純に2番目のcoutの結果が0になると予想する場合がありますが、-O2を使用して最適化を有効にすると、gccとclangの両方が次の結果を生成します。
0
1
これは予想されないかもしれませんが、未定義の動作を呼び出したので完全に有効です。フロートは有効にエイリアスできないint型のオブジェクト。したがって、オプティマイザは、iを逆参照するときに格納された定数1を戻り値と見なすことができます。これは、fを介した格納がintオブジェクトに有効に影響しなかったためです。コンパイラエクスプローラーでコードをプラグインすると、これがまさに何が起こっているかを示しています（実例）：
foo(float*, int*): # @foo(float*, int*)
mov dword ptr [rsi], 1
mov dword ptr [rdi], 0
mov eax, 1
ret
Type-Based Alias Analysis（TBAA）を使用するオプティマイザは、1が返されると想定し、定数値をレジスタeaxに直接移動します。このレジスタは、戻り値を保持します。TBAAは、ロードとストアを最適化するために、どのタイプにエイリアスを許可するかに関する言語規則を使用します。この場合、TBAAは、floatがエイリアスおよびintできないことを認識し、iの負荷を最適化します。
今、ルールブックへ
私たちが許可されていることと許可されていないことを規格は正確に何と言っていますか？標準言語は単純ではないので、各項目について、意味を示すコード例を提供しようと思います。
C11標準は何と言っていますか？
C11の標準は、セクションに次のように述べている6.5式パラグラフ7：
オブジェクトは、次のタイプのいずれかを持つ左辺値式によってのみアクセスされる格納された値を持つものとします。88）
—オブジェクトの有効なタイプと互換性のあるタイプ。
int x = 1;
int *p = &x;
printf("%d\n", *p); // *p gives us an lvalue expression of type int which is compatible with int
—オブジェクトの有効なタイプと互換性のあるタイプの修飾バージョン、
int x = 1;
const int *p = &x;
printf("%d\n", *p); // *p gives us an lvalue expression of type const int which is compatible with int
—オブジェクトの有効なタイプに対応する符号付きまたは符号なしタイプのタイプ
int x = 1;
unsigned int *p = (unsigned int*)&x;
printf("%u\n", *p ); // *p gives us an lvalue expression of type unsigned int which corresponds to
// the effective type of the object
GCC /打ち鳴らすには、拡張子があるとも割り当てることができますunsigned int型を*に* int型を、彼らは互換性のある型でなくても。
—オブジェクトの有効な型の修飾バージョンに対応する署名付きまたは署名なしの型である型
int x = 1;
const unsigned int *p = (const unsigned int*)&x;
printf("%u\n", *p ); // *p gives us an lvalue expression of type const unsigned int which is a unsigned type
// that corresponds with to a qualified verison of the effective type of the object
—メンバーの中に前述のタイプの1つを含む集約またはユニオンタイプ（再帰的に、サブアグリゲートまたは含まれるユニオンのメンバーを含む）、または
struct foo {
int x;
};
void foobar( struct foo *fp, int *ip ); // struct foo is an aggregate that includes int among its members so it can
// can alias with *ip
foo f;
foobar( &f, &f.x );
—文字タイプ。
int x = 65;
char *p = (char *)&x;
printf("%c\n", *p ); // *p gives us an lvalue expression of type char which is a character type.
// The results are not portable due to endianness issues.
C ++ 17 Draft Standardの発言
セクション[basic.lval]パラグラフ11のC ++ 17ドラフト標準は次のように述べています。
：次のタイプの他の数の挙動が未定義であるのglvalueを通じてオブジェクトの格納された値にアクセスするためのプログラムしようとした場合63
-オブジェクトの動的な型、（11.1）
void *p = malloc( sizeof(int) ); // We have allocated storage but not started the lifetime of an object
int *ip = new (p) int{0}; // Placement new changes the dynamic type of the object to int
std::cout << *ip << "\n"; // *ip gives us a glvalue expression of type int which matches the dynamic type
// of the allocated object
（11.2）—オブジェクトの動的タイプのcv修飾バージョン、
int x = 1;
const int *cip = &x;
std::cout << *cip << "\n"; // *cip gives us a glvalue expression of type const int which is a cv-qualified
// version of the dynamic type of x
（11.3）—オブジェクトの動的タイプに類似したタイプ（7.5で定義）
（11.4）—オブジェクトの動的タイプに対応する符号付きまたは符号なしタイプのタイプ
// Both si and ui are signed or unsigned types corresponding to each others dynamic types
// We can see from this godbolt(https://godbolt.org/g/KowGXB) the optimizer assumes aliasing.
signed int foo( signed int &si, unsigned int &ui ) {
si = 1;
ui = 2;
return si;
}
（11.5）—オブジェクトの動的タイプのcv修飾バージョンに対応する署名付きまたは署名なしのタイプであるタイプ
signed int foo( const signed int &si1, int &si2); // Hard to show this one assumes aliasing
（11.6）—要素または非静的データメンバー（再帰的に、サブアグリゲートまたは含まれるユニオンの要素または非静的データメンバーを含む）の中に前述のタイプの1つを含む集約またはユニオンタイプ、
struct foo {
int x;
};
// Compiler Explorer example(https://godbolt.org/g/z2wJTC) shows aliasing assumption
int foobar( foo &fp, int &ip ) {
fp.x = 1;
ip = 2;
return fp.x;
}
foo f;
foobar( f, f.x );
（11.7）—オブジェクトの動的タイプの（おそらくcv修飾された）基本クラスタイプであるタイプ
struct foo { int x ; };
struct bar : public foo {};
int foobar( foo &f, bar &b ) {
f.x = 1;
b.x = 2;
return f.x;
}
（11.8）— char、unsigned char、またはstd :: byteタイプ。
int foo( std::byte &b, uint32_t &ui ) {
b = static_cast<std::byte>('a');
ui = 0xFFFFFFFF;
return std::to_integer<int>( b ); // b gives us a glvalue expression of type std::byte which can alias
// an object of type uint32_t
}
上記のリストには、signed charに注意する価値はありません。これは、文字タイプを表すCとの大きな違いです。
タイププニングとは
ここまで来て、疑問に思うかもしれませんが、なぜ別名を付けたいのでしょうか？答えは通常、punと入力することです。多くの場合、使用されるメソッドは厳密なエイリアス規則に違反しています。
型システムを回避して、オブジェクトを別の型として解釈したい場合があります。これはタイプパニングと呼ばれ、メモリのセグメントを別のタイプとして再解釈します。タイプパニングは、オブジェクトの基になる表現にアクセスして、表示、転送、または操作する必要があるタスクに役立ちます。タイプパニングが使用されているのがわかる典型的な領域は、コンパイラ、シリアル化、ネットワークコードなどです。
伝統的に、これはオブジェクトのアドレスを取得し、それを再解釈したい型のポインターにキャストしてから値にアクセスすることによって、つまり別名を付けることによって実現されていました。例えば：
int x = 1 ;
// In C
float *fp = (float*)&x ; // Not a valid aliasing
// In C++
float *fp = reinterpret_cast<float*>(&x) ; // Not a valid aliasing
printf( "%f\n", *fp ) ;
これまで見てきたように、これは有効なエイリアスではないため、未定義の動作を呼び出しています。しかし、伝統的にコンパイラーは厳密なエイリアシング規則を利用せず、このタイプのコードは通常は機能するだけでしたが、開発者は残念ながらこの方法で慣れてきました。タイプパニングの一般的な代替方法は、Cで有効であるが、C ++では未定義の動作である共用体を使用する方法です（実際の例を参照）。
union u1
{
int n;
float f;
} ;
union u1 u;
u.f = 1.0f;
printf( "%d\n”, u.n ); // UB in C++ n is not the active member
これはC ++では無効であり、一部のユーザーは、共用体の目的はバリアント型を実装するためだけであると考えており、型のパンニングに共用体を使用することは不正行為だと感じています。
Punを正しく入力するにはどうすればよいですか？
CとC ++の両方で型パンニングを行うための標準的な方法はmemcpyです。これは少し重いように見えるかもしれませんが、オプティマイザは型パンニングのためのmemcpyの使用を認識し、それを最適化して、レジスタの移動を生成する必要があります。たとえば、int64_tがdoubleと同じサイズであることがわかっている場合：
static_assert( sizeof( double ) == sizeof( int64_t ) ); // C++17 does not require a message
memcpyを使用できます。
void func1( double d ) {
std::int64_t n;
std::memcpy(&n, &d, sizeof d);
//...
十分な最適化レベルでは、適切な最新のコンパイラは、前述のreinterpret_castメソッドまたは型パンニングのunionメソッドと同じコードを生成します。生成されたコードを調べると、register mov（ライブコンパイラエクスプローラーの例）のみを使用していることがわかります。
C ++ 20とbit_cast
C ++ 20では、bit_cast（提案からのリンクで利用可能な実装）を得ることができます。これは、タイプパンするためのシンプルで安全な方法を提供するだけでなく、constexprコンテキストで使用可能です。
以下は、bit_castを使用して、unsigned intをfloatに入力する方法の例です（実際に表示されます）。
std::cout << bit_cast<float>(0x447a0000) << "\n" ; //assuming sizeof(float) == sizeof(unsigned int)
場合へとより型が同じサイズを持っていない、それは中間struct15を使用するために私たちを必要とします。我々は含む構造体に使用するのsizeof（unsigned int型）文字配列を（想定している4バイトの符号なし整数をする）から、タイプとunsigned int型としては、するにはタイプ：
struct uint_chars {
unsigned char arr[sizeof( unsigned int )] = {} ; // Assume sizeof( unsigned int ) == 4
};
// Assume len is a multiple of 4
int bar( unsigned char *p, size_t len ) {
int result = 0;
for( size_t index = 0; index < len; index += sizeof(unsigned int) ) {
uint_chars f;
std::memcpy( f.arr, &p[index], sizeof(unsigned int));
unsigned int result = bit_cast<unsigned int>(f);
result += foo( result );
}
return result ;
}
この中間型が必要なのは残念ですが、それが現在のbit_castの制約です。
厳格なエイリアシング違反の検出
C ++で厳密なエイリアシングをキャッチするための優れたツールは多くありません。厳密なエイリアシング違反のいくつかのケースや、整列されていないロードとストアのいくつかのケースをキャッチするツールがあります。
フラグ-fstrict -aliasingと-Wstrict-aliasingを使用するgccは、誤検知 /誤検知がないわけではありませんが、いくつかのケースをキャッチできます。たとえば、次の場合はgccで警告が生成されます（ライブで確認してください）。
int a = 1;
short j;
float f = 1.f; // Originally not initialized but tis-kernel caught
// it was being accessed w/ an indeterminate value below
printf("%i\n", j = *(reinterpret_cast<short*>(&a)));
printf("%i\n", j = *(reinterpret_cast<int*>(&f)));
この追加のケースをキャッチしません（ライブでご覧ください）：
int *p;
p=&a;
printf("%i\n", j = *(reinterpret_cast<short*>(p)));
clangはこれらのフラグを許可しますが、実際には警告を実装していないようです。
私たちが利用できるもう1つのツールはASanで、これは整列されていないロードとストアをキャッチできます。これらは直接の厳密なエイリアシング違反ではありませんが、厳密なエイリアシング違反の一般的な結果です。たとえば、次の場合、-fsanitize = addressを使用してclangでビルドするとランタイムエラーが発生します
int *x = new int[2]; // 8 bytes: [0,7].
int *u = (int*)((char*)x + 6); // regardless of alignment of x this will not be an aligned address
*u = 1; // Access to range [6-9]
printf( "%d\n", *u ); // Access to range [6-9]
私がお勧めする最後のツールはC ++固有のものであり、厳密にはツールではありませんが、コーディングの実践であり、Cスタイルのキャストは許可されていません。gccとclangはどちらも、-Wold-style-castを使用してCスタイルのキャストの診断を生成します。これにより、未定義の型パンがreinterpret_castを使用するように強制されます。一般に、reinterpret_castは、より詳細なコードレビューのためのフラグである必要があります。また、コードベースでreinterpret_castを検索して監査を実行する方が簡単です。
Cの場合は、すべてのツールがすでにカバーされています。また、C言語の大部分のプログラムを徹底的に分析する静的アナライザーであるtis-interpreterもあります。-fstrict -aliasingを使用すると1つのケースが見落とされる、前の例のCバージョンが指定されている場合（ライブで表示）
int a = 1;
short j;
float f = 1.0 ;
printf("%i\n", j = *((short*)&a));
printf("%i\n", j = *((int*)&f));
int *p;
p=&a;
printf("%i\n", j = *((short*)p));
tis-interpeterは3つすべてをキャッチできます。次の例では、tis-kernalをtis-interpreterとして呼び出します（出力は簡潔にするために編集されています）。
./bin/tis-kernel -sa example1.c
...
example1.c:9:[sa] warning: The pointer (short *)(& a) has type short *. It violates strict aliasing
rules by accessing a cell with effective type int.
...
example1.c:10:[sa] warning: The pointer (int *)(& f) has type int *. It violates strict aliasing rules by
accessing a cell with effective type float.
Callstack: main
...
example1.c:15:[sa] warning: The pointer (short *)p has type short *. It violates strict aliasing rules by
accessing a cell with effective type int.
最後に、現在開発中のTySanがあります。このサニタイザーは、シャドウメモリセグメントに型チェック情報を追加し、アクセスをチェックして、エイリアスルールに違反していないかどうかを確認します。このツールは、すべてのエイリアス違反をキャッチできる可能性がありますが、実行時のオーバーヘッドが大きくなる可能性があります。
cていc++faqます。