ध्यान दें
यह मेरे "सख्त उपनाम नियम क्या है और हम क्यों परवाह करते हैं?" लिखें।
सख्त अलियासिंग क्या है?
C और C ++ में अलियासिंग को किस प्रकार के अभिव्यक्ति के माध्यम से संग्रहीत मूल्यों तक पहुंचने की अनुमति है, इसके साथ क्या करना है। C और C ++ दोनों में, मानक निर्दिष्ट करता है कि किस प्रकार के उर्फ को किस प्रकार की अनुमति दी जाती है। कंपाइलर और ऑप्टिमाइज़र को यह मानने की अनुमति है कि हम अलियासिंग नियमों का कड़ाई से पालन करते हैं, इसलिए शब्द सख्त अलियासिंग नियम । यदि हम एक प्रकार का उपयोग करके एक मान तक पहुंचने का प्रयास करते हैं, तो इसे अपरिभाषित व्यवहार ( यूबी ) के रूप में वर्गीकृत नहीं किया जाता है । एक बार जब हमारे पास अपरिभाषित व्यवहार होता है तो सभी दांव बंद हो जाते हैं, हमारे कार्यक्रम के परिणाम अब विश्वसनीय नहीं हैं।
दुर्भाग्य से सख्त उर्फ उल्लंघन के साथ, हम अक्सर हम जो परिणाम की उम्मीद करते हैं, वह प्राप्त करेंगे, संभावना है कि एक नए अनुकूलन के साथ एक संकलक के भविष्य के संस्करण को कोड को तोड़ दिया जाएगा जिसे हमने सोचा था कि यह वैध था। यह अवांछनीय है और यह सख्त अलियासिंग नियमों को समझने का एक सार्थक लक्ष्य है और उनका उल्लंघन करने से कैसे बचें।
हम क्यों परवाह करते हैं, इसके बारे में अधिक समझने के लिए, हम उन मुद्दों पर चर्चा करेंगे जो सख्त अलियासिंग नियमों का उल्लंघन करते समय सामने आते हैं, टाइपिंग पाइंटिंग क्योंकि टाइप पाइंटिंग में उपयोग की जाने वाली सामान्य तकनीकें अक्सर सख्त अलियासिंग नियमों का उल्लंघन करती हैं और सही ढंग से सजा कैसे टाइप करें।
प्रारंभिक उदाहरण
आइए कुछ उदाहरणों को देखें, फिर हम इस बारे में बात कर सकते हैं कि मानक (एस) क्या कहते हैं, कुछ और उदाहरणों की जांच करें और फिर देखें कि कैसे सख्त अलियासिंग से बचें और उन उल्लंघनों को पकड़ें जिनसे हम चूक गए थे। यहाँ एक उदाहरण है जो आश्चर्यजनक नहीं होना चाहिए ( लाइव उदाहरण ):
int x = 10;
int *ip = &x;
std::cout << *ip << "\n";
*ip = 12;
std::cout << x << "\n";
हम एक है पूर्णांक * स्मृति को ओर इशारा करते एक के कब्जे में पूर्णांक और यह एक वैध अलियासिंग है। ऑप्टिमाइज़र को यह मान लेना चाहिए कि आईपी के माध्यम से असाइनमेंट 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?
}
फ़ंक्शन फू में हम एक इंट * और एक फ्लोट * लेते हैं , इस उदाहरण में हम फू कहते हैं और दोनों मापदंडों को एक ही मेमोरी स्थान पर इंगित करने के लिए सेट करते हैं जिसमें इस उदाहरण में एक इंट होता है । ध्यान दें, reinterpret_cast अभिव्यक्ति का इलाज करने के लिए संकलक से कह रहा है जैसे कि यह अपने टेम्पलेट पैरामीटर द्वारा टाइप किया गया था। इस मामले में हम इसे एक्सप्रेशन & x का इलाज करने के लिए कह रहे हैं जैसे कि यह फ्लोट * था । हम दूसरे काउंट के परिणाम की उम्मीद कर सकते हैं 0 हो सकता है, लेकिन ऑप्टिमाइज़ेशन के साथ -O2 का उपयोग करके सक्षम किया जाता है, दोनों gcc और clang निम्न परिणाम उत्पन्न करते हैं:
0
1
जिसकी उम्मीद नहीं की जा सकती है लेकिन यह पूरी तरह से वैध है क्योंकि हमने अपरिभाषित व्यवहार किया है। एक नाव वैध एक उपनाम नहीं कर सकते पूर्णांक वस्तु। इसलिए अनुकूलक मान सकते हैं निरंतर 1 जब अपसंदर्भन संग्रहीत मैं के बाद से के माध्यम से एक दुकान वापसी मान हो जाएगा च वैध एक को प्रभावित नहीं कर सकता पूर्णांक वस्तु। कंपाइलर एक्सप्लोरर में कोड प्लग करना यह दिखाता है कि वास्तव में क्या हो रहा है ( लाइव उदाहरण ):
foo(float*, int*): # @foo(float*, int*)
mov dword ptr [rsi], 1
mov dword ptr [rdi], 0
mov eax, 1
ret
का उपयोग कर अनुकूलक प्रकार के आधार उर्फ विश्लेषण (TBAA) मान लिया गया है 1 लौटा दी जाएगी और सीधे रजिस्टर में निरंतर मूल्य बढ़ता रहता है eax वापसी मान किया जाता है जो। TBAA लोड और स्टोर को अनुकूलित करने के लिए अन्य प्रकार की अनुमति देने के बारे में भाषाओं के नियमों का उपयोग करता है। इस मामले में TBAA जानता है कि एक फ्लोट उर्फ और 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 / 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 कहता है:
यदि कोई प्रोग्राम किसी वस्तु के संग्रहित मूल्य को निम्न प्रकार के व्यवहार के अलावा किसी अन्य वस्तु के ग्लव्यू तक पहुँचाने का प्रयास करता है तो व्यवहार अपरिभाषित है: 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 में परिभाषित)
(११.४) - एक प्रकार जो वस्तु के गतिशील प्रकार के अनुरूप हस्ताक्षरित या अहस्ताक्षरित प्रकार है,
// 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;
}
(११.५) - एक प्रकार जो वस्तु के गतिशील प्रकार के cv- योग्य संस्करण के अनुरूप हस्ताक्षरित या अहस्ताक्षरित प्रकार है,
signed int foo( const signed int &si1, int &si2); // Hard to show this one assumes aliasing
(११.६) - एक समग्र या संघ प्रकार जिसमें इसके तत्वों या गैर-डेटा डेटा सदस्यों के बीच पूर्वोक्त प्रकारों में से एक शामिल है (सहित, पुनरावर्ती, एक तत्व या किसी उप-समूह या निहित यूनियन के गैर-स्थैतिक डेटा सदस्य),
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 );
(११. () - एक प्रकार जो वस्तु के गतिशील प्रकार का एक (संभवतः 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) - एक चार, अहस्ताक्षरित चार, या एसटीडी :: बाइट प्रकार।
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
}
वर्थ नोटिंग साइन किए गए चार्ट को ऊपर की सूची में शामिल नहीं किया गया है, यह सी से एक उल्लेखनीय अंतर है जो एक चरित्र प्रकार कहता है ।
टाइप पुनिंग क्या है
हम इस बिंदु पर पहुंच गए हैं और हम सोच रहे होंगे कि हम क्यों इसके लिए उपनाम देना चाहेंगे? उत्तर आमतौर पर दंड टाइप करने के लिए होता है , अक्सर उपयोग किए जाने वाले तरीके सख्त अलियासिंग नियमों का उल्लंघन करते हैं।
कभी-कभी हम टाइप सिस्टम को दरकिनार करना चाहते हैं और किसी ऑब्जेक्ट को एक अलग प्रकार के रूप में व्याख्या करते हैं। मेमोरी के एक सेगमेंट को दूसरे प्रकार की व्याख्या करने के लिए इसे टाइप पिंगिंग कहा जाता है । टाइप पाइंटिंग उन कार्यों के लिए उपयोगी है जो किसी ऑब्जेक्ट के अंतर्निहित प्रतिनिधित्व तक पहुंच, परिवहन या हेरफेर करना चाहते हैं। विशिष्ट क्षेत्र हम पाते हैं कि टाइपिंग का उपयोग किया जा रहा है कंपाइलर, क्रमांकन, नेटवर्किंग कोड, आदि…
परंपरागत रूप से यह वस्तु के पते को लेते हुए पूरा किया गया है, इसे उस प्रकार के एक पॉइंटर को कास्टिंग करना है जिसे हम इसे फिर से व्याख्या करना चाहते हैं और फिर मूल्य को एक्सेस करके या अन्य शब्दों में अलियासिंग करके। उदाहरण के लिए:
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 ++ में मान्य नहीं है और कुछ लोग यूनियनों के उद्देश्य को पूरी तरह से वैरिएंट प्रकारों को लागू करने के लिए मानते हैं और टाइप पाइंटिंग के लिए यूनियनों का उपयोग करने का अनुभव करते हैं।
हम कैसे सही तरीके से पुनरीक्षण करते हैं?
C और C ++ दोनों में टाइप पाइंटिंग के लिए मानक विधि यादगार है । यह एक छोटे से भारी हाथ लग सकता है लेकिन अनुकूलक के उपयोग की पहचान करनी चाहिए memcpy के लिए प्रकार punning और इसे दूर का अनुकूलन और चाल रजिस्टर करने के लिए एक रजिस्टर उत्पन्न करते हैं। उदाहरण के लिए यदि हम जानते हैं कि int64_t डबल के समान आकार है :
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 विधि या संघ के लिए विधि प्रकार punning । उत्पन्न कोड की जांच करने पर हम देखते हैं कि यह केवल रजिस्टर mov ( लाइव कंपाइलर एक्सप्लोरर उदाहरण ) का उपयोग करता है ।
C ++ 20 और bit_cast
C ++ 20 में हम बिट_कास्ट ( प्रस्ताव से लिंक में उपलब्ध कार्यान्वयन) प्राप्त कर सकते हैं, जो एक कॉन्स्ट्रेक्स संदर्भ में प्रयोग करने योग्य होने के साथ-साथ टाइप-वाक्य को एक सरल और सुरक्षित तरीका देता है।
निम्नलिखित कैसे उपयोग करने के लिए का एक उदाहरण है bit_cast एक यमक टाइप करने के लिए अहस्ताक्षरित पूर्णांक के लिए नाव , ( यह सीधा प्रसारण दिखाई ):
std::cout << bit_cast<float>(0x447a0000) << "\n" ; //assuming sizeof(float) == sizeof(unsigned int)
उस स्थिति में जहां To और From के समान आकार नहीं है, हमें एक मध्यवर्ती संरचना 15 का उपयोग करने की आवश्यकता होती है। हम एक struct एक युक्त का उपयोग करेगा sizeof (अहस्ताक्षरित int) चरित्र सरणी ( मान लिया गया 4 बाइट अहस्ताक्षरित 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 ;
}
यह दुर्भाग्यपूर्ण है कि हमें इस मध्यवर्ती प्रकार की आवश्यकता है लेकिन यह बिट_कास्ट का वर्तमान अवरोध है ।
कैचिंग स्ट्रिक्ट अलाइज़िंग वायलेशन
हमारे पास C ++ में सख्त अलियासिंग को पकड़ने के लिए बहुत सारे अच्छे उपकरण नहीं हैं, हमारे पास जो उपकरण हैं वे सख्त अलियासिंग उल्लंघन के कुछ मामलों और गलत लोड और स्टोर के कुछ मामलों को पकड़ लेंगे।
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)));
हालांकि क्लैंग इन झंडों को अनुमति देता है लेकिन यह स्पष्ट रूप से चेतावनियों को लागू नहीं करता है।
एक और उपकरण जो हमारे पास उपलब्ध है वह है आसन जो गलत लोड और स्टोर को पकड़ सकता है। हालाँकि ये सीधे तौर पर सख्त अलिज़िंग उल्लंघन नहीं हैं लेकिन ये सख्त अलियासिंग उल्लंघन का एक सामान्य परिणाम हैं। उदाहरण के लिए, निम्न मामले- क्लेन्साइनेट = पते के उपयोग के साथ निर्मित होने पर रनटाइम त्रुटियाँ उत्पन्न करेंगे
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 दोनों ही C- शैली के कलाकारों के लिए एक डायग्नोस्टिक का निर्माण करेंगे, जो कि-स्टाइल-कास्ट का उपयोग करेगा । यह किसी भी अपरिभाषित प्रकार के पुंजों को रीइंटरप्रिट_कास्ट का उपयोग करने के लिए मजबूर करेगा, सामान्य रीइंटरप्रिट_कास्ट में कोड कोड की समीक्षा के लिए एक ध्वज होना चाहिए। ऑडिट करने के लिए reinterpret_cast के लिए अपना कोड आधार खोजना भी आसान है।
सी के लिए हमारे पास पहले से ही कवर किए गए सभी उपकरण हैं और हमारे पास टिस-इंटरप्रेटर भी है, एक स्थिर विश्लेषक जो सी भाषा के एक बड़े उपसमूह के लिए प्रोग्राम का विस्तृत विश्लेषण करता है। पहले के उदाहरण के C verions को देखते हुए जहां -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-interpreter के रूप में tis-kernal को आमंत्रित करता है (आउटपुट संक्षिप्तता के लिए संपादित किया जाता है):
./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।