บันทึก
นี่เป็นข้อความที่ตัดตอนมาจาก"กฎนามแฝงที่เข้มงวดของฉันคืออะไรและทำไมเราจึงสนใจ" เขียน.
นามแฝงที่เข้มงวดคืออะไร
ในการสร้างสมนาม C และ C ++ นั้นเกี่ยวข้องกับประเภทนิพจน์ที่เราได้รับอนุญาตให้เข้าถึงค่าที่เก็บไว้ผ่าน ในทั้ง C และ C ++ มาตรฐานจะระบุประเภทการแสดงออกที่อนุญาตให้นามแฝงประเภทใด คอมไพเลอร์และเพิ่มประสิทธิภาพได้รับอนุญาตให้ถือว่าเราปฏิบัติตามกฎอย่างเคร่งครัด aliasing จึงระยะกฎ aliasing เข้มงวด หากเราพยายามเข้าถึงค่าโดยใช้ประเภทที่ไม่ได้รับอนุญาตจะถูกจัดประเภทเป็นพฤติกรรมที่ไม่ได้กำหนด ( UB ) เมื่อเรามีพฤติกรรมที่ไม่ได้กำหนดการเดิมพันทั้งหมดจะปิดลงผลลัพธ์ของโปรแกรมของเราจะไม่น่าเชื่อถืออีกต่อไป
น่าเสียดายที่มีการละเมิดนามแฝงที่เข้มงวดเรามักจะได้รับผลลัพธ์ตามที่เราคาดหวังไว้ซึ่งความเป็นไปได้ที่คอมไพเลอร์เวอร์ชันอนาคตที่มีการเพิ่มประสิทธิภาพใหม่จะทำลายรหัสที่เราคิดว่าถูกต้อง นี่เป็นสิ่งที่ไม่พึงปรารถนาและเป็นเป้าหมายที่คุ้มค่าที่จะเข้าใจกฎนามแฝงที่เข้มงวดและวิธีหลีกเลี่ยงการละเมิดกฎเหล่านั้น
เพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับสาเหตุที่เราสนใจเราจะหารือเกี่ยวกับปัญหาที่เกิดขึ้นเมื่อละเมิดกฎนามแฝงที่เข้มงวดพิมพ์ punning เนื่องจากเทคนิคทั่วไปที่ใช้ในประเภท punning มักจะละเมิดกฎนามแฝงที่เข้มงวดและวิธีพิมพ์ pun อย่างถูกต้อง
ตัวอย่างเบื้องต้น
ลองดูตัวอย่างจากนั้นเราสามารถพูดถึงสิ่งที่มาตรฐานพูดตรวจสอบตัวอย่างเพิ่มเติมแล้วดูวิธีหลีกเลี่ยงการใช้นามแฝงที่เข้มงวดและตรวจจับการละเมิดที่เราพลาดไป นี่คือตัวอย่างที่ไม่ควรแปลกใจ ( ตัวอย่างสด ):
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 *และลอย *ในตัวอย่างนี้เราเรียกfooและตั้งค่าพารามิเตอร์ทั้งชี้ไปที่สถานที่ตั้งหน่วยความจำเดียวกันซึ่งในตัวอย่างนี้มีint หมายเหตุreinterpret_castกำลังบอกคอมไพเลอร์ให้ดำเนินการกับนิพจน์ราวกับว่ามีชนิดที่ระบุโดยพารามิเตอร์เทมเพลต ในกรณีนี้เราจะบอกว่ามันจะรักษาการแสดงออกและ xราวกับว่ามันมีชนิดลอย * เราอย่างไร้เดียงสาอาจคาดหวังผลมาจากการที่สองศาลจะเป็น0แต่เปิดใช้งานด้วยการเพิ่มประสิทธิภาพการใช้-O2ทั้ง GCC และเสียงดังกราวผลิตผลต่อไปนี้:
0
1
ซึ่งอาจไม่ได้รับการคาดหวัง แต่ใช้ได้อย่างสมบูรณ์เนื่องจากเราได้เรียกใช้พฤติกรรมที่ไม่ได้กำหนด การลอยไม่สามารถถูกต้องนามแฝงวัตถุint ดังนั้นออพติไมเซอร์สามารถสมมติค่าคงที่ 1 ที่เก็บไว้เมื่อ dereferencing iจะเป็นค่าส่งคืนเนื่องจากการจัดเก็บผ่านfไม่สามารถส่งผลกระทบต่อวัตถุintได้อย่างถูกต้อง การเสียบรหัสในคอมไพเลอร์ Explorer จะแสดงให้เห็นว่านี่เป็นสิ่งที่เกิดขึ้นจริง ( ตัวอย่างสด ):
foo(float*, int*): # @foo(float*, int*)
mov dword ptr [rsi], 1
mov dword ptr [rdi], 0
mov eax, 1
ret
เครื่องมือเพิ่มประสิทธิภาพที่ใช้การวิเคราะห์นามแฝงตามประเภท (TBAA)ถือว่า1จะถูกส่งคืนและย้ายค่าคงที่ไปยัง register eaxโดยตรงซึ่งมีค่าส่งคืนโดยตรง TBAA ใช้กฎภาษาเกี่ยวกับประเภทที่ได้รับอนุญาตให้นามแฝงเพื่อเพิ่มประสิทธิภาพการโหลดและร้านค้า ในกรณีนี้ TBAA รู้ว่าการลอยไม่สามารถใช้นามแฝงและintและปรับการโหลดของi ให้เหมาะสม
ตอนนี้เพื่อ Rule-Book
มาตรฐานบอกอะไรเราว่าได้รับอนุญาตและไม่ได้รับอนุญาตให้ทำ? ภาษามาตรฐานไม่ตรงไปตรงมาดังนั้นสำหรับแต่ละรายการฉันจะพยายามให้ตัวอย่างรหัสที่แสดงให้เห็นถึงความหมาย
มาตรฐาน C11 พูดว่าอะไร?
C11มาตรฐานกล่าวว่าต่อไปนี้ในส่วน6.5 นิพจน์วรรค 7 :
วัตถุต้องมีค่าที่เก็บไว้เข้าถึงได้โดยนิพจน์ lvalue ที่มีประเภทใดประเภทหนึ่งต่อไปนี้: 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 / clang มีส่วนขยายและยังอนุญาตให้กำหนด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
- ประเภทรวมหรือสหภาพที่รวมประเภทหนึ่งดังกล่าวไว้ในหมู่สมาชิก (รวมถึงเรียกซ้ำสมาชิกของกลุ่มย่อยหรือสหภาพที่มีอยู่) หรือ
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 พูด
มาตรฐานฉบับร่าง C ++ 17 ในส่วน[basic.lval] วรรค 11พูดว่า:
หากโปรแกรมพยายามเข้าถึงค่าที่เก็บไว้ของวัตถุผ่าน 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) - ชนิดรวมหรือยูเนี่ยนที่มีหนึ่งในประเภทดังกล่าวในหมู่องค์ประกอบหรือสมาชิกข้อมูลที่ไม่อยู่นิ่ง (รวมถึงแบบเรียกซ้ำองค์ประกอบหรือสมาชิกข้อมูลที่ไม่คงที่ของสหภาพย่อยหรือมีสหภาพ)
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) - ประเภทถ่าน, ถ่านที่ไม่ได้ลงชื่อหรือ 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
}
มูลค่า noting ลงนามถ่านไม่รวมอยู่ในรายการข้างต้นนี้เป็นความแตกต่างที่โดดเด่นจากCซึ่งบอกว่าเป็นชนิดตัวอักษร
Type Punning คืออะไร
เราได้มาถึงจุดนี้และเราอาจสงสัยว่าทำไมเราต้องการนามแฝง? คำตอบคือพิมพ์คำพิพากษาบ่อยครั้งวิธีที่ใช้ละเมิดกฎนามแฝงที่เข้มงวด
บางครั้งเราต้องการหลีกเลี่ยงระบบชนิดและตีความวัตถุเป็นชนิดอื่น สิ่งนี้เรียกว่าประเภท punningเพื่อตีความเซ็กเมนต์ของหน่วยความจำเป็นประเภทอื่น ประเภท punningมีประโยชน์สำหรับงานที่ต้องการเข้าถึงการเป็นตัวแทนของวัตถุเพื่อดูการขนส่งหรือจัดการ พื้นที่ทั่วไปที่เราพบว่ามีการใช้งานการสะกดคำแบบพิมพ์คือคอมไพเลอร์การทำให้เป็นอนุกรมรหัสเครือข่าย ฯลฯ ...
ตามเนื้อผ้าสิ่งนี้สามารถทำได้โดยการนำที่อยู่ของวัตถุชี้ไปที่ตัวชี้ประเภทที่เราต้องการตีความอีกครั้งเป็นแล้วการเข้าถึงค่าหรือในคำอื่น ๆ โดยนามแฝง ตัวอย่างเช่น:
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 ++ และบางคนพิจารณาจุดประสงค์ของสหภาพว่าจะใช้สำหรับการใช้งานประเภทตัวแปรและรู้สึกว่าใช้สหภาพสำหรับประเภท punning เป็นการละเมิด
เราจะพิมพ์ Pun อย่างไรให้ถูกต้อง
วิธีการมาตรฐานสำหรับประเภทเล่นสำนวนทั้ง C และ C ++ เป็นmemcpy สิ่งนี้อาจดูถนัดมือเล็กน้อย แต่เครื่องมือเพิ่มประสิทธิภาพควรจดจำการใช้memcpyสำหรับประเภท punningและปรับให้เหมาะสมและสร้างการลงทะเบียนเพื่อย้ายการลงทะเบียน ตัวอย่างเช่นถ้าเรารู้ว่า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วิธีการหรือสหภาพวิธีการสำหรับประเภทเล่นสำนวน ตรวจสอบโค้ดที่สร้างขึ้นที่เราเห็นว่าใช้เพียงลงทะเบียน mov ( ตัวอย่าง Live Compiler Explorer )
C ++ 20 และ bit_cast
ใน C ++ 20 เราอาจได้รับbit_cast ( การนำไปใช้ในลิงก์จากข้อเสนอ ) ซึ่งเป็นวิธีที่ง่ายและปลอดภัยในการพิมพ์-Pun รวมถึงการใช้งานในบริบทของกลุ่ม
ต่อไปนี้เป็นตัวอย่างของวิธีการใช้bit_castเพื่อพิมพ์ pun int ที่ไม่ได้ลงนามเพื่อลอย ( ดูสด ):
std::cout << bit_cast<float>(0x447a0000) << "\n" ; //assuming sizeof(float) == sizeof(unsigned int)
ในกรณีที่ประเภทถึงและจากไม่มีขนาดเดียวกันเราต้องใช้โครงสร้างระดับกลาง 15 เราจะใช้ struct ที่มีอาร์เรย์อักขระsizeof (unsigned int) ( ถือว่า 4 ไบต์ที่ไม่ได้ลงนาม int ) เป็นประเภทFromและint ที่ไม่ได้ลงนามเป็นประเภทTo :
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 ++ เครื่องมือที่เรามีจะจับบางกรณีของการละเมิดนามแฝงที่เข้มงวดและบางกรณีของการโหลดและร้านค้าที่ไม่ตรงแนว
gcc โดยใช้แฟล็ก -fstrict-aliasingและ-Wstrict-aliasingสามารถตรวจพบบางกรณีแม้ว่าจะไม่ได้ผลบวก / เชิงลบ ตัวอย่างเช่นกรณีต่อไปนี้จะสร้างคำเตือนเป็น 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)));
แม้ว่าเสียงดังกราวด์อนุญาตให้ใช้ธงเหล่านี้ แต่ดูเหมือนว่าไม่ได้ใช้คำเตือนจริง ๆ
เครื่องมืออีกอย่างที่เรามีให้สำหรับเราคือ ASan ซึ่งสามารถรับโหลดที่ไม่ตรงแนวและเก็บได้ แม้ว่าสิ่งเหล่านี้ไม่ใช่การละเมิดนามแฝงที่เข้มงวดโดยตรง แต่เป็นผลทั่วไปของการละเมิดนามแฝงที่เข้มงวด ตัวอย่างเช่นกรณีต่อไปนี้จะสร้างข้อผิดพลาดรันไทม์เมื่อสร้างด้วย clang โดยใช้-fsanitize = address
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 และเสียงดังกราวจะผลิตการวินิจฉัยสำหรับบรรยากาศแบบ C ใช้-Wold สไตล์หล่อ สิ่งนี้จะบังคับให้การพิมพ์ที่ไม่ได้กำหนดใด ๆ เพื่อใช้ reinterpret_cast โดยทั่วไป reinterpret_cast ควรเป็นค่าสถานะสำหรับการตรวจสอบโค้ดที่ใกล้ชิดยิ่งขึ้น นอกจากนี้ยังง่ายต่อการค้นหาฐานรหัสของคุณสำหรับ reinterpret_cast เพื่อทำการตรวจสอบ
สำหรับ C เรามีเครื่องมือทั้งหมดครอบคลุมอยู่แล้วและเรายังมี tis-interpreter ตัววิเคราะห์แบบคงที่ที่วิเคราะห์โปรแกรมสำหรับชุดย่อยขนาดใหญ่ของภาษา C รับ verion C ของตัวอย่างก่อนหน้านี้ที่ใช้-fstrict-aliasingคิดถึงหนึ่งกรณี ( ดูแบบสด )
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 สามารถจับทั้งสามตัวอย่างต่อไปนี้เรียก 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ซึ่งขณะนี้อยู่ในการพัฒนา น้ำยาฆ่าเชื้อนี้เพิ่มข้อมูลการตรวจสอบประเภทในเซ็กเมนต์หน่วยความจำเงาและตรวจสอบการเข้าถึงเพื่อดูว่าพวกเขาละเมิดกฎนามแฝงหรือไม่ เครื่องมือนี้ควรจะสามารถตรวจจับการละเมิดนามแฝงทั้งหมด แต่อาจมีค่าใช้จ่ายในการดำเนินการจำนวนมาก
cc++faq