पर्दे के पीछे क्या होता है सी #: स्टैक के साथ काम करने की मूल बातें

मैं उन इंटर्नल को देखने का प्रस्ताव करता हूं जो ऑब्जेक्ट्स के शुरुआती लाइनों, कॉलिंग विधियों और पासिंग मापदंडों की सरल रेखाओं के पीछे हैं। और, ज़ाहिर है, हम व्यवहार में इस जानकारी का उपयोग करेंगे - हम कॉलिंग विधि के ढेर को घटाएंगे।

त्याग

कहानी के साथ आगे बढ़ने से पहले, मैं दृढ़ता से आपको स्ट्रक्चरलआउट के बारे में पहली पोस्ट पढ़ने की सलाह देता हूं , एक उदाहरण है जो इस लेख में उपयोग किया जाएगा।

उच्च-स्तरीय एक के पीछे सभी कोड डिबग मोड के लिए प्रस्तुत किए जाते हैं, क्योंकि यह वैचारिक आधार को दर्शाता है। JIT ऑप्टिमाइज़ेशन एक अलग बड़ा विषय है जिसे यहाँ कवर नहीं किया जाएगा।

मैं यह भी चेतावनी देना चाहूंगा कि इस लेख में ऐसी सामग्री नहीं है जिसका वास्तविक परियोजनाओं में उपयोग किया जाना चाहिए।

पहला - सिद्धांत

कोई भी कोड अंततः मशीन कमांड का एक सेट बन जाता है। सबसे समझ में आने वाली विधानसभा भाषा निर्देशों के रूप में उनका प्रतिनिधित्व है जो सीधे एक (या कई) मशीन निर्देशों के अनुरूप है।


एक साधारण उदाहरण की ओर मुड़ने से पहले, मैं स्टैक से परिचित होने का प्रस्ताव करता हूं। स्टैक मुख्य रूप से मेमोरी का एक हिस्सा होता है जो कि, एक नियम के रूप में, विभिन्न प्रकार के डेटा को संग्रहीत करने के लिए उपयोग किया जाता है (आमतौर पर उन्हें अस्थायी डेटा कहा जा सकता है)। यह भी याद रखने योग्य है कि स्टैक छोटे पते की ओर बढ़ता है। यह बाद में स्टैक पर एक ऑब्जेक्ट रखा जाता है, इसका कम पता होगा।

अब हम असेंबली भाषा के कोड के अगले टुकड़े पर एक नज़र डालते हैं (मैंने कुछ कॉल को छोड़ दिया है जो डीबग मोड में निहित हैं)।

C #:

public class StubClass { public static int StubMethod(int fromEcx, int fromEdx, int fromStack) { int local = 5; return local + fromEcx + fromEdx + fromStack; } public static void CallingMethod() { int local1 = 7, local2 = 8, local3 = 9; int result = StubMethod(local1, local2, local3); } } 

एएसएम:

 StubClass.StubMethod(Int32, Int32, Int32) 1: push ebp 2: mov ebp, esp 3: sub esp, 0x10 4: mov [ebp-0x4], ecx 5: mov [ebp-0x8], edx 6: xor edx, edx 7: mov [ebp-0xc], edx 8: xor edx, edx 9: mov [ebp-0x10], edx 10: nop 11: mov dword [ebp-0xc], 0x5 12: mov eax, [ebp-0xc] 13: add eax, [ebp-0x4] 14: add eax, [ebp-0x8] 15: add eax, [ebp+0x8] 16: mov [ebp-0x10], eax 17: mov eax, [ebp-0x10] 18: mov esp, ebp 19: pop ebp 20: ret 0x4 StubClass.CallingMethod() 1: push ebp 2: mov ebp, esp 3: sub esp, 0x14 4: xor eax, eax 5: mov [ebp-0x14], eax 6: xor edx, edx 7: mov [ebp-0xc], edx 8: xor edx, edx 9: mov [ebp-0x8], edx 10: xor edx, edx 11: mov [ebp-0x4], edx 12: xor edx, edx 13: mov [ebp-0x10], edx 14: nop 15: mov dword [ebp-0x4], 0x7 16: mov dword [ebp-0x8], 0x8 17: mov dword [ebp-0xc], 0x9 18: push dword [ebp-0xc] 19: mov ecx, [ebp-0x4] 20: mov edx, [ebp-0x8] 21: call StubClass.StubMethod(Int32, Int32, Int32) 22: mov [ebp-0x14], eax 23: mov eax, [ebp-0x14] 24: mov [ebp-0x10], eax 25: nop 26: mov esp, ebp 27: pop ebp 28: ret 

