हम ELF फ़ाइल को डिबगिंग जानकारी (DWARF) के साथ मैन्युअल रूप से (ARM माइक्रोकंट्रोलर के लिए) बनाते हैं

परिचय

हाल ही में, मुझे माइक्रोकंट्रोलर्स में दिलचस्पी हो गई। पहले एवीआर, फिर एआरएम। प्रोग्रामिंग के लिए दो मुख्य विकल्प हैं माइक्रोकंट्रोलर: असेंबलर और सी। हालांकि, मैं फोर्ट प्रोग्रामिंग भाषा का प्रशंसक हूं और इसे इन माइक्रोकंट्रोलर में पोर्ट करना शुरू कर दिया। बेशक, तैयार समाधान हैं, लेकिन उनमें से कोई भी मेरे पास नहीं था जो मुझे चाहिए: जीडीबी के साथ डिबगिंग। और मैं इस अंतर को भरने के लिए तैयार हूं (अब तक केवल एआरएम के लिए)। मेरे पास 32-बिट एआरएम कॉर्टेक्स-एम 3 प्रोसेसर, 128kB फ्लैश और 8k रैम के साथ एक stm32vldiscovery बोर्ड था, यही कारण है कि मैंने इसके साथ शुरुआत की।
मैंने फोर्ट पर पाठ्यक्रम के ट्रांस-ट्रांसलेटर को लिखा था, और लेख में कोई कोड नहीं होगा, क्योंकि इस भाषा को विदेशी माना जाता है। मैं खुद को काफी विस्तृत सिफारिशों तक सीमित करूंगा। विषय पर नेटवर्क पर लगभग कोई प्रलेखन और उदाहरण नहीं हैं, कुछ मापदंडों का चयन मेरे द्वारा परीक्षण और त्रुटि के माध्यम से किया गया था, कुछ में जीसीसी संकलक के आउटपुट फ़ाइलों का विश्लेषण करके। इसके अलावा, मैंने केवल आवश्यक न्यूनतम डिबगिंग जानकारी का उपयोग किया, बिना स्पर्श के, उदाहरण के लिए, स्थानांतरण-एस और कई अन्य चीजें। विषय बहुत व्यापक है और, मैं स्वीकार करता हूं, मैंने इसे केवल 30 प्रतिशत समझ लिया, जो मेरे लिए पर्याप्त था।

इस परियोजना में रुचि रखने वाला कोई भी व्यक्ति यहां कोड डाउनलोड कर सकता है ।

ELF समीक्षा

मानक विकास उपकरण आपके प्रोग्राम को डीएलबी जानकारी शामिल करने की क्षमता के साथ एक ईएलएफ (निष्पादन योग्य और लिंक करने योग्य प्रारूप) फ़ाइल में संकलित करते हैं। प्रारूप विनिर्देश यहाँ पाया जा सकता है । इसके अलावा, प्रत्येक वास्तुकला की अपनी विशेषताएं हैं, उदाहरण के लिए , एआरएम विशेषताएं । आइए संक्षेप में इस प्रारूप पर विचार करें।
ELF निष्पादन योग्य फ़ाइल में निम्नलिखित भाग होते हैं:

1. शीर्षक (ईएलएफ हैडर)

फ़ाइल और इसकी मुख्य विशेषताओं के बारे में सामान्य जानकारी शामिल है।

2. कार्यक्रम का शीर्षक (प्रोग्राम हैडर टेबल)

यह फ़ाइल अनुभागों और मेमोरी सेगमेंट के बीच पत्राचार की एक तालिका है; यह लोडर को बताता है कि किस मेमोरी क्षेत्र को प्रत्येक अनुभाग लिखना है।

3. धारा

अनुभाग में फ़ाइल (प्रोग्राम, डेटा, डीबगिंग जानकारी, आदि) की सभी जानकारी होती है
प्रत्येक अनुभाग में एक प्रकार, नाम और अन्य पैरामीटर हैं। ".Text" अनुभाग में, कोड आमतौर पर, ".symtab" - प्रोग्राम प्रतीकों (फ़ाइल नाम, प्रक्रिया और चर) की एक तालिका, ".strtab" में - लाइनों की एक तालिका, उपसर्ग "। Debug_" - डिबग जानकारी, आदि के साथ संग्रहीत किया जाता है। .D। इसके अलावा, फ़ाइल में आवश्यक रूप से इंडेक्स 0 के साथ एक खाली अनुभाग होना चाहिए।

4. अनुभाग शीर्षक तालिका

यह एक तालिका है जिसमें अनुभाग शीर्षकों की एक सरणी होती है।
प्रारूप का निर्माण ईएलएफ अनुभाग में अधिक विस्तार से चर्चा की गई है।

DWARF समीक्षा

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

• ब्रेकपॉइंट्स भौतिक पते पर नहीं, लेकिन स्रोत कोड फ़ाइल में लाइन नंबर या फ़ंक्शन के नाम पर
• प्रदर्शन और वैश्विक और स्थानीय चर, साथ ही फ़ंक्शन मापदंडों के मूल्यों को बदलते हैं
• प्रदर्शन कॉल स्टैक (बैकट्रेस)
• प्रोग्राम कोड चरण को एक कोडांतरक निर्देश के अनुसार नहीं, बल्कि स्रोत कोड की तर्ज पर निष्पादित करें

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

डेटा का वर्णन करने वाले नोड:

1. डेटा प्रकार:
   
   • बुनियादी डेटा प्रकार (प्रकार DW_TAG_base_type के साथ नोड), उदाहरण के लिए, जैसे सी में टाइप इंट।
   • मिश्रित डेटा प्रकार (संकेत, आदि)
   • सरणियों
   • संरचनाएं, कक्षाएं, यूनियनों, इंटरफेस
   
   
2. डेटा ऑब्जेक्ट:
   
   • स्थिरांक
   • फ़ंक्शन पैरामीटर
   • चर
   • आदि
   
   

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

कोड का वर्णन करने वाले नोड:

1. कार्यविधियाँ (फ़ंक्शंस) - नोड्स टैग DW_TAG_subprogram के साथ। वंशज नोड्स में चर का विवरण हो सकता है - फ़ंक्शन पैरामीटर और स्थानीय फ़ंक्शन चर।
2. संकलन इकाई कार्यक्रम के लिए जानकारी रखता है और अन्य सभी नोड्स का जनक है।

ऊपर वर्णित जानकारी ".debug_info" और ".debug_abbrev" अनुभागों में है।

अन्य जानकारी:

• पंक्ति संख्या (अनुभाग ".debug_line") के बारे में जानकारी
• मैक्रो सूचना (अनुभाग ".debug_macinfo")
• कॉल फ़्रेम सूचना ("। Debug_frame" अनुभाग)

ईएलएफ बनाना

हम एल्फुटिल्स पैकेज से एब्लेजफुल लाइब्रेरी का उपयोग करके ईएफएल फाइल बनाएंगे । उदाहरण के लिए libble - LibELF के उपयोग पर नेटवर्क पर एक अच्छा लेख है (दुर्भाग्य से, इसमें फ़ाइलों का निर्माण बहुत संक्षेप में वर्णित है) और साथ ही साथ प्रलेखन भी ।
फ़ाइल बनाना कई चरणों में शामिल है:

1. लिबेल इनिशियलाइज़ेशन
2. फ़ाइल हेडर बनाना (ELF Header)
3. प्रोग्राम हेडर बनाना (प्रोग्राम हैडर टेबल)
4. अनुभाग बनाएं
5. फ़ाइल रिकॉर्ड

अधिक विस्तार से चरणों पर विचार करें।

लिबेल इनिशियलाइज़ेशन

