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

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

त्याग

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

उच्च स्तर के पीछे सभी कोड डिबगिंग मोड के लिए प्रस्तुत किया जाता है, यह वह है जो वैचारिक आधार दिखाता है। इसके अलावा, उपरोक्त सभी को 32-बिट प्लेटफॉर्म के लिए माना जाता है। 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 रजिस्टर किसी भी तरह से पॉइंटर से स्टैक के शीर्ष से संबंधित है। मुझे कहना होगा कि ऐसा नहीं है।

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

StubMethod पर विचार करें।

पहली पंक्ति में, EBP रजिस्टर की सामग्री को सहेजा जाता है (स्टैक पर धकेल दिया जाता है)। फ़ंक्शन से लौटने से पहले, यह मान बहाल किया जाएगा।

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

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

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

Fastcall के बारे में अनुस्मारक: देशी .net फास्टकॉल कॉलिंग कन्वेंशन का उपयोग करता है।
समझौता फ़ंक्शन के लिए पारित मापदंडों के स्थान और आदेश को नियंत्रित करता है।
फास्टकॉल के साथ , पहले और दूसरे मापदंडों को क्रमशः ईसीएक्स और ईडीएक्स रजिस्टरों के माध्यम से पारित किया जाता है, और बाद के मापदंडों को स्टैक के माध्यम से पारित किया जाता है।

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

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

अगला स्थानीय चर के लिए स्टैक स्थान की सफाई कर रहा है और स्थानीय चर को आरंभ कर रहा है।

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

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

लाइनें 18 और 19 पिछले ईबीपी (कॉलिंग विधि) और पॉइंटर को स्टैक के शीर्ष पर पुनर्स्थापित करती हैं (जिस समय विधि को बुलाया गया था)।

अंतिम पंक्ति लौटती है। मूल्य 0x4 के बारे में मैं थोड़ा कम बताऊंगा।
कमांड के इस क्रम को फंक्शन एपिलॉग कहा जाता है।

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

यहाँ एक नमूना स्टैक छवि है:



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

एक छोटा सा उदाहरण

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

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

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

लेकिन EDX पैरामीटर (जो अंतिम लेख की परवाह करता है) से गुजरता है, यह बताता है कि हम कुछ मामलों में कंपाइलर को निकाल सकते हैं।

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

हम संदर्भ प्रकारों के साथ सभी समान पसंदीदा तकनीक का उपयोग करते हैं।

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

लेकिन वहां वह उन्हें नहीं पाता है और कॉलिंग विधि के ढेर को पढ़ना शुरू कर देता है।


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

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