नोटिस करने वाली पहली बात ईबीपी और ईएसपी रजिस्टर और उनके साथ संचालन है।

एक गलत धारणा है कि EBP रजिस्टर किसी तरह पॉइंटर से संबंधित है जो कि स्टैक के शीर्ष पर है, मेरे दोस्तों के बीच आम है। मुझे कहना होगा कि यह नहीं है।

ESP रजिस्टर स्टैक के शीर्ष पर इंगित करने के लिए जिम्मेदार है। इसके विपरीत, प्रत्येक PUSH निर्देश के साथ (स्टैक के शीर्ष पर एक मूल्य डालते हुए) ESP रजिस्टर का मूल्य कम हो जाता है (स्टैक छोटे पते की ओर बढ़ता है), और प्रत्येक POP निर्देश के साथ इसे बढ़ाया जाता है। इसके अलावा, कॉल कमांड स्टैक पर रिटर्न एड्रेस को आगे बढ़ाता है, जिससे ईएसपी रजिस्टर का मूल्य घट जाता है। वास्तव में, ईएसपी रजिस्टर का परिवर्तन न केवल तब किया जाता है जब इन निर्देशों को निष्पादित किया जाता है (उदाहरण के लिए, जब रुकावट कॉल किया जाता है, यही बात कॉल निर्देशों के साथ होती है)।

StubMethod () पर विचार करेंगे।

पहली पंक्ति में, ईबीपी रजिस्टर की सामग्री को बचाया जाता है (इसे स्टैक पर रखा जाता है)। किसी फ़ंक्शन से लौटने से पहले, इस मान को पुनर्स्थापित किया जाएगा।

दूसरी पंक्ति स्टैक के शीर्ष के पते के वर्तमान मूल्य को संग्रहीत करती है (रजिस्टर ईएसपी का मूल्य ईबीपी में स्थानांतरित हो जाता है)। अगला, हम स्टैक के शीर्ष को उतने पदों पर ले जाते हैं, जितने में हमें स्थानीय चर और मापदंडों (तीसरी पंक्ति) को संग्रहीत करने की आवश्यकता होती है। सभी स्थानीय आवश्यकताओं के लिए मेमोरी आवंटन जैसा कुछ - स्टैक फ्रेम । इसी समय, ईबीपी रजिस्टर वर्तमान कॉल के संदर्भ में एक प्रारंभिक बिंदु है। संबोधित करना इस मूल्य पर आधारित है।

उपरोक्त सभी को फ़ंक्शन प्रोलॉग कहा जाता है ।

उसके बाद, स्टैक पर चर संग्रहीत ईबीपी रजिस्टर के माध्यम से एक्सेस किए जाते हैं, जो उस स्थान पर इंगित करता है जहां इस पद्धति के चर शुरू होते हैं। इसके बाद स्थानीय वैरिएबल की शुरुआत होती है।

Fastcall अनुस्मारक: .net में, Fastcall कॉलिंग कन्वेंशन का उपयोग किया जाता है।
कॉलिंग कन्वेंशन फ़ंक्शन को दिए गए स्थान और मापदंडों के क्रम को नियंत्रित करता है।
पहले और दूसरे मापदंडों को क्रमशः ECX और EDX रजिस्टरों के माध्यम से पारित किया जाता है, बाद के मापदंडों को स्टैक के माध्यम से प्रेषित किया जाता है। (यह 32-बिट सिस्टम के लिए है, हमेशा की तरह। 64-बिट सिस्टम में चार पैरामीटर रजिस्टरों ( RCX , RDX , R8 , R9 ) से होकर गुजरे हैं)