सबसे पहले आपको elf_version फ़ंक्शन (EV_CURRENT) को कॉल करना होगा और परिणाम की जांच करनी होगी। यदि यह EV_NONE के बराबर है, तो एक त्रुटि हुई है और आगे की कार्रवाई नहीं की जा सकती है। फिर हमें उस फ़ाइल को बनाने की ज़रूरत है जो हमें डिस्क पर चाहिए, इसका हैंडल प्राप्त करें और इसे elf_begin फ़ंक्शन में पास करें:

Elf * elf_begin( int fd, Elf_Cmd cmd, Elf *elf) 

• fd - नई खोली गई फ़ाइल को हैंडल करें
• cmd - मोड, पढ़ने की जानकारी के लिए ELF_C_READ, लिखने के लिए ELF_C_WRITE या पढ़ने / लिखने के लिए ELF_C_RDWR), यह हमारे मामले में ओपन फाइल मोड (ELF_C_RRITE) के अनुरूप होना चाहिए)
• योगिनी - केवल संग्रह फ़ाइलों (.A) के साथ काम करने के लिए, हमारे मामले में, आपको 0 पास करने की आवश्यकता है

फ़ंक्शन किसी वर्णक को बनाए गए डिस्क्रिप्टर पर लौटाता है, जिसका उपयोग सभी परिवाद कार्यों में किया जाएगा, 0 त्रुटि के मामले में लौटाया जाता है।

एक शीर्षक बनाएँ

नया फ़ाइल हेडर elf32_newehdr फ़ंक्शन द्वारा बनाया गया है:

 Elf32_Ehdr * elf32_newehdr( Elf *elf); 

• योगिनी - संभाल elf_begin द्वारा लौट आए

त्रुटि पर 0 लौटाता है, या किसी संरचना को इंगित करता है - ELF फ़ाइल हेडर:

 #define EI_NIDENT 16 typedef struct { unsigned char e_ident[EI_NIDENT]; Elf32_Half e_type; Elf32_Half e_machine; Elf32_Word e_version; Elf32_Addr e_entry; Elf32_Off e_phoff; Elf32_Off e_shoff; Elf32_Word e_flags; Elf32_Half e_ehsize; Elf32_Half e_phentsize; Elf32_Half e_phnum; Elf32_Half e_shentsize; Elf32_Half e_shnum; Elf32_Half e_shstrndx; } Elf32_Ehdr; 

इसके कुछ क्षेत्र एक मानक तरीके से भरे गए हैं, कुछ को हमारे लिए भरने की आवश्यकता है:

• e_ident - पहचान बाइट सरणी, में निम्नलिखित संकेत हैं:
  
  • EI_MAG0, EI_MAG1, EI_MAG2, EI_MAG3 - इन 4 बाइट्स में वर्ण 0x7f, 'ELF' शामिल होने चाहिए, जो कि elf32_newehdad फ़ंक्शन हमारे लिए पहले ही कर चुका है
  • EI_DATA - फ़ाइल में डेटा एन्कोडिंग के प्रकार को इंगित करता है: ELFDATA2LSB या ELFDATA2MSB। आपको इस तरह ELFDATA2LSB स्थापित करने की आवश्यकता है: e_ident [EI_DATA] = ELFDATA2LSB
  • EI_VERSION - फ़ाइल हेडर संस्करण, जो हमारे लिए पहले से इंस्टॉल है
  • EI_PAD - स्पर्श न करें
• e_type - फ़ाइल प्रकार, ET_NONE - प्रकार के बिना, ET_REL - फ़ाइल को स्थानांतरित किया जा सकता है, ET_EXEC - निष्पादन योग्य फ़ाइल, ET_DYN - साझा ऑब्जेक्ट फ़ाइल, आदि। हमें फ़ाइल प्रकार को ET_EXEC पर सेट करना होगा
• e_machine - इस फ़ाइल के लिए आवश्यक आर्किटेक्चर, उदाहरण के लिए EM_386 - Intel आर्किटेक्चर के लिए, ARM के लिए हमें EM_ARM (40) यहाँ लिखना होगा - ARM आर्किटेक्चर के लिए ELF देखें
• e_version - फ़ाइल संस्करण, EV_CURRENT पर सेट होना चाहिए
• e_entry - प्रवेश बिंदु का पता, हमारे लिए यह आवश्यक नहीं है
• e_phoff - प्रोग्राम हेडर फ़ाइल में ऑफसेट, e_shoff - अनुभाग हेडर ऑफसेट, भरें नहीं
• e_flags - प्रोसेसर-विशिष्ट झंडे, हमारी वास्तुकला के लिए (Cortex-M3) आपको इसे 0x05000000 (ABI संस्करण 5) पर सेट करने की आवश्यकता है
• e_ehsize, e_phentsize, e_phnum, e_shentsize, e_shnum - स्पर्श न करें
• e_shstrndx - उस अनुभाग की संख्या समाहित करता है जिसमें अनुभाग शीर्षलेखों के साथ पंक्तियों की एक तालिका होती है। चूंकि हमारे पास अभी तक कोई अनुभाग नहीं है, इसलिए हम इस नंबर को बाद में स्थापित करेंगे

एक कार्यक्रम शीर्षक बनाएँ

जैसा कि पहले ही उल्लेख किया गया है, प्रोग्राम हेडर (प्रोग्राम हैडर टेबल) फाइल सेक्शन और मेमोरी सेगमेंट के बीच पत्राचार की एक तालिका है, जो लोडर को प्रत्येक सेक्शन को लिखने के लिए कहता है। बनाया गया शीर्षक elf32_newphdr फ़ंक्शन का उपयोग करके बनाया गया है:

 Elf32_Phdr * elf32_newphdr( Elf *elf, size_t count); 

• योगिनी हमारा वर्णनकर्ता है
• गिनती - बनाने के लिए तालिका तत्वों की संख्या। चूंकि हमारे पास केवल एक अनुभाग (प्रोग्राम कोड के साथ) होगा, फिर गणना 1 होगी।

प्रोग्राम हेडर पर त्रुटि या पॉइंटर पर 0 देता है।
शीर्ष लेख तालिका में प्रत्येक तत्व इस संरचना द्वारा वर्णित है:

 typedef struct { Elf32_Word p_type; Elf32_Off p_offset; Elf32_Addr p_vaddr; Elf32_Addr p_paddr; Elf32_Word p_filesz; Elf32_Word p_memsz; Elf32_Word p_flags; Elf32_Word p_align; } Elf32_Phdr; 

• p_type - खंड (अनुभाग) का प्रकार, यहां हमें PT_LOAD - लोड करने योग्य खंड निर्दिष्ट करना होगा
• p_offset - फ़ाइल में ऑफ़सेट, जहाँ से मेमोरी में लोड होने वाले सेक्शन का डेटा शुरू होता है। हमारे पास यह अनुभाग है .text, जो फ़ाइल हेडर और प्रोग्राम हेडर के तुरंत बाद स्थित होगा, हम ऑफसेट की गणना इन हेडर की लंबाई के योग के रूप में कर सकते हैं। Elf32_fsize फ़ंक्शन का उपयोग करके किसी भी प्रकार की लंबाई प्राप्त की जा सकती है:
  

   size_t elf32_fsize(Elf_Type type, size_t count, unsigned int version); 

  प्रकार - यहाँ निरंतर ELF_T_xxx, हमें आकारों की आवश्यकता होगी ELF_T_EHDR और ELF_T_PHDR; गिनती - वांछित प्रकार के तत्वों की संख्या, संस्करण - को EV_CURRENT पर सेट किया जाना चाहिए
