1 // copyright (c) 2017-2021 hors<horsicq@gmail.com>
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 
10 // The above copyright notice and this permission notice shall be included in all
11 // copies or substantial portions of the Software.
12 
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 // SOFTWARE.
20 //
21 #ifndef XELF_H
22 #define XELF_H
23 
24 #include "xbinary.h"
25 #include "xelf_def.h"
26 
27 class XELF : public XBinary
28 {
29     Q_OBJECT
30 
31 public:
32     enum DS
33     {
34         DS_UNKNOWN,
35         DS_INTERPRETER,
36         DS_LIBRARIES,
37         DS_RUNPATH,
38         DS_NOTES,
39         DS_DYNAMICTAGS,
40         DS_STRINGTABLE,
41         DS_SYMBOLTABLE,
42         DS_RELA,
43         DS_REL
44     };
45 
46     struct NOTE
47     {
48         qint64 nOffset;
49         qint64 nSize;
50         quint32 nType;
51         QString sName;
52         qint64 nDataOffset;
53         qint64 nDataSize;
54     };
55 
56     struct TAG_STRUCT
57     {
58         qint64 nOffset;
59         qint64 nTag;
60         qint64 nValue;
61     };
62 
63     struct SECTION_RECORD
64     {
65         QString sName;
66         qint64 nOffset;
67         qint64 nSize;
68         qint64 nFlags;
69     };
70 
71     enum TYPE
72     {
73         TYPE_UNKNOWN=0,
74         TYPE_REL,
75         TYPE_EXEC,
76         TYPE_DYN,
77         TYPE_CORE,
78         TYPE_NUM
79     };
80 
81     XELF(QIODevice *pDevice=nullptr,bool bIsImage=false,qint64 nModuleAddress=-1);
82     ~XELF();
83 
84     virtual bool isValid();
85     static bool isValid(QIODevice *pDevice,bool bIsImage=false,qint64 nModuleAddress=-1);
86     static MODE getMode(QIODevice *pDevice,bool bIsImage=false,qint64 nModuleAddress=-1);
87     bool isBigEndian();
88 
89     qint64 getEhdrOffset();
90     qint64 getEhdr32Size();
91     qint64 getEhdr64Size();
92 
93     quint32 getIdent_Magic();
94     void setIdent_Magic(quint32 nValue);
95 
96     quint8 getIdent_mag(int nMag);
97     void setIdent_mag(quint8 nValue,int nMag);
98 
99     quint32 getIdent_mag_LE();
100     void setIdent_mag_LE(quint32 nValue);
101 
102     quint8 getIdent_class();
103     void setIdent_class(quint8 nValue);
104     quint8 getIdent_data();
105     void setIdent_data(quint8 nValue);
106     quint8 getIdent_version();
107     void setIdent_version(quint8 nValue);
108 
109     quint8 getIdent_osabi();
110     void setIdent_osabi(quint8 nValue);
111     quint8 getIdent_abiversion();
112     void setIdent_abiversion(quint8 nValue);
113 
114     quint8 getIdent_pad(int nPad);
115     void setIdent_pad(quint8 nValue,int nPad);
116 
117     // TODO Hdr32 getHdr32();
118     // TODO Hdr64 getHdr64();
119     quint16 getHdr32_type();
120     void setHdr32_type(quint16 nValue);
121     quint16 getHdr32_machine();
122     void setHdr32_machine(quint16 nValue);
123     quint32 getHdr32_version();
124     void setHdr32_version(quint32 nValue);
125     quint32 getHdr32_entry();
126     void setHdr32_entry(quint32 nValue);
127     quint32 getHdr32_phoff();
128     void setHdr32_phoff(quint32 nValue);
129     quint32 getHdr32_shoff();
130     void setHdr32_shoff(quint32 nValue);
131     quint32 getHdr32_flags();
132     void setHdr32_flags(quint32 nValue);
133     quint16 getHdr32_ehsize();
134     void setHdr32_ehsize(quint16 nValue);
135     quint16 getHdr32_phentsize();
136     void setHdr32_phentsize(quint16 nValue);
137     quint16 getHdr32_phnum();
138     void setHdr32_phnum(quint16 nValue);
139     quint16 getHdr32_shentsize();
140     void setHdr32_shentsize(quint16 nValue);
141     quint16 getHdr32_shnum();
142     void setHdr32_shnum(quint16 nValue);
143     quint16 getHdr32_shstrndx();
144     void setHdr32_shstrndx(quint16 nValue);
145 
146     quint16 getHdr64_type();
147     void setHdr64_type(quint16 nValue);
148     quint16 getHdr64_machine();
149     void setHdr64_machine(quint16 nValue);
150     quint32 getHdr64_version();
151     void setHdr64_version(quint32 nValue);
152     quint64 getHdr64_entry();
153     void setHdr64_entry(quint64 nValue);
154     quint64 getHdr64_phoff();
155     void setHdr64_phoff(quint64 nValue);
156     quint64 getHdr64_shoff();
157     void setHdr64_shoff(quint64 nValue);
158     quint32 getHdr64_flags();
159     void setHdr64_flags(quint32 nValue);
160     quint16 getHdr64_ehsize();
161     void setHdr64_ehsize(quint16 nValue);
162     quint16 getHdr64_phentsize();
163     void setHdr64_phentsize(quint16 nValue);
164     quint16 getHdr64_phnum();
165     void setHdr64_phnum(quint16 nValue);
166     quint16 getHdr64_shentsize();
167     void setHdr64_shentsize(quint16 nValue);
168     quint16 getHdr64_shnum();
169     void setHdr64_shnum(quint16 nValue);
170     quint16 getHdr64_shstrndx();
171     void setHdr64_shstrndx(quint16 nValue);
172 
173     XELF_DEF::Elf_Ehdr getHdr();
174 
175     static QMap<quint64,QString> getHeaderVersionList();
176 
177     static QMap<quint64,QString> getIndentMag();
178     static QMap<quint64,QString> getIndentMagS();
179     static QMap<quint64,QString> getIndentClasses();
180     static QMap<quint64,QString> getIndentClassesS();
181     static QMap<quint64,QString> getIndentDatas();
182     static QMap<quint64,QString> getIndentDatasS();
183     static QMap<quint64,QString> getIndentVersions();
184     static QMap<quint64,QString> getIndentVersionsS();
185     static QMap<quint64,QString> getIndentOsabis();
186     static QMap<quint64,QString> getIndentOsabisS();
187 
188     static QMap<quint64,QString> getTypes();
189     static QMap<quint64,QString> getTypesS();
190     static QMap<quint64,QString> getMachines();
191     static QMap<quint64,QString> getMachinesS();
192 
193     static QMap<quint64,QString> getSectionTypes();
194     static QMap<quint64,QString> getSectionTypesS();
195     static QMap<quint64,QString> getSectionFlags();
196     static QMap<quint64,QString> getSectionFlagsS();
197 
198     static QMap<quint64,QString> getProgramTypes();
199     static QMap<quint64,QString> getProgramTypesS();
200     static QMap<quint64,QString> getProgramFlags();
201     static QMap<quint64,QString> getProgramFlagsS();
202 
203     static QMap<quint64,QString> getDynamicTags();
204     static QMap<quint64,QString> getDynamicTagsS();
205 
206     // TODO more
207     static QMap<quint64,QString> getRelTypes_x86();
208     static QMap<quint64,QString> getRelTypesS_x86();
209     static QMap<quint64,QString> getRelTypes_x64();
210     static QMap<quint64,QString> getRelTypesS_x64();
211     static QMap<quint64,QString> getRelTypes_SPARC();
212     static QMap<quint64,QString> getRelTypesS_SPARC();
213 
214     static QMap<quint64,QString> getStBinds();
215     static QMap<quint64,QString> getStBindsS();
216     static QMap<quint64,QString> getStTypes();
217     static QMap<quint64,QString> getStTypesS();
218 
219     quint16 getSectionStringTable();
220     quint16 getSectionStringTable(bool bIs64);
221 
222     OFFSETSIZE getSectionOffsetSize(quint32 nSection);
223 
224     QMap<quint32,QString> getStringsFromSection(quint32 nSection);
225     QMap<quint32,QString> getStringsFromSectionData(QByteArray *pbaData);
226     QString getStringFromSection(quint32 nIndex,quint32 nSection);
227     QMap<quint32,QString> getStringsFromMainSection();
228     QString getStringFromMainSection(quint32 nIndex);
229     QByteArray getSection(quint32 nIndex);
230     bool isSectionValid(quint32 nIndex);
231 
232     QList<XELF_DEF::Elf32_Shdr> getElf32_ShdrList();
233     QList<XELF_DEF::Elf64_Shdr> getElf64_ShdrList();
234     QList<XELF_DEF::Elf_Shdr> getElf_ShdrList();
235 
236     XELF_DEF::Elf32_Shdr getElf32_Shdr(quint32 nIndex);
237     XELF_DEF::Elf64_Shdr getElf64_Shdr(quint32 nIndex);
238 
239     XELF_DEF::Elf32_Shdr _readElf32_Shdr(qint64 nOffset,bool bIsBigEndian);
240     XELF_DEF::Elf64_Shdr _readElf64_Shdr(qint64 nOffset,bool bIsBigEndian);
241 
242     quint32 getElf32_Shdr_name(quint32 nIndex);
243     quint32 getElf32_Shdr_type(quint32 nIndex);
244     quint32 getElf32_Shdr_flags(quint32 nIndex);
245     quint32 getElf32_Shdr_addr(quint32 nIndex);
246     quint32 getElf32_Shdr_offset(quint32 nIndex);
247     quint32 getElf32_Shdr_size(quint32 nIndex);
248     quint32 getElf32_Shdr_link(quint32 nIndex);
249     quint32 getElf32_Shdr_info(quint32 nIndex);
250     quint32 getElf32_Shdr_addralign(quint32 nIndex);
251     quint32 getElf32_Shdr_entsize(quint32 nIndex);
252 
253     void setElf32_Shdr_name(quint32 nIndex,quint32 nValue);
254     void setElf32_Shdr_type(quint32 nIndex,quint32 nValue);
255     void setElf32_Shdr_flags(quint32 nIndex,quint32 nValue);
256     void setElf32_Shdr_addr(quint32 nIndex,quint32 nValue);
257     void setElf32_Shdr_offset(quint32 nIndex,quint32 nValue);
258     void setElf32_Shdr_size(quint32 nIndex,quint32 nValue);
259     void setElf32_Shdr_link(quint32 nIndex,quint32 nValue);
260     void setElf32_Shdr_info(quint32 nIndex,quint32 nValue);
261     void setElf32_Shdr_addralign(quint32 nIndex,quint32 nValue);
262     void setElf32_Shdr_entsize(quint32 nIndex,quint32 nValue);
263 
264     quint32 getElf64_Shdr_name(quint32 nIndex);
265     quint32 getElf64_Shdr_type(quint32 nIndex);
266     quint64 getElf64_Shdr_flags(quint32 nIndex);
267     quint64 getElf64_Shdr_addr(quint32 nIndex);
268     quint64 getElf64_Shdr_offset(quint32 nIndex);
269     quint64 getElf64_Shdr_size(quint32 nIndex);
270     quint32 getElf64_Shdr_link(quint32 nIndex);
271     quint32 getElf64_Shdr_info(quint32 nIndex);
272     quint64 getElf64_Shdr_addralign(quint32 nIndex);
273     quint64 getElf64_Shdr_entsize(quint32 nIndex);
274 
275     void setElf64_Shdr_name(quint32 nIndex,quint32 nValue);
276     void setElf64_Shdr_type(quint32 nIndex,quint32 nValue);
277     void setElf64_Shdr_flags(quint32 nIndex,quint64 nValue);
278     void setElf64_Shdr_addr(quint32 nIndex,quint64 nValue);
279     void setElf64_Shdr_offset(quint32 nIndex,quint64 nValue);
280     void setElf64_Shdr_size(quint32 nIndex,quint64 nValue);
281     void setElf64_Shdr_link(quint32 nIndex,quint32 nValue);
282     void setElf64_Shdr_info(quint32 nIndex,quint32 nValue);
283     void setElf64_Shdr_addralign(quint32 nIndex,quint64 nValue);
284     void setElf64_Shdr_entsize(quint32 nIndex,quint64 nValue);
285 
286     quint32 getElf_Shdr_name(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
287     quint32 getElf_Shdr_type(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
288     quint64 getElf_Shdr_flags(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
289     quint64 getElf_Shdr_addr(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
290     quint64 getElf_Shdr_offset(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
291     quint64 getElf_Shdr_size(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
292     quint32 getElf_Shdr_link(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
293     quint32 getElf_Shdr_info(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
294     quint64 getElf_Shdr_addralign(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
295     quint64 getElf_Shdr_entsize(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
296 
297     qint64 getShdrOffset(quint32 nIndex);
298     qint64 getShdrSize();
299 
300     QList<XELF_DEF::Elf32_Phdr> getElf32_PhdrList();
301     QList<XELF_DEF::Elf64_Phdr> getElf64_PhdrList();
302     QList<XELF_DEF::Elf_Phdr> getElf_PhdrList();
303 
304     XELF_DEF::Elf32_Phdr getElf32_Phdr(quint32 nIndex);
305     XELF_DEF::Elf64_Phdr getElf64_Phdr(quint32 nIndex);
306 
307     XELF_DEF::Elf32_Phdr _readElf32_Phdr(qint64 nOffset,bool bIsBigEndian);
308     XELF_DEF::Elf64_Phdr _readElf64_Phdr(qint64 nOffset,bool bIsBigEndian);
309 
310     quint32 getElf32_Phdr_type(quint32 nIndex);
311     quint32 getElf32_Phdr_offset(quint32 nIndex);
312     quint32 getElf32_Phdr_vaddr(quint32 nIndex);
313     quint32 getElf32_Phdr_paddr(quint32 nIndex);
314     quint32 getElf32_Phdr_filesz(quint32 nIndex);
315     quint32 getElf32_Phdr_memsz(quint32 nIndex);
316     quint32 getElf32_Phdr_flags(quint32 nIndex);
317     quint32 getElf32_Phdr_align(quint32 nIndex);
318 
319     void setElf32_Phdr_type(quint32 nIndex,quint32 nValue);
320     void setElf32_Phdr_offset(quint32 nIndex,quint32 nValue);
321     void setElf32_Phdr_vaddr(quint32 nIndex,quint32 nValue);
322     void setElf32_Phdr_paddr(quint32 nIndex,quint32 nValue);
323     void setElf32_Phdr_filesz(quint32 nIndex,quint32 nValue);
324     void setElf32_Phdr_memsz(quint32 nIndex,quint32 nValue);
325     void setElf32_Phdr_flags(quint32 nIndex,quint32 nValue);
326     void setElf32_Phdr_align(quint32 nIndex,quint32 nValue);
327 
328     quint32 getElf64_Phdr_type(quint32 nIndex);
329     quint64 getElf64_Phdr_offset(quint32 nIndex);
330     quint64 getElf64_Phdr_vaddr(quint32 nIndex);
331     quint64 getElf64_Phdr_paddr(quint32 nIndex);
332     quint64 getElf64_Phdr_filesz(quint32 nIndex);
333     quint64 getElf64_Phdr_memsz(quint32 nIndex);
334     quint32 getElf64_Phdr_flags(quint32 nIndex);
335     quint64 getElf64_Phdr_align(quint32 nIndex);
336 
337     void setElf64_Phdr_type(quint32 nIndex,quint32 nValue);
338     void setElf64_Phdr_offset(quint32 nIndex,quint64 nValue);
339     void setElf64_Phdr_vaddr(quint32 nIndex,quint64 nValue);
340     void setElf64_Phdr_paddr(quint32 nIndex,quint64 nValue);
341     void setElf64_Phdr_filesz(quint32 nIndex,quint64 nValue);
342     void setElf64_Phdr_memsz(quint32 nIndex,quint64 nValue);
343     void setElf64_Phdr_flags(quint32 nIndex,quint32 nValue);
344     void setElf64_Phdr_align(quint32 nIndex,quint64 nValue);
345 
346     quint32 getElf_Phdr_type(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
347     quint64 getElf_Phdr_offset(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
348     quint64 getElf_Phdr_vaddr(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
349     quint64 getElf_Phdr_paddr(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
350     quint64 getElf_Phdr_filesz(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
351     quint64 getElf_Phdr_memsz(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
352     quint32 getElf_Phdr_flags(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
353     quint64 getElf_Phdr_align(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
354 
355     qint64 getPhdrOffset(quint32 nIndex);
356     qint64 getPhdrSize();
357 
358     int getSectionIndexByName(QString sSectionName);
359     QByteArray getSectionByName(QString sSectionName);
360 
361     OS_ANSISTRING getProgramInterpreterName();
362     OS_ANSISTRING getProgramInterpreterName(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
363 
364     QList<QString> getCommentStrings();
365     QList<QString> getCommentStrings(int nSection);
366 
367     QList<NOTE> getNotes();
368     QList<NOTE> getNotes(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
369     QList<NOTE> _getNotes(qint64 nOffset,qint64 nSize,bool bIsBigEndian);
370     NOTE _readNote(qint64 nOffset,qint64 nSize,bool bIsBigEndian);
371 
372     static bool isNotePresent(QList<NOTE> *pListNotes,QString sName);
373     static NOTE getNote(QList<NOTE> *pListNotes,QString sName);
374 
375     QList<TAG_STRUCT> getTagStructs();
376     QList<TAG_STRUCT> getTagStructs(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders,_MEMORY_MAP *pMemoryMap);
377     QList<TAG_STRUCT> _getTagStructs(qint64 nOffset,qint64 nSize,bool bIs64,bool bIsBigEndian);
378 
379     static QList<TAG_STRUCT> _getTagStructs(QList<TAG_STRUCT> *pListTagStructs,qint64 nTag);
380 
381     qint64 getDynamicArraySize();
382 
383     qint64 getDynamicArrayTag(qint64 nOffset);
384     qint64 getDynamicArrayValue(qint64 nOffset);
385 
386     void setDynamicArrayTag(qint64 nOffset,qint64 nValue);
387     void setDynamicArrayValue(qint64 nOffset,qint64 nValue);
388 
389     OFFSETSIZE getStringTable();
390     OFFSETSIZE getStringTable(_MEMORY_MAP *pMemoryMap,QList<TAG_STRUCT> *pListTagStructs);
391 
392     QList<QString> getLibraries();
393     QList<QString> getLibraries(_MEMORY_MAP *pMemoryMap,QList<TAG_STRUCT> *pListTagStructs);
394 
395     OS_ANSISTRING getRunPath();
396     OS_ANSISTRING getRunPath(_MEMORY_MAP *pMemoryMap,QList<TAG_STRUCT> *pListTagStructs);
397 
398     virtual _MEMORY_MAP getMemoryMap();
399     virtual qint64 getEntryPointOffset(_MEMORY_MAP *pMemoryMap);
400 
401     static QList<SECTION_RECORD> getSectionRecords(QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders,bool bIsImage,QByteArray *pbaSectionTable);
402     bool isSectionNamePresent(QString sSectionName);
403     static bool isSectionNamePresent(QString sSectionName,QList<SECTION_RECORD> *pListSectionRecords);
404     qint32 getSectionNumber(QString sSectionName);
405     static qint32 getSectionNumber(QString sSectionName,QList<SECTION_RECORD> *pListSectionRecords);
406     static SECTION_RECORD getSectionRecord(QString sSectionName,QList<SECTION_RECORD> *pListSectionRecords);
407 
408     virtual MODE getMode();
409     virtual QString getArch();
410     virtual int getType();
411     virtual FT getFileType();
412     virtual QString typeIdToString(int nType);
413 
414     virtual qint64 getBaseAddress();
415 
416     QList<XELF_DEF::Elf_Phdr> _getPrograms(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders,quint32 nType);
417 
418     QList<DATASET> getDatasetsFromSections(QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders);
419     QList<DATASET> getDatasetsFromPrograms(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders);
420     QList<DATASET> getDatasetsFromTagStructs(_MEMORY_MAP *pMemoryMap,QList<TAG_STRUCT> *pListTagStructs);
421 
422     QList<XELF_DEF::Elf32_Sym> getElf32_SymList(qint64 nOffset,qint64 nSize);
423     QList<XELF_DEF::Elf64_Sym> getElf64_SymList(qint64 nOffset,qint64 nSize);
424 
425     XELF_DEF::Elf32_Sym _readElf32_Sym(qint64 nOffset,bool bIsBigEndian);
426     XELF_DEF::Elf64_Sym _readElf64_Sym(qint64 nOffset,bool bIsBigEndian);
427 
428     void setElf32_Sym_st_name(qint64 nOffset,quint32 nValue,bool bIsBigEndian);
429     void setElf32_Sym_st_value(qint64 nOffset,quint32 nValue,bool bIsBigEndian);
430     void setElf32_Sym_st_size(qint64 nOffset,quint32 nValue,bool bIsBigEndian);
431     void setElf32_Sym_st_info(qint64 nOffset,quint8 nValue);
432     void setElf32_Sym_st_other(qint64 nOffset,quint8 nValue);
433     void setElf32_Sym_st_shndx(qint64 nOffset,quint16 nValue,bool bIsBigEndian);
434 
435     void setElf64_Sym_st_name(qint64 nOffset,quint32 nValue,bool bIsBigEndian);
436     void setElf64_Sym_st_info(qint64 nOffset,quint8 nValue);
437     void setElf64_Sym_st_other(qint64 nOffset,quint8 nValue);
438     void setElf64_Sym_st_shndx(qint64 nOffset,quint16 nValue,bool bIsBigEndian);
439     void setElf64_Sym_st_value(qint64 nOffset,quint64 nValue,bool bIsBigEndian);
440     void setElf64_Sym_st_size(qint64 nOffset,quint64 nValue,bool bIsBigEndian);
441 
442     qint64 getSymSize();
443 
444     qint64 getSymTableSize(qint64 nOffset);
445 
446     XELF_DEF::Elf32_Rel _readElf32_Rel(qint64 nOffset,bool bIsBigEndian);
447     XELF_DEF::Elf64_Rel _readElf64_Rel(qint64 nOffset,bool bIsBigEndian);
448     XELF_DEF::Elf32_Rela _readElf32_Rela(qint64 nOffset,bool bIsBigEndian);
449     XELF_DEF::Elf64_Rela _readElf64_Rela(qint64 nOffset,bool bIsBigEndian);
450 
451     QList<XELF_DEF::Elf32_Rel> getElf32_RelList(qint64 nOffset,qint64 nSize);
452     QList<XELF_DEF::Elf64_Rel> getElf64_RelList(qint64 nOffset,qint64 nSize);
453 
454     QList<XELF_DEF::Elf32_Rela> getElf32_RelaList(qint64 nOffset,qint64 nSize);
455     QList<XELF_DEF::Elf64_Rela> getElf64_RelaList(qint64 nOffset,qint64 nSize);
456 
457     void setElf32_Rel_r_offset(qint64 nOffset,quint32 nValue,bool bIsBigEndian);
458     void setElf32_Rel_r_info(qint64 nOffset,quint32 nValue,bool bIsBigEndian);
459 
460     void setElf64_Rel_r_offset(qint64 nOffset,quint64 nValue,bool bIsBigEndian);
461     void setElf64_Rel_r_info(qint64 nOffset,quint64 nValue,bool bIsBigEndian);
462 
463     void setElf32_Rela_r_offset(qint64 nOffset,quint32 nValue,bool bIsBigEndian);
464     void setElf32_Rela_r_info(qint64 nOffset,quint32 nValue,bool bIsBigEndian);
465     void setElf32_Rela_r_addend(qint64 nOffset,quint32 nValue,bool bIsBigEndian);
466 
467     void setElf64_Rela_r_offset(qint64 nOffset,quint64 nValue,bool bIsBigEndian);
468     void setElf64_Rela_r_info(qint64 nOffset,quint64 nValue,bool bIsBigEndian);
469     void setElf64_Rela_r_addend(qint64 nOffset,quint64 nValue,bool bIsBigEndian);
470 
471     quint16 getNumberOfSections();
472     quint16 getNumberOfPrograms();
473 
474     bool isSectionsTablePresent();
475     bool isProgramsTablePresent();
476 };
477 
478 #endif // XELF_H
479