गैर-स्थैतिक तरीकों के लिए, पहला पैरामीटर निहित है और इसमें उस उदाहरण का पता होता है जिस पर विधि को कहा जाता है (यह पता)।

लाइनों 4 और 5 में, रजिस्टरों (पहले 2) के माध्यम से पारित किए गए मापदंडों को स्टैक पर संग्रहीत किया जाता है।

अगला स्थानीय चर ( स्टैक फ्रेम ) के लिए स्टैक पर जगह की सफाई कर रहा है और स्थानीय चर को शुरू कर रहा है।

यह उल्लेख के लायक है कि फ़ंक्शन का परिणाम रजिस्टर EAX में है ।

12-16 पंक्तियों में, वांछित चर के अलावा होता है। मैं आपका ध्यान रेखा १५ की ओर आकर्षित करता हूं। पते की पहुँच मूल्य है जो कि स्टैक की शुरुआत से अधिक है, अर्थात, पिछली पद्धति के स्टैक से। कॉल करने से पहले, कॉलर स्टैक के शीर्ष पर एक पैरामीटर को धक्का देता है। यहाँ हम इसे पढ़ते हैं। परिणाम का परिणाम रजिस्टर EAX से प्राप्त किया जाता है और स्टैक पर रखा जाता है। चूंकि यह StubMethod () का रिटर्न वैल्यू है, इसे फिर से EAX में रखा गया है। बेशक, इस तरह के बेतुके निर्देश सेट केवल डिबग मोड में निहित हैं, लेकिन वे वास्तव में दिखाते हैं कि हमारा कोड स्मार्ट ऑप्टिमाइज़र के बिना कैसा दिखता है जो काम का शेर साझा करता है।

18 और 19 की पंक्तियों में, पिछले ईबीपी (कॉलिंग विधि) और स्टैक के शीर्ष पर सूचक को पुनर्स्थापित किया जाता है (जिस समय विधि कहा जाता है)। अंतिम पंक्ति फ़ंक्शन से लौटने वाली है। मूल्य 0x4 के बारे में मैं थोड़ा बाद में बताऊंगा।

आदेशों के इस तरह के अनुक्रम को एक फ़ंक्शन उपसंहार कहा जाता है।

अब CallingMethod () पर एक नज़र डालते हैं । चलो सीधे लाइन 18 पर जाते हैं। यहां हमने स्टैक के शीर्ष पर तीसरा पैरामीटर रखा है। कृपया ध्यान दें कि हम इसे PUSH निर्देश का उपयोग करते हुए करते हैं, अर्थात, ESP मान को घटाया जाता है। अन्य 2 मापदंडों को रजिस्टरों ( फास्टकॉल ) में डाल दिया जाता है। इसके बाद StubMethod () मेथड कॉल आता है। अब आरईटी 0x4 निर्देश को याद करते हैं। यहाँ निम्नलिखित प्रश्न संभव है: 0x4 क्या है? जैसा कि मैंने ऊपर उल्लेख किया है, हमने स्टैक पर कॉल किए गए फ़ंक्शन के मापदंडों को धक्का दिया है। लेकिन अब हमें उनकी जरूरत नहीं है। 0x4 इंगित करता है कि फ़ंक्शन कॉल के बाद स्टैक से कितने बाइट्स को साफ़ करने की आवश्यकता है। चूंकि पैरामीटर एक था, इसलिए आपको 4 बाइट्स साफ़ करने की आवश्यकता है।

यहाँ स्टैक की एक मोटी छवि है:



इस प्रकार, यदि हम चारों ओर मुड़ते हैं और देखते हैं कि विधि कॉल के ठीक बाद स्टैक पर क्या स्थित है, तो सबसे पहले हम ईबीपी देखेंगे, जिसे स्टैक पर धकेल दिया गया था (वास्तव में, यह वर्तमान विधि की पहली पंक्ति में हुआ था)। अगली बात रिटर्न एड्रेस होगी। यह स्थान निर्धारित करता है, हमारे कार्य समाप्त होने के बाद निष्पादन को फिर से शुरू करने के लिए ( RET द्वारा उपयोग किया जाता है)। और इन क्षेत्रों के ठीक बाद हम वर्तमान फ़ंक्शन के मापदंडों को देखेंगे (3 से शुरू होकर, पहले दो पैरामीटर रजिस्टरों के माध्यम से पारित किए जाते हैं)। और उनके पीछे कॉलिंग पद्धति का ढेर छिप जाता है!