• p_vaddr, p_paddr - वह वर्चुअल और भौतिक पता जिससे अनुभाग की सामग्री डाउनलोड की जाएगी। चूंकि हमारे पास आभासी पते नहीं हैं, इसलिए हम इसे भौतिक के बराबर सेट करते हैं, सरलतम मामले में - 0, क्योंकि यह वह जगह है जहां हमारा कार्यक्रम लोड किया जाएगा।
• p_filesz, p_memsz - फ़ाइल और मेमोरी में अनुभाग का आकार। हमारे पास समान हैं, लेकिन चूंकि प्रोग्राम कोड के साथ कोई खंड नहीं है, इसलिए हम उन्हें बाद में स्थापित करेंगे
• p_flags - लोड किए गए मेमोरी सेगमेंट के लिए अनुमतियां। यह PF_R हो सकता है - पढ़ें, PF_W - लिखें, PF_X - निष्पादित करें, या इसके संयोजन। PF_R + PF_X पर p_flags सेट करें
• p_align - खंड का संरेखण, हमारे पास 4 है

अनुभाग बनाएँ

हेडर बनाने के बाद, आप सेक्शन बनाना शुरू कर सकते हैं। एक खाली खंड elf_newscn फ़ंक्शन का उपयोग करके बनाया गया है:

 Elf_Scn * elf_newscn( Elf *elf); 

• योगिनी - संभाल elf_begin द्वारा पहले लौट आए

फ़ंक्शन किसी पॉइंटर को त्रुटि पर खंड या 0 पर लौटाता है।
सेक्शन बनाने के बाद, आपको सेक्शन हेडर को भरना होगा और सेक्शन डेटा डिस्क्रिप्टर बनाना होगा।
हम elf32_getshdr फ़ंक्शन का उपयोग करके अनुभाग हेडर को एक पॉइंटर प्राप्त कर सकते हैं:

 Elf32_Shdr * elf32_getshdr( Elf_Scn *scn); 

• scn उस अनुभाग का सूचक है जो हमें elf_newscn फ़ंक्शन से मिला है।

अनुभाग शीर्षक इस तरह दिखता है:

 typedef struct { Elf32_Word sh_name; Elf32_Word sh_type; Elf32_Word sh_flags; Elf32_Addr sh_addr; Elf32_Off sh_offset; Elf32_Word sh_size; Elf32_Word sh_link; Elf32_Word sh_info; Elf32_Word sh_addralign; Elf32_Word sh_entsize; } Elf32_Shdr; 

• sh_name - सेक्शन का नाम - सेक्शन हेडर (सेक्शन .shstrtab) की स्ट्रिंग टेबल में ऑफसेट - नीचे "पंक्तियों की तालिकाएँ" देखें
• sh_type - अनुभाग का सामग्री प्रकार, उस प्रोग्राम कोड वाले अनुभाग के लिए जिसे आपको SHT_PROGBITS सेट करना है, स्ट्रिंग टेबल के साथ अनुभागों के लिए - SHT_STRTAB, वर्ण तालिका के लिए - SHT_SYMTAB
• sh_flags - खंड झंडे जो संयुक्त हो सकते हैं, और जिनमें से हमें केवल तीन की आवश्यकता है:
  
  • SHF_ALLOC - इसका अर्थ है कि अनुभाग को मेमोरी में लोड किया जाएगा
  • SHF_EXECINSTR - अनुभाग में निष्पादन योग्य कोड होता है
  • SHF_STRINGS - अनुभाग में पंक्तियों की एक तालिका है
  
  तदनुसार, कार्यक्रम के साथ .text अनुभाग के लिए, आपको झंडे सेट करना चाहिए SHF_ALLOC + SHF_EXECINSTR
• sh_addr - पता जहां सेक्शन को मेमोरी में लोड किया जाएगा
• sh_offset - फ़ाइल में अनुभाग ऑफ़सेट - स्पर्श न करें, लाइब्रेरी हमारे लिए स्थापित होगी
• sh_size - अनुभाग आकार - स्पर्श न करें
• sh_link - संबंधित अनुभाग की संख्या समाहित करता है; अनुभाग को इसकी संबंधित पंक्ति तालिका (नीचे देखें) से जोड़ना आवश्यक है
• sh_info - अनुभाग के प्रकार के आधार पर अतिरिक्त जानकारी, 0 पर सेट
• sh_addralign - पता संरेखण, स्पर्श न करें
• sh_entsize - यदि एक खंड में एक ही लंबाई के कई तत्व होते हैं, तो ऐसे तत्व की लंबाई इंगित करती है, स्पर्श न करें

हेडर में भरने के बाद, आपको elf_newdata फ़ंक्शन के साथ एक अनुभाग डेटा विवरणक बनाना होगा:

 Elf_Data * elf_newdata( Elf_Scn *scn); 

• scn - बस एक नए अनुभाग के लिए सूचक प्राप्त किया।

फ़ंक्शन त्रुटि पर 0 या Elf_Data संरचना के लिए एक संकेतक देता है जिसे भरना होगा:

 typedef struct { void* d_buf; Elf_Type d_type; size_t d_size; off_t d_off; size_t d_align; unsigned d_version; } Elf_Data; 

• d_buf - अनुभाग को लिखे जाने वाले डेटा का सूचक
• d_type - data type, ELF_T_BYTE हमारे लिए हर जगह उपयुक्त है
• d_size - डेटा का आकार
• d_off - अनुभाग में ऑफसेट, 0 पर सेट
• d_align - संरेखण, बिना संरेखण के 1 पर सेट किया जा सकता है
• d_version - संस्करण, EV_CURRENT पर सेट होना चाहिए

विशेष खंड

हमारे उद्देश्यों के लिए, हमें वर्गों के न्यूनतम आवश्यक सेट बनाने की आवश्यकता होगी:

• .text - प्रोग्राम कोड वाला सेक्शन
• .symtab - फ़ाइल वर्ण तालिका
• .strtab .symtab अनुभाग से वर्णों के नामों वाली एक स्ट्रिंग तालिका है, क्योंकि उत्तरार्द्ध स्वयं के नाम को संग्रहीत नहीं करता है, लेकिन उनके सूचकांक
• .shstrtab - पंक्ति तालिका जिसमें अनुभाग नाम हैं

सभी अनुभाग पिछले अनुभाग में वर्णित अनुसार बनाए गए हैं, लेकिन प्रत्येक विशेष खंड की अपनी विशेषताएं हैं।

अनुभाग

इस अनुभाग में निष्पादन योग्य कोड है, इसलिए आपको SHT_PROGBITS, sh_flags को SHF_EXECINSTR + SHF_ALLOC, sh_addr को उस पते को सेट करने की आवश्यकता है, जिसमें यह कोड लोड किया जाएगा

धारा .symtab

अनुभाग में कार्यक्रम के सभी प्रतीकों (कार्यों) और उन फाइलों का विवरण शामिल है जिनमें उनका वर्णन किया गया था। इसमें लंबाई में 16 बाइट्स के ऐसे तत्व होते हैं:

 typedef struct { Elf32_Word st_name; Elf32_Addr st_value; Elf32_Word st_size; unsigned char st_info; unsigned char st_other; Elf32_Half st_shndx; } Elf32_Sym; 

• st_name - प्रतीक नाम (स्ट्रिंग्स की तालिका में अनुक्रमणिका .strtab)
• st_value - मान (फ़ंक्शन के लिए इनपुट पता या फ़ाइल के लिए 0)। चूंकि कॉर्टेक्स-एम 3 में थम्ब -2 कमांड सिस्टम है, इसलिए यह पता अजीब होना चाहिए (वास्तविक पता + 1)
• st_size - फ़ंक्शन कोड लंबाई (फ़ाइल के लिए 0)
• st_info - प्रतीक का प्रकार और उसका दायरा। इस फ़ील्ड का मान निर्धारित करने के लिए एक मैक्रो है।
  

   #define ELF32_ST_INFO(b,t) (((b)<<4)+((t)&0xf)) 

  
  जहां बी स्कोप है और टी अक्षर का प्रकार है
  दायरा STB_LOCAL हो सकता है (चरित्र अन्य ऑब्जेक्ट फ़ाइलों से दिखाई नहीं देता है) या STB_GLOBAL (दृश्यमान)। सरलीकरण के लिए हम STB_GLOBAL का उपयोग करते हैं।
  चरित्र प्रकार - फ़ंक्शन के लिए STT_FUNC, फ़ाइल के लिए STT_FILE
