Ghi chú
Điều này được trích từ "Quy tắc bí danh nghiêm ngặt của tôi là gì và tại sao chúng ta quan tâm?" hãy viết ra giấy.
Bí danh nghiêm ngặt là gì?
Trong bí danh C và C ++ có liên quan đến loại biểu thức nào chúng ta được phép truy cập các giá trị được lưu trữ thông qua. Trong cả C và C ++, tiêu chuẩn chỉ định loại biểu thức nào được phép đặt bí danh cho loại nào. Trình biên dịch và trình tối ưu hóa được phép giả định rằng chúng tôi tuân thủ nghiêm ngặt các quy tắc răng cưa, do đó thuật ngữ quy tắc răng cưa nghiêm ngặt . Nếu chúng tôi cố gắng truy cập một giá trị bằng cách sử dụng một loại không được phép, nó được phân loại là hành vi không xác định ( UB ). Khi chúng tôi có hành vi không xác định, tất cả các cược đã tắt, kết quả của chương trình của chúng tôi không còn đáng tin cậy nữa.
Thật không may với các vi phạm bí danh nghiêm ngặt, chúng tôi sẽ thường nhận được kết quả mà chúng tôi mong đợi, để lại khả năng phiên bản tương lai của trình biên dịch với tối ưu hóa mới sẽ phá vỡ mã mà chúng tôi cho là hợp lệ. Điều này là không mong muốn và nó là một mục tiêu đáng giá để hiểu các quy tắc bí danh nghiêm ngặt và làm thế nào để tránh vi phạm chúng.
Để hiểu thêm về lý do tại sao chúng tôi quan tâm, chúng tôi sẽ thảo luận về các vấn đề phát sinh khi vi phạm các quy tắc răng cưa nghiêm ngặt, loại xảo quyệt vì các kỹ thuật phổ biến được sử dụng trong loại picky thường vi phạm các quy tắc bí danh nghiêm ngặt và cách gõ chữ đúng.
Ví dụ sơ bộ
Chúng ta hãy xem xét một số ví dụ, sau đó chúng ta có thể nói về chính xác những gì các tiêu chuẩn nói, kiểm tra một số ví dụ khác và sau đó xem làm thế nào để tránh bí danh nghiêm ngặt và bắt vi phạm mà chúng ta đã bỏ lỡ. Đây là một ví dụ không đáng ngạc nhiên ( ví dụ trực tiếp ):
int x = 10;
int *ip = &x;
std::cout << *ip << "\n";
*ip = 12;
std::cout << x << "\n";
Chúng ta có một int * trỏ đến bộ nhớ bị chiếm bởi một int và đây là một bí danh hợp lệ. Trình tối ưu hóa phải cho rằng các bài tập thông qua ip có thể cập nhật giá trị chiếm dụng bởi x .
Ví dụ tiếp theo cho thấy răng cưa dẫn đến hành vi không xác định ( ví dụ trực tiếp ):
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?
}
Trong hàm foo, chúng ta lấy một int * và float * , trong ví dụ này, chúng ta gọi foo và đặt cả hai tham số để trỏ đến cùng một vị trí bộ nhớ mà trong ví dụ này chứa một int . Lưu ý, reinterpret_cast đang báo cho trình biên dịch xử lý biểu thức như thể nó có kiểu được chỉ định bởi tham số mẫu của nó. Trong trường hợp này, chúng tôi đang bảo nó xử lý biểu thức & x như thể nó có kiểu float * . Chúng tôi có thể ngây thơ mong đợi kết quả của cout thứ hai là 0 nhưng với tối ưu hóa được kích hoạt bằng cách sử dụng -O2 cả gcc và clang tạo ra kết quả như sau:
0
1
Điều này có thể không được mong đợi nhưng hoàn toàn hợp lệ vì chúng tôi đã gọi hành vi không xác định. Một float không thể hợp lệ bí danh một đối tượng int . Do đó, trình tối ưu hóa có thể giả sử hằng số 1 được lưu trữ khi hội thảo i sẽ là giá trị trả về do một cửa hàng qua f không thể ảnh hưởng hợp lệ đến một đối tượng int . Việc cắm mã trong Compiler Explorer cho thấy đây chính xác là những gì đang xảy ra ( ví dụ trực tiếp ):
foo(float*, int*): # @foo(float*, int*)
mov dword ptr [rsi], 1
mov dword ptr [rdi], 0
mov eax, 1
ret
Trình tối ưu hóa sử dụng Phân tích bí danh dựa trên loại (TBAA) giả định 1 sẽ được trả về và trực tiếp di chuyển giá trị không đổi vào thanh ghi eax mang giá trị trả về. TBAA sử dụng các quy tắc ngôn ngữ về loại nào được phép đặt bí danh để tối ưu hóa tải và lưu trữ. Trong trường hợp này, TBAA biết rằng một float không thể bí danh và int và tối ưu hóa tải của i .
Bây giờ, đến Quy tắc
Chính xác thì tiêu chuẩn nói chúng ta được phép và không được phép làm gì? Ngôn ngữ tiêu chuẩn không đơn giản, vì vậy đối với mỗi mục tôi sẽ cố gắng cung cấp các ví dụ mã thể hiện ý nghĩa.
Tiêu chuẩn C11 nói lên điều gì?
Các C11 tiêu chuẩn nói sau đây trong phần 6,5 Expressions đoạn 7 :
Một đối tượng sẽ có giá trị được lưu trữ chỉ được truy cập bằng biểu thức lvalue có một trong các loại sau: 88)
- một loại tương thích với loại hiệu quả của đối tượng,
int x = 1;
int *p = &x;
printf("%d\n", *p); // *p gives us an lvalue expression of type int which is compatible with int
- phiên bản đủ điều kiện của loại tương thích với loại đối tượng hiệu quả,
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
- một loại là loại đã ký hoặc không dấu tương ứng với loại hiệu quả của đối tượng,
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 có một phần mở rộng và cũng cho phép gán int * không dấu cho int * mặc dù chúng không phải là loại tương thích.
- một loại là loại đã ký hoặc không dấu tương ứng với một phiên bản đủ điều kiện của loại đối tượng hiệu quả,
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
- một loại tổng hợp hoặc liên minh bao gồm một trong các loại đã nói ở trên trong số các thành viên của nó (bao gồm, đệ quy, một thành viên của một tập hợp phụ hoặc có liên kết), hoặc
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 );
- một kiểu nhân vật.
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.
Tiêu chuẩn Dự thảo C ++ 17 nói gì
Tiêu chuẩn dự thảo C ++ 17 trong phần [basic.lval] đoạn 11 nói:
Nếu một chương trình cố gắng truy cập giá trị được lưu trữ của một đối tượng thông qua một giá trị khác với một trong các loại sau đây thì hành vi không được xác định: 63
(11.1) - loại động của đối tượng,
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) - phiên bản đủ điều kiện cv của loại động của đối tượng,
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) - một loại tương tự (như được định nghĩa trong 7.5) với loại động của đối tượng,
(11.4) - một loại là loại đã ký hoặc không dấu tương ứng với loại động của đối tượng,
// 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) - một loại là loại đã ký hoặc không dấu tương ứng với phiên bản đủ điều kiện cv của loại động của đối tượng,
signed int foo( const signed int &si1, int &si2); // Hard to show this one assumes aliasing
(11.6) - một loại tổng hợp hoặc kết hợp bao gồm một trong các loại đã nói ở trên trong số các thành phần hoặc thành viên dữ liệu không phải là dữ liệu (bao gồm, đệ quy, một thành phần hoặc thành viên dữ liệu không tĩnh của liên kết gộp hoặc chứa)
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) - một loại là loại lớp cơ sở (có thể đủ điều kiện cv) của loại động của đối tượng,
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) - một kiểu char, unsign char hoặc 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
}
Đáng chú ý char đã ký không được bao gồm trong danh sách trên, đây là một sự khác biệt đáng chú ý từ C mà nói một loại ký tự .
Kiểu trừng phạt là gì
Chúng tôi đã đi đến điểm này và chúng tôi có thể tự hỏi, tại sao chúng tôi muốn bí danh cho? Câu trả lời thường là gõ chữ , thường các phương thức được sử dụng vi phạm các quy tắc răng cưa nghiêm ngặt.
Đôi khi chúng tôi muốn phá vỡ hệ thống loại và giải thích một đối tượng là một loại khác. Điều này được gọi là loại pucky , để diễn giải lại một đoạn bộ nhớ như một loại khác. Kiểu pucky rất hữu ích cho các tác vụ muốn truy cập vào biểu diễn cơ bản của một đối tượng để xem, vận chuyển hoặc thao tác. Các lĩnh vực điển hình mà chúng tôi thấy loại pucky đang được sử dụng là trình biên dịch, tuần tự hóa, mã mạng, v.v.
Theo truyền thống, điều này đã được thực hiện bằng cách lấy địa chỉ của đối tượng, chuyển nó thành một con trỏ của loại mà chúng ta muốn diễn giải lại nó và sau đó truy cập giá trị, hay nói cách khác bằng cách đặt bí danh. Ví dụ:
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 ) ;
Như chúng ta đã thấy trước đây, đây không phải là một bí danh hợp lệ, vì vậy chúng ta đang gọi hành vi không xác định. Nhưng các trình biên dịch truyền thống đã không tận dụng các quy tắc bí danh nghiêm ngặt và loại mã này thường chỉ hoạt động, các nhà phát triển đã không may làm quen với việc làm theo cách này. Một phương pháp thay thế phổ biến cho loại picky là thông qua các hiệp hội, có giá trị trong C nhưng hành vi không xác định trong C ++ ( xem ví dụ trực tiếp ):
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
Điều này không hợp lệ trong C ++ và một số người coi mục đích của các công đoàn chỉ là để thực hiện các loại biến thể và cảm thấy việc sử dụng các công đoàn cho loại picky là một sự lạm dụng.
Làm thế nào để chúng ta gõ Pun chính xác?
Phương pháp tiêu chuẩn để loại pucky trong cả C và C ++ là memcpy . Điều này có vẻ hơi nặng tay nhưng trình tối ưu hóa sẽ nhận ra việc sử dụng memcpy để loại pucky và tối ưu hóa nó đi và tạo ra một đăng ký để đăng ký di chuyển. Ví dụ: nếu chúng ta biết int64_t có cùng kích thước với double :
static_assert( sizeof( double ) == sizeof( int64_t ) ); // C++17 does not require a message
chúng ta có thể sử dụng memcpy :
void func1( double d ) {
std::int64_t n;
std::memcpy(&n, &d, sizeof d);
//...
Ở mức tối ưu hóa đủ, bất kỳ trình biên dịch hiện đại phong nha nào cũng tạo ra mã giống hệt với phương thức reinterpret_cast hoặc phương thức hợp nhất đã đề cập trước đó để loại picky . Kiểm tra mã được tạo, chúng tôi thấy nó chỉ sử dụng đăng ký Mov ( Ví dụ trình biên dịch trình biên dịch trực tiếp ).
C ++ 20 và bit_cast
Trong C ++ 20, chúng tôi có thể nhận được bit_cast ( triển khai có sẵn trong liên kết từ đề xuất ), điều này mang lại một cách đơn giản và an toàn để chơi chữ cũng như có thể sử dụng được trong ngữ cảnh constexpr.
Sau đây là một ví dụ về cách sử dụng bit_cast để gõ chữ int unsced để nổi , ( xem trực tiếp ):
std::cout << bit_cast<float>(0x447a0000) << "\n" ; //assuming sizeof(float) == sizeof(unsigned int)
Trong trường hợp các loại To và From không có cùng kích thước, nó yêu cầu chúng ta sử dụng một cấu trúc trung gian15. Chúng ta sẽ sử dụng một cấu trúc chứa một mảng ký tự sizeof (unsign int) ( giả sử 4 byte unsign int ) là kiểu From và unsign int như kiểu 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 ;
}
Thật không may là chúng ta cần loại trung gian này nhưng đó là ràng buộc hiện tại của bit_cast .
Bắt vi phạm bí danh nghiêm ngặt
Chúng tôi không có nhiều công cụ tốt để bắt răng cưa nghiêm ngặt trong C ++, các công cụ chúng tôi có sẽ bắt được một số trường hợp vi phạm bí danh nghiêm ngặt và một số trường hợp tải và lưu trữ sai.
gcc sử dụng hàm răng cưa -fstrict-aliasing và -Wstrict-aliasing có thể bắt được một số trường hợp mặc dù không phải không có dương / âm sai. Ví dụ: các trường hợp sau sẽ tạo cảnh báo trong gcc ( xem trực tiếp ):
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)));
mặc dù nó sẽ không bắt được trường hợp bổ sung này ( xem trực tiếp ):
int *p;
p=&a;
printf("%i\n", j = *(reinterpret_cast<short*>(p)));
Mặc dù clang cho phép những lá cờ này nhưng dường như nó không thực sự cảnh báo.
Một công cụ khác mà chúng tôi có sẵn cho chúng tôi là ASan có thể bắt các tải và cửa hàng bị sai lệch. Mặc dù đây không phải là những vi phạm răng cưa trực tiếp nghiêm ngặt nhưng chúng là kết quả chung của các vi phạm răng cưa nghiêm ngặt. Ví dụ: các trường hợp sau sẽ tạo ra lỗi thời gian chạy khi được tạo bằng clang bằng cách sử dụng -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ông cụ cuối cùng tôi sẽ giới thiệu là C ++ cụ thể và không hoàn toàn là một công cụ mà là thực hành mã hóa, không cho phép các kiểu phôi C. Cả gcc và clang sẽ tạo ra chẩn đoán cho các kiểu phôi C bằng cách sử dụng -Wold-style-cast . Điều này sẽ buộc mọi kiểu chơi chữ không xác định sử dụng reinterpret_cast, nói chung reinterpret_cast phải là một cờ để xem xét mã gần hơn. Nó cũng dễ dàng hơn để tìm kiếm cơ sở mã của bạn cho reinterpret_cast để thực hiện kiểm toán.
Đối với C, chúng tôi có tất cả các công cụ đã được trình bày và chúng tôi cũng có trình thông dịch tis, một bộ phân tích tĩnh phân tích triệt để một chương trình cho một tập hợp con lớn của ngôn ngữ C. Đưa ra một câu C của ví dụ trước đó trong đó việc sử dụng -fstrict-aliasing bỏ lỡ một trường hợp ( xem trực tiếp )
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 có thể bắt được cả ba, ví dụ sau đây gọi tis-kernal là tis-phiên dịch (đầu ra được chỉnh sửa cho ngắn gọn):
./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.
Cuối cùng là TySan hiện đang được phát triển. Trình khử trùng này thêm thông tin kiểm tra loại trong phân đoạn bộ nhớ bóng và kiểm tra truy cập để xem liệu chúng có vi phạm quy tắc răng cưa hay không. Công cụ có khả năng có thể bắt được tất cả các vi phạm răng cưa nhưng có thể có chi phí hoạt động lớn.
cvàc++faq.