पहले और दूसरे क्षेत्रों का उल्लेख ( ईबीपी और वापसी पता) हम 0x8 में ऑफसेट की व्याख्या करते हैं जब हम मापदंडों का उपयोग करते हैं।

इसके विपरीत, फ़ंक्शन कॉल से पहले कड़ाई से परिभाषित क्रम में स्टैक के शीर्ष पर पैरामीटर होना चाहिए। इसलिए, विधि को कॉल करने से पहले, प्रत्येक पैरामीटर को स्टैक पर धकेल दिया जाता है।
लेकिन क्या होगा अगर वे धक्का नहीं देते हैं, और फ़ंक्शन अभी भी उन्हें ले जाएगा?

छोटा उदाहरण

इसलिए, उपरोक्त सभी तथ्यों ने मुझे उस पद्धति के ढेर को पढ़ने की अत्यधिक इच्छा पैदा की है जो मेरी पद्धति को बुलाएगा। यह विचार कि मैं तीसरे तर्क से केवल एक स्थिति में हूं (यह कॉलिंग विधि के ढेर के सबसे करीब होगा) पोषित डेटा है जिसे मैं इतना प्राप्त करना चाहता हूं, मुझे सोने नहीं दिया।

इस प्रकार, कॉलिंग विधि के ढेर को पढ़ने के लिए, मुझे मापदंडों से थोड़ा आगे चढ़ने की आवश्यकता है।

मापदंडों का उल्लेख करते समय, किसी विशेष पैरामीटर के पते की गणना केवल इस तथ्य पर आधारित होती है कि कॉलर ने उन्हें ढेर पर धकेल दिया है।

लेकिन EDX पैरामीटर (जो रुचि रखता है - पिछला लेख ) के माध्यम से गुजरने से मुझे लगता है कि हम कुछ मामलों में संकलक को आउटसोर्स कर सकते हैं।

यह करने के लिए मैंने जिस टूल का उपयोग किया है, उसे स्ट्रक्चरलैट एट्रिब्यूट (अल फीचर्स पहले लेख में हैं ) कहा जाता है। // एक दिन मैं केवल इस विशेषता से थोड़ा अधिक सीखूंगा, मैं वादा करता हूं

ओवरलैप्ड संदर्भ प्रकारों के साथ हम उसी पसंदीदा विधि का उपयोग करते हैं।

उसी समय, यदि ओवरलैपिंग विधियों में मापदंडों की एक अलग संख्या होती है, तो संकलक आवश्यक लोगों को स्टैक पर धक्का नहीं देता (कम से कम क्योंकि यह नहीं जानता कि कौन से हैं)।
हालांकि, विधि जिसे वास्तव में कहा जाता है (एक अलग प्रकार से समान ऑफसेट के साथ), इसके स्टैक के सापेक्ष सकारात्मक पते में बदल जाता है, अर्थात, जहां यह मापदंडों को खोजने की योजना बनाता है।

लेकिन कोई भी पैरामीटर पारित नहीं करता है और कॉलिंग विधि के ढेर को पढ़ने के लिए विधि शुरू होती है। और ऑब्जेक्ट का पता (आईडी संपत्ति के साथ, जो कि राइटलाइन () में उपयोग किया जाता है ) उस स्थान पर है, जहां तीसरे पैरामीटर की उम्मीद है।


मैं असेंबली भाषा कोड नहीं दूंगा, वहां सब कुछ बहुत स्पष्ट है, लेकिन यदि कोई प्रश्न हैं, तो मैं उन्हें टिप्पणियों में जवाब देने की कोशिश करूंगा

मैं पूरी तरह से समझता हूं कि इस उदाहरण का उपयोग अभ्यास में नहीं किया जा सकता है, लेकिन मेरी राय में, यह कार्य की सामान्य योजना को समझने के लिए बहुत उपयोगी हो सकता है।