• st_other - सेट ०
• st_shndx - उस खंड का सूचकांक जिसके लिए प्रतीक परिभाषित किया गया है (.text अनुभाग का सूचकांक), या फ़ाइल के लिए SHN_ABS।
  इसके scn डिस्क्रिप्टर द्वारा खंड सूचकांक elf_ndxscn का उपयोग करके निर्धारित किया जा सकता है:
  

   size_t elf_ndxscn( Elf_Scn *scn); 

  
  

स्रोत टेक्स्ट से किसी सरणी में गुजरते समय किसी अनुभाग के लिए डेटा एकत्र किया जा सकता है, जिस पर सूचक तब अनुभाग डेटा डिस्क्रिप्टर (d_buf) को लिखा जाता है।
यह खंड सामान्य तरीके से बनाया गया है, केवल sh_type को SHT_SYMTAB पर सेट करने की आवश्यकता है, और .strtab खंड के सूचकांक को sh_link फ़ील्ड में लिखा गया है, इसलिए ये खंड जुड़े हुए हैं।

धारा .strtab

इस अनुभाग में .symtab अनुभाग से सभी वर्णों के नाम हैं। यह एक नियमित अनुभाग के रूप में बनाया गया है, लेकिन sh_type को SHT_STRTAB, sh_flags से SHF_STRINGS तक सेट किया जाना चाहिए, इसलिए यह खंड पंक्तियों की तालिका बन जाता है।
स्रोत टेक्स्ट से किसी सरणी में गुजरते समय किसी अनुभाग के लिए डेटा एकत्र किया जा सकता है, जिस पर सूचक तब अनुभाग डेटा डिस्क्रिप्टर (d_buf) को लिखा जाता है।

धारा .shstrtab

अनुभाग - लाइनों की एक तालिका, फ़ाइल के सभी वर्गों के शीर्षकों में शामिल है, जिसमें स्वयं का शीर्षक भी शामिल है। यह .strtab सेक्शन की तरह ही बनाया गया है। इसका इंडेक्स बनाने के बाद, आपको इसे फ़ाइल हेडर के e_shstrndx फील्ड में लिखना होगा।

रो टेबल

पंक्ति तालिकाओं में एक शून्य बाइट के साथ समाप्त होने वाली लगातार पंक्तियाँ होती हैं, इस तालिका में पहली बाइट भी होनी चाहिए। तालिका में पंक्ति सूचकांक तालिका की शुरुआत से बाइट्स में केवल ऑफसेट है, इसलिए पहली पंक्ति के 'नाम' में सूचकांक 1, अगली पंक्ति 'है' var 'में 6 का सूचकांक है।

  सूचकांक 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
        \ 0 नाम \ 0 var \ 0 

फ़ाइल रिकॉर्ड

इसलिए, हेडर और सेक्शन पहले से ही बने हुए हैं, अब उन्हें एक फाइल पर लिखने और एक्जिट लीफ से बाहर निकलने की आवश्यकता है। रिकॉर्ड elf_update फ़ंक्शन द्वारा निर्मित है:

 off_t elf_update( Elf *elf, Elf_Cmd cmd); 

• योगिनी - संभाल
• cmd - कमांड, लिखने के लिए ELF_C_WRITE के बराबर होना चाहिए।

फ़ंक्शन त्रुटि पर -1 लौटता है। त्रुटि पाठ को elf_errmsg (-1) फ़ंक्शन को कॉल करके प्राप्त किया जा सकता है, जो त्रुटि स्ट्रिंग के लिए एक संकेतक लौटाएगा।
हम elf_end फ़ंक्शन के साथ पुस्तकालय के साथ काम करना समाप्त करते हैं, जिससे हम अपने विवरणक को पास करते हैं। यह केवल पहले खोली गई फ़ाइल को बंद करने के लिए बनी हुई है।
हालाँकि, हमारी बनाई गई फ़ाइल में डिबगिंग जानकारी नहीं है, जिसे हम अगले भाग में जोड़ेंगे।

DWARF बनाना

हम libdwarf लाइब्रेरी का उपयोग करते हुए डिबगिंग जानकारी बनाएंगे , जो कि डॉक्यूमेंट (libdwarf2p.1.pdf - एक निर्माता लाइब्रेरी इंटरफेस टू DWARF) के साथ एक पीडीएफ फाइल के साथ आता है।
डिबगिंग जानकारी बनाना निम्नलिखित चरणों में शामिल है:

1. कामचलाऊ निर्माता का प्रारंभ
2. नोड्स बनाना (डीआईई - डिबगिंग सूचना प्रविष्टि)
3. नोड एट्रीब्यूट बनाना
4. एक संकलन इकाई बनाना
5. एक सामान्य सूचना प्रविष्टि बनाना
6. डेटा प्रकार बनाना
7. प्रक्रियाओं (कार्यों) का निर्माण
8. चर और स्थिरांक बनाना
9. डिबग जानकारी के साथ अनुभाग बनाना
10. पुस्तकालय के साथ काम खत्म करना

अधिक विस्तार से चरणों पर विचार करें।

कामचलाऊ निर्माता का प्रारंभ

हम एक ही समय में संकलन के दौरान डिबगिंग की जानकारी सृजित करेंगे। इनसिमटैब सेक्शन में पात्रों का निर्माण करते हैं, इसलिए लाइब्रेरी को इनिशियलाइज़ होने के बाद आरंभीकृत किया जाना चाहिए, एलईएफ हेडर और प्रोग्राम हेडर बनाए जाते हैं, इससे पहले कि सेक्शन बनाया जाए।
आरंभीकरण के लिए, हम dwarf_producer_init_c फ़ंक्शन का उपयोग करेंगे। लाइब्रेरी (dwarf_producer_init, dwarf_producer_init_b) में कई और आरंभीकरण कार्य हैं, जो प्रलेखन में वर्णित कुछ बारीकियों में भिन्न हैं। सिद्धांत रूप में, आप उनमें से किसी का उपयोग कर सकते हैं।

 Dwarf_P_Debug dwarf_producer_init_c( Dwarf_Unsigned flags, Dwarf_Callback_Func_c func, Dwarf_Handler errhand, Dwarf_Ptr errarg, void * user_data, Dwarf_Error *error) 

• झंडे - "या" कई स्थिरांक का संयोजन जो कुछ मापदंडों को निर्धारित करता है, उदाहरण के लिए, बिट डेप्थ, बाइट ऑर्डर (लिटिल-एंडियन, बिग-एंडियन), रिलोकेशन प्रारूप, जिसके लिए हमें निश्चित रूप से DW_DLC_WRITE और DWDDLC_SYMBOLIC_RELOCATIONS की आवश्यकता है
• func - एक कॉलबैक फ़ंक्शन जिसे डिबगिंग जानकारी के साथ ELF अनुभाग बनाते समय कॉल किया जाएगा। अधिक जानकारी के लिए, नीचे "डिबगिंग जानकारी के साथ अनुभाग बनाना" अनुभाग देखें।
• इरैंडहैंड - एक फ़ंक्शन के लिए एक पॉइंटर जो त्रुटियों के होने पर कॉल किया जाएगा। 0 पास कर सकते हैं
• इररग - वह डेटा जो इरैंडहैंड फंक्शन में पास होगा, उसे 0 पर सेट किया जा सकता है
• user_data - फंक फ़ंक्शन को पास किया जाने वाला डेटा 0 पर सेट किया जा सकता है
• एरर - रिटर्न एरर कोड

फ़ंक्शन Dwarf_P_Debug देता है - बाद के सभी कार्यों में उपयोग किए गए डिस्क्रिप्टर, या एक त्रुटि के मामले में -1, और त्रुटि में एक त्रुटि कोड होगा (आप इस कोड को पास करके dff_errmsg फ़ंक्शन का उपयोग करके त्रुटि कोड का पाठ प्राप्त कर सकते हैं)

नोड्स बनाना (डीआईई - डिबगिंग सूचना प्रविष्टि)

जैसा कि ऊपर वर्णित है, डिबगिंग जानकारी एक पेड़ संरचना बनाती है। इस पेड़ का एक नोड बनाने के लिए, आपको चाहिए:

• इसे dwarf_new_die फ़ंक्शन के साथ बनाएं
• इसमें विशेषताएँ जोड़ें (प्रत्येक प्रकार की विशेषता इसके फ़ंक्शन द्वारा जोड़ी जाती है, जिसे बाद में वर्णित किया जाएगा)

नोड dwarf_new_die फ़ंक्शन का उपयोग करके बनाया गया है:

 Dwarf_P_Die dwarf_new_die( Dwarf_P_Debug dbg, Dwarf_Tag new_tag, Dwarf_P_Die parent, Dwarf_P_Die child, Dwarf_P_Die left_sibling, Dwarf_P_Die right_sibling, Dwarf_Error *error) 

• dbg - Dwarf_P_Debug लाइब्रेरी इनिशियलाइज़ेशन के दौरान प्राप्त विवरण
• नोड का new_tag - टैग (प्रकार) - निरंतर DW_TAG_xxxx, जो फ़ाइल libdwarv.h में पाया जा सकता है
• माता-पिता, बच्चे, बाएँ_बसिंग, दाएँ_बस - क्रमशः, माता-पिता, बच्चे, नोड के बाएँ और दाएँ पड़ोसी। इन सभी मापदंडों को निर्दिष्ट करना आवश्यक नहीं है, बाकी सेट के बजाय एक निर्दिष्ट करने के लिए पर्याप्त है। 0. यदि सभी पैरामीटर 0 हैं, तो नोड या तो जड़ या अलग होगा
• त्रुटि - इसमें होने पर त्रुटि कोड होगा

फ़ंक्शन त्रुटि पर DW_DLV_BADADDR, या Dwarf_P_Die नोड को हैंडल देता है यदि सफल हो

नोड एट्रीब्यूट बनाना

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

 Dwarf_P_Attribute dwarf_add_AT_name( Dwarf_P_Die ownerdie, char *name, Dwarf_Error *error) 

• नाम - गुण मान ही (नोड नाम)

सफलता पर त्रुटि या विशेषता विवरणक पर DW_DLV_BADADDR लौटाता है।
कार्य dwarf_add_AT_signed_const, dwarf_add_AT_unsigned_const नोड में निर्दिष्ट विशेषता और उसके हस्ताक्षरित (अहस्ताक्षरित) मान जोड़ें। हस्ताक्षरित और अहस्ताक्षरित विशेषताओं का उपयोग निरंतर मान, आकार, रेखा संख्या आदि को सेट करने के लिए किया जाता है। समारोह प्रारूप:

 Dwarf_P_Attribute dwarf_add_AT_(un)signed_const( Dwarf_P_Debug dbg, Dwarf_P_Die ownerdie, Dwarf_Half attr, Dwarf_Signed value, Dwarf_Error *error) 

• dbg - Dwarf_P_Debug लाइब्रेरी इनिशियलाइज़ेशन के दौरान प्राप्त विवरण
• attr - वह विशेषता जिसका मान सेट किया गया है, निरंतर DW_AT_xxxx है, जिसे फ़ाइल libdf.h में पाया जा सकता है
• मूल्य - विशेषता मान

सफलता पर त्रुटि या विशेषता विवरणक के मामले में DW_DLV_BADADDR लौटाएं।

एक संकलन इकाई बनाना

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

मुख्य फ़ाइल जानकारी

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

संकलक जानकारी

हम dwarf_add_AT_producer फ़ंक्शन का उपयोग करते हैं:

 Dwarf_P_Attribute dwarf_add_AT_name( Dwarf_P_Die ownerdie, char *producer_string, Dwarf_Error *error) 

• निर्माता_स्ट्रिंग - सूचना पाठ के साथ एक स्ट्रिंग

सफलता पर त्रुटि या विशेषता विवरणक पर DW_DLV_BADADDR लौटाता है।

एक सामान्य सूचना प्रविष्टि बनाना

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

• रजिस्टर प्रक्रिया में संग्रहीत नहीं है
• रजिस्टर प्रक्रिया में इसके मूल्य को नहीं बदलता है
• रजिस्टर सीएफए + एन में स्टैक पर संग्रहीत किया जाता है
• रजिस्टर को दूसरे रजिस्टर में स्टोर किया जाता है
• रजिस्टर को कुछ पते पर मेमोरी में संग्रहीत किया जाता है, जिसकी गणना एक गैर-स्पष्ट तरीके से की जा सकती है
• आदि

चूंकि जानकारी को कोड में प्रत्येक पते के लिए इंगित किया जाना चाहिए, यह बहुत ही चमकदार है और इसे .debug_frame अनुभाग में एक संपीड़ित रूप में संग्रहीत किया जाता है। चूंकि यह पते से पते में बहुत कम बदलता है, केवल इसके परिवर्तन निर्देश DW_CFA_xxxx के रूप में एन्कोड किए गए हैं। प्रत्येक निर्देश एक परिवर्तन को इंगित करता है, उदाहरण के लिए:

• DW_CFA_set_loc - कार्यक्रम में वर्तमान पते को इंगित करता है
• DW_CFA_advance_loc - एक सूचक को बाइट्स की एक निश्चित संख्या में ले जाता है
• DW_CFA_def_cfa - स्टैक फ़्रेम (संख्यात्मक स्थिर) के पते को इंगित करता है
• DW_CFA_def_cfa_register - स्टैक फ्रेम (प्रोसेसर रजिस्टर से लिया गया) के पते को इंगित करता है
• DW_CFA_def_cfa_expression - इंगित करता है कि स्टैक फ्रेम के पते की गणना कैसे करें
• DW_CFA_same_value - इंगित करता है कि मामला नहीं बदला गया है
• DW_CFA_register - इंगित करता है कि रजिस्टर किसी अन्य रजिस्टर में संग्रहीत है
• आदि

.Debug_frame अनुभाग के तत्व ऐसे रिकॉर्ड हैं जो दो प्रकार के हो सकते हैं: सामान्य सूचना प्रविष्टि (CIE) और फ़्रेम विवरण प्रविष्टि (FDE)। CIE में ऐसी जानकारी है जो कई FDE प्रविष्टियों के लिए सामान्य है, मोटे तौर पर यह एक निश्चित प्रकार की प्रक्रिया का वर्णन करती है। FDE प्रत्येक विशिष्ट प्रक्रिया का भी वर्णन करता है। प्रक्रिया में प्रवेश करते समय, डीबगर पहले CIE से निर्देश निष्पादित करता है, और फिर FDE से।
मेरा कंपाइलर प्रक्रिया बनाता है जिसमें सीएफए स्प (आर 13) रजिस्टर में होता है। सभी प्रक्रियाओं के लिए एक CIE बनाएँ। इसके लिए एक dwarf_add_frame_cie फ़ंक्शन है:

 Dwarf_Unsigned dwarf_add_frame_cie( Dwarf_P_Debug dbg, char *augmenter, Dwarf_Small code_align, Dwarf_Small data_align, Dwarf_Small ret_addr_reg, Dwarf_Ptr init_bytes, Dwarf_Unsigned init_bytes_len, Dwarf_Error *error); 

• संवर्धक एक UTF-8 एन्कोडेड स्ट्रिंग है जो इंगित करता है कि CIE या FDE के लिए अतिरिक्त प्लेटफ़ॉर्म-विशिष्ट जानकारी है। हमने एक खाली स्ट्रिंग लगाई
• code_align - बाइट्स में कोड का संरेखण (हमारे पास 2 है)
• data_align — ( -4, 4 )
• ret_addr_reg — , ( 14)
• init_bytes — , DW_CFA_. , . elf-, , . 3 : 0x0C, 0x0D, 0, DW_CFA_def_cfa: r13 ofs 0 (CFA r13, 0)
• init_bytes_len — init_bytes

DW_DLV_NOCOUNT CIE, FDE , « FDE »

, , , . , ( int, double .), .
— DW_TAG_base_type. :

• «» (DW_AT_name)
• «» (DW_AT_encoding) — , (, DW_ATE_boolean — , DW_ATE_float — , DW_ATE_signed — , DW_ATE_unsigned — .)
• «» (DW_AT_byte_size — DW_AT_bit_size — )

.
, 32- «int», DW_TAG_base_type DW_AT_name — «int», DW_AT_encoding — DW_ATE_signed, DW_AT_byte_size — 4.
. DW_AT_type — . int — DW_TAG_pointer_type DW_AT_type «int».
dwarf_add_AT_reference:

 Dwarf_P_Attribute dwarf_add_AT_reference( Dwarf_P_Debug dbg, Dwarf_P_Die ownerdie, Dwarf_Half attr, Dwarf_P_Die otherdie, Dwarf_Error *error) 

• attr — , DW_AT_type
• otherdie — ,

प्रक्रियाएँ बनाने के लिए, मुझे अन्य प्रकार के डिबगिंग जानकारी को स्पष्ट करने की आवश्यकता है - लाइन नंबर की जानकारी। यह प्रत्येक मशीन निर्देश को स्रोत कोड की एक विशेष पंक्ति में मैप करने और किसी प्रोग्राम के लाइन-बाय-लाइन डीबगिंग को सक्षम करने का कार्य करता है। यह जानकारी .debug_line अनुभाग में संग्रहीत है। यदि हमारे पास पर्याप्त स्थान है, तो यह मैट्रिक्स के रूप में संग्रहीत किया जाएगा, ऐसे कॉलम के साथ प्रत्येक निर्देश के लिए एक पंक्ति:

• स्रोत फ़ाइल नाम
• इस फाइल में लाइन नंबर
• फ़ाइल में कॉलम नंबर
• क्या निर्देश एक ऑपरेटर या स्टेटमेंट ब्लॉक की शुरुआत है
• आदि

, . -, , -, , . , , «» . , : DW_LNS_advance_pc — , DW_LNS_set_file — , , DW_LNS_const_add_pc — ..
, libdwarf , .
प्रत्येक निर्देश के लिए फ़ाइल नाम को स्टोर करना महंगा है, इसलिए, नाम के बजाय, इसका सूचकांक एक विशेष तालिका में संग्रहीत किया जाता है। फ़ाइल इंडेक्स बनाने के लिए, आपको dwarf_add_file_decl फ़ंक्शन का उपयोग करना होगा:

 Dwarf_Unsigned dwarf_add_file_decl( Dwarf_P_Debug dbg, char *name, Dwarf_Unsigned dir_idx, Dwarf_Unsigned time_mod, Dwarf_Unsigned length, Dwarf_Error *error) 

• नाम - फ़ाइल नाम
• dir_idx - उस फ़ोल्डर का सूचकांक जहां फ़ाइल स्थित है। सूचकांक dwarf_add_directory_decl फ़ंक्शन का उपयोग करके प्राप्त किया जा सकता है। यदि पूर्ण पथ का उपयोग किया जाता है, तो आप 0 को फ़ोल्डर के सूचकांक के रूप में सेट कर सकते हैं और dwarf_add_directory_decec का उपयोग नहीं कर सकते
• time_mod - फ़ाइल संशोधन समय, आप छोड़ सकते हैं (0)
• लंबाई - फ़ाइल का आकार, वैकल्पिक (0)

फ़ंक्शन फ़ाइल इंडेक्स या DW_DLV_NOCOUNT को त्रुटि पर लौटाएगा।
पंक्ति संख्याओं के बारे में जानकारी बनाने के लिए, तीन कार्य हैं dwarf_add_line_entry_b, dwarf_lne_set_address, dwarf_lne_end_fter_ence, जिन्हें हम नीचे विचार करेंगे।
प्रक्रिया के लिए डिबगिंग जानकारी बनाना कई चरणों में होता है:

• .symtab अनुभाग में एक प्रक्रिया प्रतीक बनाना
• विशेषताओं के साथ एक प्रक्रिया नोड बनाना
• FDE प्रक्रियाएँ बनाना
• प्रक्रिया मापदंडों का निर्माण
• लाइन नंबर की जानकारी बनाना

एक प्रक्रिया प्रतीक बनाना

« .symtab». . , . , , .

dwarf_new_die (. « »), DW_TAG_subprogram, — Compilation Unit ( ) DIE ( ). :

• ( dwarf_add_AT_name, . « »)
• , ( DW_AT_decl_line), dwarf_add_AT_unsigned_const (. « »)
• ( DW_AT_decl_file), dwarf_add_AT_unsigned_const (. « »)
• ( DW_AT_low_pc), dwarf_add_AT_targ_address, .
• ( DW_AT_high_pc), dwarf_add_AT_targ_address, .
• ( DW_AT_type — , . « »). —

DW_AT_low_pc DW_AT_high_pc dwarf_add_AT_targ_address_b:

 Dwarf_P_Attribute dwarf_add_AT_targ_address_b( Dwarf_P_Debug dbg, Dwarf_P_Die ownerdie, Dwarf_Half attr, Dwarf_Unsigned pc_value, Dwarf_Unsigned sym_index, Dwarf_Error *error) 

• attr — (DW_AT_low_pc DW_AT_high_pc)
• pc_value —
• sym_index - .symtab तालिका में प्रक्रिया प्रतीक का सूचकांक। वैकल्पिक, 0 पास कर सकते हैं

फ़ंक्शन त्रुटि पर DW_DLV_BADADDR लौटाएगा।

FDE प्रक्रियाएँ बनाना

जैसा कि अनुभाग में उल्लेख किया गया है "एक सामान्य जानकारी प्रविष्टि बनाना", प्रत्येक प्रक्रिया के लिए, आपको एक फ्रेम डिस्क्रिप्टर बनाने की आवश्यकता है, जो कई चरणों में होता है:

• एक नया FDE बनाना (सामान्य जानकारी प्रविष्टि बनाना देखें)
• सामान्य सूची में शामिल एफडीई बनाया
• निर्मित FDE में निर्देश जोड़ना

आप dwarf_new_fde फ़ंक्शन का उपयोग करके एक नया FDE बना सकते हैं:

 Dwarf_P_Fde dwarf_new_fde( Dwarf_P_Debug dbg, Dwarf_Error *error) 

फ़ंक्शन त्रुटि पर एक नया FDE विवरणक या DW_DLV_BADADDR लौटाएगा।
आप dwarf_add_frame_fde का उपयोग करके सूची में एक नया FDE संलग्न कर सकते हैं:

 Dwarf_Unsigned dwarf_add_frame_fde( Dwarf_P_Debug dbg, Dwarf_P_Fde fde, Dwarf_P_Die die, Dwarf_Unsigned cie, Dwarf_Addr virt_addr, Dwarf_Unsigned code_len, Dwarf_Unsigned sym_idx, Dwarf_Error* error) 

• फीका - बस संभाल लिया
• मरो - मरने की प्रक्रिया (विशेषताओं के साथ एक प्रक्रिया नोड बनाना देखें)
• cie - CIE विवरणक (एक सामान्य सूचना प्रविष्टि बनाना देखें)
• virt_addr - हमारी प्रक्रिया का प्रारंभिक पता
• code_len - बाइट्स में प्रक्रिया की लंबाई
• sym_idx - प्रतीक सूचकांक (वैकल्पिक, आप निर्दिष्ट कर सकते हैं 0)

फ़ंक्शन त्रुटि पर DW_DLV_NOCOUNT वापस कर देगा।
इस सब के बाद, आप हमारे FDE में DW_CFA_xxxx निर्देश जोड़ सकते हैं। यह dwarf_add_fde_inst और dwarf_fde_cfa_offset फ़ंक्शन के साथ किया जाता है। पहले वाला सूची में दिए गए निर्देश को जोड़ता है:

 Dwarf_P_Fde dwarf_add_fde_inst( Dwarf_P_Fde fde, Dwarf_Small op, Dwarf_Unsigned val1, Dwarf_Unsigned val2, Dwarf_Error *error) 

• fde - FDE द्वारा बनाया गया डिस्क्रिप्टर
• ऑप - निर्देश कोड (DW_CFA_xxxx)
• val1, val2 - निर्देश पैरामीटर (प्रत्येक निर्देश के लिए अलग, मानक देखें, खंड 6.4.2 कॉल फ़्रेम निर्देश)

Dwarf_fde_cfa_offset फ़ंक्शन DW_CFA_offset स्टेटमेंट जोड़ता है:

 Dwarf_P_Fde dwarf_fde_cfa_offset( Dwarf_P_Fde fde, Dwarf_Unsigned reg, Dwarf_Signed offset, Dwarf_Error *error) 

• fde - FDE द्वारा बनाया गया डिस्क्रिप्टर
• reg - एक रजिस्टर जो फ्रेम को लिखा जाता है
• ऑफ़सेट - फ़्रेम में इसकी ऑफ़सेट्स (बाइट्स में नहीं, बल्कि फ़्रेम एलिमेंट्स में, एक सामान्य सूचना प्रविष्टि बनाना, data_alide) देखें

, , lr (r14). DW_CFA_advance_loc , 1, pc 2 (. Common Information Entry, code_align), DW_CFA_def_cfa_offset 4 ( 4 ) dwarf_fde_cfa_offset reg=14 offset=1, r14 -4 CFA.

, . « »

C

:

• dwarf_lne_set_address
• कोड की प्रत्येक पंक्ति (या मशीन निर्देश) के लिए हम स्रोत कोड (dwarf_add_line_entry) के बारे में जानकारी बनाते हैं
• प्रक्रिया के अंत में, dwarf_lne_end_fterence फ़ंक्शन के साथ निर्देश ब्लॉक को पूरा करें

Dwarf_lne_set_address फ़ंक्शन उस पते को सेट करता है जहां निर्देश ब्लॉक शुरू होता है:

 Dwarf_Unsigned dwarf_lne_set_address( Dwarf_P_Debug dbg, Dwarf_Addr offs, Dwarf_Unsigned symidx, Dwarf_Error *error) 

• उतर - प्रक्रिया का पता (पहली मशीन निर्देश का पता)
• sym_idx - प्रतीक सूचकांक (वैकल्पिक, आप निर्दिष्ट कर सकते हैं 0)

रिटर्न 0 (सफलता) या DW_DLV_NOCOUNT (त्रुटि)।
Dwarf_add_line_entry_b फ़ंक्शन स्रोत कोड की पंक्तियों के बारे में .debug_line अनुभाग में जानकारी जोड़ता है। मैं प्रत्येक मशीन निर्देश के लिए इस फ़ंक्शन को कॉल करता हूं:

 Dwarf_Unsigned dwarf_add_line_entry_b( Dwarf_P_Debug dbg, Dwarf_Unsigned file_index, Dwarf_Addr code_offset, Dwarf_Unsigned lineno, Dwarf_Signed column_number, Dwarf_Bool is_source_stmt_begin, Dwarf_Bool is_basic_block_begin, Dwarf_Bool is_epilogue_begin, Dwarf_Bool is_prologue_end, Dwarf_Unsigned isa, Dwarf_Unsigned discriminator, Dwarf_Error *error) 

• file_index - dwarf_add_file_decl फ़ंक्शन द्वारा पहले प्राप्त स्रोत कोड फ़ाइल का सूचकांक (देखें "प्रक्रिया बनाना")
• code_offset - वर्तमान मशीन अनुदेश का पता
• लाइनो - सोर्स कोड फ़ाइल में लाइन नंबर
• column_number —
• is_source_stmt_begin — 1 lineno ( 1)
• is_basic_block_begin — 1 ( 0)
• is_epilogue_begin — 1 ( , 0)
• is_prologue_end — 1 (!)
• isa — instruction set architecture ( ). DW_ISA_ARM_thumb ARM Cortex M3!
• discriminator. (, , ) . . , 0

फ़ंक्शन 0 (सफलता) या DW_DLV_NOCOUNT (त्रुटि) देता है।
अंत में, dwarf_lne_end_fterence फ़ंक्शन प्रक्रिया को पूरा करता है:

 Dwarf_Unsigned dwarf_lne_end_sequence( Dwarf_P_Debug dbg, Dwarf_Addr address; Dwarf_Error *error) 

• पता - वर्तमान मशीन अनुदेश का पता

रिटर्न 0 (सफलता) या DW_DLV_NOCOUNT (त्रुटि)।
यह प्रक्रिया के निर्माण को पूरा करता है।

चर और स्थिरांक बनाना

सामान्य तौर पर, चर बहुत सरल होते हैं। उनके पास एक नाम, मेमोरी का एक टुकड़ा (या प्रोसेसर रजिस्टर) है, जहां उनका डेटा स्थित है, साथ ही इस डेटा का प्रकार भी है। यदि वैरिएबल वैश्विक है, तो इसका अभिभावक संकलन इकाई होना चाहिए, यदि स्थानीय - संबंधित नोड (विशेष रूप से प्रक्रियाओं के मापदंडों के संबंध में, उनकी प्रक्रिया माता-पिता होनी चाहिए)। आप यह भी निर्दिष्ट कर सकते हैं कि चर घोषणा किस फ़ाइल, लाइन और कॉलम में स्थित है।
, , . , — (location expressions). — ( DW_OP_) - , , . , :

• DW_OP_addr —
• DW_OP_fbreg — ( )
• DW_OP_reg0… DW_OP_reg31 — ,

, (dwarf_new_expr), (dwarf_add_expr_addr, dwarf_add_expr_gen .) DW_AT_location (dwarf_add_AT_location_expression).
0 :

 Dwarf_Expr dwarf_new_expr( Dwarf_P_Debug dbg, Dwarf_Error *error) 

dwarf_add_expr_gen:

 Dwarf_Unsigned dwarf_add_expr_gen( Dwarf_P_Expr expr, Dwarf_Small opcode, Dwarf_Unsigned val1, Dwarf_Unsigned val2, Dwarf_Error *error) 

• expr — ,
• opcode — , DW_OP_
• val1, val2 — (. )

फ़ंक्शन त्रुटि पर DW_DLV_NOCOUNT देता है।
किसी चर का पता स्पष्ट रूप से सेट करने के लिए, पिछले एक के बजाय dwarf_add_expr_addr फ़ंक्शन का उपयोग किया जाना चाहिए:

 Dwarf_Unsigned dwarf_add_expr_addr( Dwarf_P_Expr expr, Dwarf_Unsigned address, Dwarf_Signed sym_index, Dwarf_Error *error) 

• expr - पता अभिव्यक्ति का विवरण जिसमें निर्देश जोड़ा गया है
• पता - चर का पता
• sym_index - .symtab तालिका में वर्ण का सूचकांक। वैकल्पिक, 0 पास कर सकते हैं

फ़ंक्शन त्रुटि पर DW_DLV_NOCOUNT भी लौटाता है।
अंत में, आप बौने_add_AT_location_expr फ़ंक्शन का उपयोग करके नोड के लिए बनाई गई पता अभिव्यक्ति जोड़ सकते हैं:

 Dwarf_P_Attribute dwarf_add_AT_location_expr( Dwarf_P_Debug dbg, Dwarf_P_Die ownerdie, Dwarf_Half attr, Dwarf_P_Expr loc_expr, Dwarf_Error *error) 

• मालिक - वह नोड जिसमें अभिव्यक्ति जोड़ी जाती है
• Attr - विशेषता (हमारे मामले में DW_AT_location)
• loc_expr - पहले से बनाई गई पता अभिव्यक्ति को संभाल

DW_DLV_NOCOUNT .
( ) — DW_TAG_variable, DW_TAG_formal_parameter DW_TAG_const_type . :

• / ( dwarf_add_AT_name, . « »)
• , ( DW_AT_decl_line), dwarf_add_AT_unsigned_const (. « »)
• ( DW_AT_decl_file), dwarf_add_AT_unsigned_const (. « »)
• / ( DW_AT_type — , . « »)
• (. ) —
• या मान - एक स्थिरांक के लिए (विशेषता DW_AT_const_value, "बनाना नोड गुण" देखें)

डिबग जानकारी के साथ अनुभाग बनाना

डिबगिंग सूचना ट्री के सभी नोड्स बनाने के बाद, आप इसके साथ योगिनी-वर्गों के गठन के लिए आगे बढ़ सकते हैं। यह दो चरणों में होता है:

• सबसे पहले आपको dwarf_transform_to_disk_form फ़ंक्शन को कॉल करने की आवश्यकता है, जो उस फ़ंक्शन को कॉल करेगा जिसे हमने प्रत्येक अनुभाग के लिए एक बार आवश्यक योगिनी अनुभाग बनाने के लिए लिखा था।
• प्रत्येक अनुभाग के लिए, dwarf_get_section_bytes फ़ंक्शन हमें वह डेटा लौटाएगा, जिसे संबंधित अनुभाग को लिखना होगा

समारोह

 dwarf_transform_to_disk_form ( Dwarf_P_Debug dbg, Dwarf_Error* error) 

डिबगिंग जानकारी का अनुवाद हम बाइनरी प्रारूप में करते हैं, लेकिन डिस्क के लिए कुछ भी नहीं लिखते हैं। यह हमें त्रुटि पर बनाए गए योगिनी खंड या DW_DLV_NOCOUNT की संख्या लौटाएगा। उसी समय, प्रत्येक खंड के लिए एक कॉलबैक फ़ंक्शन कहा जाएगा, जिसे हमने लाइब्रेरी को dwarf_producer_init_c फ़ंक्शन से प्रारंभ करते समय पारित किया था। हमें यह फ़ंक्शन स्वयं लिखना होगा। इसकी विशिष्टता इस प्रकार है:

 typedef int (*Dwarf_Callback_Func_c)( char* name, int size, Dwarf_Unsigned type, Dwarf_Unsigned flags, Dwarf_Unsigned link, Dwarf_Unsigned info, Dwarf_Unsigned* sect_name_index, void * user_data, int* error) 

• नाम - योगिनी अनुभाग का नाम बनाया जाना है
• आकार - अनुभाग आकार
• प्रकार - अनुभाग प्रकार
• झंडे - खंड झंडे
• लिंक - अनुभाग संचार क्षेत्र
• जानकारी - अनुभाग सूचना क्षेत्र
• sect_name_index - आपको स्थानांतरण (वैकल्पिक) के साथ अनुभाग के सूचकांक को वापस करने की आवश्यकता है
• user_data - हमें उसी तरह से पास किया गया जब हमने इसे लाइब्रेरी इनिशियलाइज़ेशन फंक्शन में सेट किया था
• एरर - यहां आप एरर कोड पास कर सकते हैं

इस कार्य में, हमें चाहिए:

• एक नया अनुभाग बनाएं (elf_newscn फ़ंक्शन, अनुभाग बनाना देखें)
• एक अनुभाग हेडर बनाएं (elf32_getshdr फ़ंक्शन, ibid।)
• इसे सही तरीके से भरें (देखें ibid।) यह सरल है, क्योंकि अनुभाग के हेडर फ़ील्ड हमारे फ़ंक्शन के मापदंडों के अनुरूप हैं। अनुपलब्ध फ़ील्ड्स sh_addr, sh_offset, sh_entsize 0 पर सेट, और sh_addralign 1 के लिए
• क्रिएट किए गए खंड (फ़ंक्शन elf_ndxscn का इंडेक्स, "सेक्शन .symtab") या -1 देखें यदि कोई त्रुटि हुई (त्रुटि कोड को त्रुटि में सेट करके)
• हमें फ़ंक्शन से लौटते समय ".rel" अनुभाग (हमारे मामले में) को 0 पर वापस छोड़ देना चाहिए

पूरा होने के बाद, dwarf_transform_to_disk_form फ़ंक्शन हमारे द्वारा बनाए गए अनुभागों की संख्या वापस कर देगा। हमें इन चरणों का पालन करते हुए प्रत्येक खंड के लिए 0 से एक चक्र से गुजरना होगा:

• बौने_get_section_bytes फ़ंक्शन के साथ अनुभाग में लिखने के लिए डेटा बनाएं:
  

   Dwarf_Ptr dwarf_get_section_bytes( Dwarf_P_Debug dbg, Dwarf_Signed dwarf_section, Dwarf_Signed *elf_section_index, Dwarf_Unsigned *length, Dwarf_Error* error) 

  
  
  • dwarf_section - अनुभाग संख्या। सीमा में होना चाहिए 0..n, जहाँ n को dwarf_transform_to_disk_form फ़ंक्शन द्वारा हमारे पास लौटाया गया
  • elf_section_index - डेटा लिखने के लिए उस अनुभाग का सूचकांक लौटाता है
  • लंबाई - इस डेटा की लंबाई
  • त्रुटि - उपयोग नहीं किया गया
  
  फ़ंक्शन प्राप्त डेटा या 0 (मामले में
  जब कोई अधिक अनुभाग बनाने के लिए नहीं होता है) के लिए एक पॉइंटर लौटाता है
• वर्तमान अनुभाग के लिए एक डेटा विवरणक बनाएं (elf_newdata फ़ंक्शन, अनुभाग बनाना देखें) और इसे भरें (ibid देखें) सेटिंग द्वारा:
  
  • d_buf - पिछले फ़ंक्शन से हमारे द्वारा प्राप्त आंकड़ों के सूचक
  • d_size - इस डेटा का आकार (ibid)
  
  

पुस्तकालय के साथ काम खत्म करना

अनुभागों के बन जाने के बाद, आप libdwarf फ़ंक्शन को बौना_प्रोड्यूसर_फिनिश समाप्त कर सकते हैं:

 Dwarf_Unsigned dwarf_producer_finish( Dwarf_P_Debug dbg, Dwarf_Error* error) 

फ़ंक्शन त्रुटि पर DW_DLV_NOCOUNT देता है।
मैं ध्यान देता हूं कि इस स्तर पर डिस्क पर लेखन नहीं किया जाता है। रिकॉर्डिंग "ईएलएफ - फाइल रिकॉर्डिंग बनाना" अनुभाग में फ़ंक्शन का उपयोग करके किया जाना चाहिए।

निष्कर्ष

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

संदर्भ

ELF

• विनिर्देश
• एआरएम आर्किटेक्चर के लिए ईएलएफ
• उदाहरण के लिए libELF
• elfutils
• कामचलाऊ आदमी पृष्ठों

बौना

• ofsayta
• मानक
• DWARF डिबगिंग प्रारूप का परिचय (माइकल जे। ईगर)
• libdwarf