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 #include "xelf.h"
22
XELF(QIODevice * pDevice,bool bIsImage,qint64 nModuleAddress)23 XELF::XELF(QIODevice *pDevice, bool bIsImage, qint64 nModuleAddress): XBinary(pDevice,bIsImage,nModuleAddress)
24 {
25 }
26
~XELF()27 XELF::~XELF()
28 {
29 }
30
isValid()31 bool XELF::isValid()
32 {
33 bool bResult=false;
34
35 if(getIdent_Magic()== XELF_DEF::ELFMAG)
36 {
37 quint8 nClass=getIdent_class();
38
39 if((nClass== XELF_DEF::ELFCLASS32)||(nClass== XELF_DEF::ELFCLASS64))
40 {
41 bResult=true;
42 }
43 }
44
45 return bResult;
46 }
47
isValid(QIODevice * pDevice,bool bIsImage,qint64 nModuleAddress)48 bool XELF::isValid(QIODevice *pDevice, bool bIsImage, qint64 nModuleAddress)
49 {
50 XELF xelf(pDevice,bIsImage,nModuleAddress);
51
52 return xelf.isValid();
53 }
54
getMode(QIODevice * pDevice,bool bIsImage,qint64 nModuleAddress)55 XBinary::MODE XELF::getMode(QIODevice *pDevice, bool bIsImage, qint64 nModuleAddress)
56 {
57 XELF xelf(pDevice,bIsImage,nModuleAddress);
58
59 return xelf.getMode();
60 }
61
isBigEndian()62 bool XELF::isBigEndian()
63 {
64 return getIdent_data()== XELF_DEF::ELFDATA2MSB;
65 }
66
getEhdrOffset()67 qint64 XELF::getEhdrOffset()
68 {
69 return 0;
70 }
71
getEhdr32Size()72 qint64 XELF::getEhdr32Size()
73 {
74 return sizeof(XELF_DEF::Elf32_Ehdr);
75 }
76
getEhdr64Size()77 qint64 XELF::getEhdr64Size()
78 {
79 return sizeof(XELF_DEF::Elf64_Ehdr);
80 }
81
getIdent_Magic()82 quint32 XELF::getIdent_Magic()
83 {
84 return read_uint32((quint64) XELF_DEF::EI_MAG0);
85 }
86
setIdent_Magic(quint32 nValue)87 void XELF::setIdent_Magic(quint32 nValue)
88 {
89 write_uint32((quint64) XELF_DEF::EI_MAG0,nValue);
90 }
91
getIdent_mag(int nMag)92 quint8 XELF::getIdent_mag(int nMag)
93 {
94 quint8 nValue=0;
95
96 if(nMag<4)
97 {
98 nValue=read_uint8(nMag);
99 }
100
101 return nValue;
102 }
103
setIdent_mag(quint8 nValue,int nMag)104 void XELF::setIdent_mag(quint8 nValue, int nMag)
105 {
106 if(nMag<4)
107 {
108 write_uint8(nMag,nValue);
109 }
110 }
111
getIdent_mag_LE()112 quint32 XELF::getIdent_mag_LE()
113 {
114 return read_uint32(0,false);
115 }
116
setIdent_mag_LE(quint32 nValue)117 void XELF::setIdent_mag_LE(quint32 nValue)
118 {
119 write_uint32(0,nValue,false);
120 }
121
getIdent_class()122 quint8 XELF::getIdent_class()
123 {
124 return read_uint8( XELF_DEF::EI_CLASS);
125 }
126
setIdent_class(quint8 nValue)127 void XELF::setIdent_class(quint8 nValue)
128 {
129 write_uint8( XELF_DEF::EI_CLASS,nValue);
130 }
131
getIdent_data()132 quint8 XELF::getIdent_data()
133 {
134 return read_uint8( XELF_DEF::EI_DATA);
135 }
136
setIdent_data(quint8 nValue)137 void XELF::setIdent_data(quint8 nValue)
138 {
139 write_uint8( XELF_DEF::EI_DATA,nValue);
140 }
141
getIdent_version()142 quint8 XELF::getIdent_version()
143 {
144 return read_uint8( XELF_DEF::EI_VERSION);
145 }
146
setIdent_version(quint8 nValue)147 void XELF::setIdent_version(quint8 nValue)
148 {
149 write_uint8( XELF_DEF::EI_VERSION,nValue);
150 }
151
getIdent_osabi()152 quint8 XELF::getIdent_osabi()
153 {
154 return read_uint8( XELF_DEF::EI_OSABI);
155 }
156
setIdent_osabi(quint8 nValue)157 void XELF::setIdent_osabi(quint8 nValue)
158 {
159 write_uint8( XELF_DEF::EI_OSABI,nValue);
160 }
161
getIdent_abiversion()162 quint8 XELF::getIdent_abiversion()
163 {
164 return read_uint8( XELF_DEF::EI_ABIVERSION);
165 }
166
setIdent_abiversion(quint8 nValue)167 void XELF::setIdent_abiversion(quint8 nValue)
168 {
169 write_uint8( XELF_DEF::EI_ABIVERSION,nValue);
170 }
171
getIdent_pad(int nPad)172 quint8 XELF::getIdent_pad(int nPad)
173 {
174 quint8 nValue=0;
175
176 if(nPad<7)
177 {
178 nValue=read_uint8( XELF_DEF::EI_ABIVERSION+1+nPad);
179 }
180
181 return nValue;
182 }
183
setIdent_pad(quint8 nValue,int nPad)184 void XELF::setIdent_pad(quint8 nValue, int nPad)
185 {
186 if(nPad<7)
187 {
188 write_uint8( XELF_DEF::EI_ABIVERSION+1+nPad,nValue);
189 }
190 }
191
getHdr32_type()192 quint16 XELF::getHdr32_type()
193 {
194 return read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_type),isBigEndian());
195 }
196
setHdr32_type(quint16 nValue)197 void XELF::setHdr32_type(quint16 nValue)
198 {
199 write_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_type),nValue,isBigEndian());
200 }
201
getHdr32_machine()202 quint16 XELF::getHdr32_machine()
203 {
204 return read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_machine),isBigEndian());
205 }
206
setHdr32_machine(quint16 nValue)207 void XELF::setHdr32_machine(quint16 nValue)
208 {
209 write_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_machine),nValue,isBigEndian());
210 }
211
getHdr32_version()212 quint32 XELF::getHdr32_version()
213 {
214 return read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_version),isBigEndian());
215 }
216
setHdr32_version(quint32 nValue)217 void XELF::setHdr32_version(quint32 nValue)
218 {
219 write_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_version),nValue,isBigEndian());
220 }
221
getHdr32_entry()222 quint32 XELF::getHdr32_entry()
223 {
224 return read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_entry),isBigEndian());
225 }
226
setHdr32_entry(quint32 nValue)227 void XELF::setHdr32_entry(quint32 nValue)
228 {
229 write_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_entry),nValue,isBigEndian());
230 }
231
getHdr32_phoff()232 quint32 XELF::getHdr32_phoff()
233 {
234 return read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_phoff),isBigEndian());
235 }
236
setHdr32_phoff(quint32 nValue)237 void XELF::setHdr32_phoff(quint32 nValue)
238 {
239 write_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_phoff),nValue,isBigEndian());
240 }
241
getHdr32_shoff()242 quint32 XELF::getHdr32_shoff()
243 {
244 return read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_shoff),isBigEndian());
245 }
246
setHdr32_shoff(quint32 nValue)247 void XELF::setHdr32_shoff(quint32 nValue)
248 {
249 write_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_shoff),nValue,isBigEndian());
250 }
251
getHdr32_flags()252 quint32 XELF::getHdr32_flags()
253 {
254 return read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_flags),isBigEndian());
255 }
256
setHdr32_flags(quint32 nValue)257 void XELF::setHdr32_flags(quint32 nValue)
258 {
259 write_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_flags),nValue,isBigEndian());
260 }
261
getHdr32_ehsize()262 quint16 XELF::getHdr32_ehsize()
263 {
264 return read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_ehsize),isBigEndian());
265 }
266
setHdr32_ehsize(quint16 nValue)267 void XELF::setHdr32_ehsize(quint16 nValue)
268 {
269 write_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_ehsize),nValue,isBigEndian());
270 }
271
getHdr32_phentsize()272 quint16 XELF::getHdr32_phentsize()
273 {
274 return read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_phentsize),isBigEndian());
275 }
276
setHdr32_phentsize(quint16 nValue)277 void XELF::setHdr32_phentsize(quint16 nValue)
278 {
279 write_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_phentsize),nValue,isBigEndian());
280 }
281
getHdr32_phnum()282 quint16 XELF::getHdr32_phnum()
283 {
284 return read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_phnum),isBigEndian());
285 }
286
setHdr32_phnum(quint16 nValue)287 void XELF::setHdr32_phnum(quint16 nValue)
288 {
289 write_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_phnum),nValue,isBigEndian());
290 }
291
getHdr32_shentsize()292 quint16 XELF::getHdr32_shentsize()
293 {
294 return read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_shentsize),isBigEndian());
295 }
296
setHdr32_shentsize(quint16 nValue)297 void XELF::setHdr32_shentsize(quint16 nValue)
298 {
299 write_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_shentsize),nValue,isBigEndian());
300 }
301
getHdr32_shnum()302 quint16 XELF::getHdr32_shnum()
303 {
304 return read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_shnum),isBigEndian());
305 }
306
setHdr32_shnum(quint16 nValue)307 void XELF::setHdr32_shnum(quint16 nValue)
308 {
309 write_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_shnum),nValue,isBigEndian());
310 }
311
getHdr32_shstrndx()312 quint16 XELF::getHdr32_shstrndx()
313 {
314 return read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_shstrndx),isBigEndian());
315 }
316
setHdr32_shstrndx(quint16 nValue)317 void XELF::setHdr32_shstrndx(quint16 nValue)
318 {
319 write_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_shstrndx),nValue,isBigEndian());
320 }
321
getHdr64_type()322 quint16 XELF::getHdr64_type()
323 {
324 return read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_type),isBigEndian());
325 }
326
setHdr64_type(quint16 nValue)327 void XELF::setHdr64_type(quint16 nValue)
328 {
329 write_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_type),nValue,isBigEndian());
330 }
331
getHdr64_machine()332 quint16 XELF::getHdr64_machine()
333 {
334 return read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_machine),isBigEndian());
335 }
336
setHdr64_machine(quint16 nValue)337 void XELF::setHdr64_machine(quint16 nValue)
338 {
339 write_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_machine),nValue,isBigEndian());
340 }
341
getHdr64_version()342 quint32 XELF::getHdr64_version()
343 {
344 return read_uint32(offsetof(XELF_DEF::Elf64_Ehdr,e_version),isBigEndian());
345 }
346
setHdr64_version(quint32 nValue)347 void XELF::setHdr64_version(quint32 nValue)
348 {
349 write_uint32(offsetof(XELF_DEF::Elf64_Ehdr,e_version),nValue,isBigEndian());
350 }
351
getHdr64_entry()352 quint64 XELF::getHdr64_entry()
353 {
354 return read_uint64(offsetof(XELF_DEF::Elf64_Ehdr,e_entry),isBigEndian());
355 }
356
setHdr64_entry(quint64 nValue)357 void XELF::setHdr64_entry(quint64 nValue)
358 {
359 write_uint64(offsetof(XELF_DEF::Elf64_Ehdr,e_entry),nValue,isBigEndian());
360 }
361
getHdr64_phoff()362 quint64 XELF::getHdr64_phoff()
363 {
364 return read_uint64(offsetof(XELF_DEF::Elf64_Ehdr,e_phoff),isBigEndian());
365 }
366
setHdr64_phoff(quint64 nValue)367 void XELF::setHdr64_phoff(quint64 nValue)
368 {
369 write_uint64(offsetof(XELF_DEF::Elf64_Ehdr,e_phoff),nValue,isBigEndian());
370 }
371
getHdr64_shoff()372 quint64 XELF::getHdr64_shoff()
373 {
374 return read_uint64(offsetof(XELF_DEF::Elf64_Ehdr,e_shoff),isBigEndian());
375 }
376
setHdr64_shoff(quint64 nValue)377 void XELF::setHdr64_shoff(quint64 nValue)
378 {
379 write_uint64(offsetof(XELF_DEF::Elf64_Ehdr,e_shoff),nValue,isBigEndian());
380 }
381
getHdr64_flags()382 quint32 XELF::getHdr64_flags()
383 {
384 return read_uint32(offsetof(XELF_DEF::Elf64_Ehdr,e_flags),isBigEndian());
385 }
386
setHdr64_flags(quint32 nValue)387 void XELF::setHdr64_flags(quint32 nValue)
388 {
389 write_uint32(offsetof(XELF_DEF::Elf64_Ehdr,e_flags),nValue,isBigEndian());
390 }
391
getHdr64_ehsize()392 quint16 XELF::getHdr64_ehsize()
393 {
394 return read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_ehsize),isBigEndian());
395 }
396
setHdr64_ehsize(quint16 nValue)397 void XELF::setHdr64_ehsize(quint16 nValue)
398 {
399 write_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_ehsize),nValue,isBigEndian());
400 }
401
getHdr64_phentsize()402 quint16 XELF::getHdr64_phentsize()
403 {
404 return read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_phentsize),isBigEndian());
405 }
406
setHdr64_phentsize(quint16 nValue)407 void XELF::setHdr64_phentsize(quint16 nValue)
408 {
409 write_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_phentsize),nValue,isBigEndian());
410 }
411
getHdr64_phnum()412 quint16 XELF::getHdr64_phnum()
413 {
414 return read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_phnum),isBigEndian());
415 }
416
setHdr64_phnum(quint16 nValue)417 void XELF::setHdr64_phnum(quint16 nValue)
418 {
419 write_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_phnum),nValue,isBigEndian());
420 }
421
getHdr64_shentsize()422 quint16 XELF::getHdr64_shentsize()
423 {
424 return read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_shentsize),isBigEndian());
425 }
426
setHdr64_shentsize(quint16 nValue)427 void XELF::setHdr64_shentsize(quint16 nValue)
428 {
429 write_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_shentsize),nValue,isBigEndian());
430 }
431
getHdr64_shnum()432 quint16 XELF::getHdr64_shnum()
433 {
434 return read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_shnum),isBigEndian());
435 }
436
setHdr64_shnum(quint16 nValue)437 void XELF::setHdr64_shnum(quint16 nValue)
438 {
439 write_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_shnum),nValue,isBigEndian());
440 }
441
getHdr64_shstrndx()442 quint16 XELF::getHdr64_shstrndx()
443 {
444 return read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_shstrndx),isBigEndian());
445 }
446
setHdr64_shstrndx(quint16 nValue)447 void XELF::setHdr64_shstrndx(quint16 nValue)
448 {
449 write_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_shstrndx),nValue,isBigEndian());
450 }
451
getHdr()452 XELF_DEF::Elf_Ehdr XELF::getHdr()
453 {
454 XELF_DEF::Elf_Ehdr result={};
455
456 bool bIsbigEndian=isBigEndian();
457
458 if(!is64())
459 {
460 result.e_type=read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_type),bIsbigEndian);
461 result.e_machine=read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_machine),bIsbigEndian);
462 result.e_version=read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_version),bIsbigEndian);
463 result.e_entry=read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_entry),bIsbigEndian);
464 result.e_phoff=read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_phoff),bIsbigEndian);
465 result.e_shoff=read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_shoff),bIsbigEndian);
466 result.e_flags=read_uint32(offsetof(XELF_DEF::Elf32_Ehdr,e_flags),bIsbigEndian);
467 result.e_ehsize=read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_ehsize),bIsbigEndian);
468 result.e_phentsize=read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_phentsize),bIsbigEndian);
469 result.e_phnum=read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_phnum),bIsbigEndian);
470 result.e_shentsize=read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_shentsize),bIsbigEndian);
471 result.e_shnum=read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_shnum),bIsbigEndian);
472 result.e_shstrndx=read_uint16(offsetof(XELF_DEF::Elf32_Ehdr,e_shstrndx),bIsbigEndian);
473 }
474 else
475 {
476 result.e_type=read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_type),bIsbigEndian);
477 result.e_machine=read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_machine),bIsbigEndian);
478 result.e_version=read_uint32(offsetof(XELF_DEF::Elf64_Ehdr,e_version),bIsbigEndian);
479 result.e_entry=read_uint64(offsetof(XELF_DEF::Elf64_Ehdr,e_entry),bIsbigEndian);
480 result.e_phoff=read_uint64(offsetof(XELF_DEF::Elf64_Ehdr,e_phoff),bIsbigEndian);
481 result.e_shoff=read_uint64(offsetof(XELF_DEF::Elf64_Ehdr,e_shoff),bIsbigEndian);
482 result.e_flags=read_uint32(offsetof(XELF_DEF::Elf64_Ehdr,e_flags),bIsbigEndian);
483 result.e_ehsize=read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_ehsize),bIsbigEndian);
484 result.e_phentsize=read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_phentsize),bIsbigEndian);
485 result.e_phnum=read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_phnum),bIsbigEndian);
486 result.e_shentsize=read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_shentsize),bIsbigEndian);
487 result.e_shnum=read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_shnum),bIsbigEndian);
488 result.e_shstrndx=read_uint16(offsetof(XELF_DEF::Elf64_Ehdr,e_shstrndx),bIsbigEndian);
489 }
490
491 return result;
492 }
493
getTypes()494 QMap<quint64, QString> XELF::getTypes()
495 {
496 QMap<quint64, QString> mapResult;
497
498 mapResult.insert(0,"ET_NONE");
499 mapResult.insert(1,"ET_REL");
500 mapResult.insert(2,"ET_EXEC");
501 mapResult.insert(3,"ET_DYN");
502 mapResult.insert(4,"ET_CORE");
503 mapResult.insert(5,"ET_NUM");
504 mapResult.insert(0xff00,"ET_LOPROC");
505 mapResult.insert(0xffff,"ET_HIPROC");
506
507 return mapResult;
508 }
509
getTypesS()510 QMap<quint64, QString> XELF::getTypesS()
511 {
512 QMap<quint64, QString> mapResult;
513
514 mapResult.insert(0,"NONE");
515 mapResult.insert(1,"REL");
516 mapResult.insert(2,"EXEC");
517 mapResult.insert(3,"DYN");
518 mapResult.insert(4,"CORE");
519 mapResult.insert(5,"NUM");
520 mapResult.insert(0xff00,"LOPROC");
521 mapResult.insert(0xffff,"HIPROC");
522
523 return mapResult;
524 }
525
getMachines()526 QMap<quint64, QString> XELF::getMachines()
527 {
528 QMap<quint64, QString> mapResult;
529
530 mapResult.insert(0,"EM_NONE"); // TODO http://users.sosdg.org/~qiyong/mxr/source/sys/sys/exec_XELF_DEF::Elf.h
531 mapResult.insert(1,"EM_M32");
532 mapResult.insert(2,"EM_SPARC");
533 mapResult.insert(3,"EM_386");
534 mapResult.insert(4,"EM_68K");
535 mapResult.insert(5,"EM_88K");
536 mapResult.insert(6,"EM_486"); /* Perhaps disused */
537 mapResult.insert(7,"EM_860");
538 mapResult.insert(8,"EM_MIPS");
539 mapResult.insert(9,"EM_S370");
540 mapResult.insert(10,"EM_MIPS_RS3_LE");
541 mapResult.insert(11,"EM_RS6000");
542 mapResult.insert(15,"EM_PARISC");
543 mapResult.insert(16,"EM_nCUBE");
544 mapResult.insert(17,"EM_VPP500");
545 mapResult.insert(18,"EM_SPARC32PLUS");
546 mapResult.insert(19,"EM_960");
547 mapResult.insert(20,"EM_PPC");
548 mapResult.insert(21,"EM_PPC64");
549 mapResult.insert(22,"EM_S390");
550 mapResult.insert(23,"EM_SPU");
551 mapResult.insert(36,"EM_V800");
552 mapResult.insert(37,"EM_FR20");
553 mapResult.insert(38,"EM_RH32");
554 mapResult.insert(39,"EM_RCE");
555 mapResult.insert(40,"EM_ARM");
556 mapResult.insert(41,"EM_ALPHA");
557 mapResult.insert(42,"EM_SH");
558 mapResult.insert(43,"EM_SPARCV9");
559 mapResult.insert(44,"EM_TRICORE");
560 mapResult.insert(45,"EM_ARC");
561 mapResult.insert(46,"EM_H8_300");
562 mapResult.insert(47,"EM_H8_300H");
563 mapResult.insert(48,"EM_H8S");
564 mapResult.insert(49,"EM_H8_500");
565 mapResult.insert(50,"EM_IA_64");
566 mapResult.insert(51,"EM_MIPS_X");
567 mapResult.insert(52,"EM_COLDFIRE");
568 mapResult.insert(53,"EM_68HC12");
569 mapResult.insert(54,"EM_MMA");
570 mapResult.insert(55,"EM_PCP");
571 mapResult.insert(56,"EM_NCPU");
572 mapResult.insert(57,"EM_NDR1");
573 mapResult.insert(58,"EM_STARCORE");
574 mapResult.insert(59,"EM_ME16");
575 mapResult.insert(60,"EM_ST100");
576 mapResult.insert(61,"EM_TINYJ");
577 mapResult.insert(62,"EM_AMD64"); // EM_X86_64
578 mapResult.insert(63,"EM_PDSP");
579 mapResult.insert(66,"EM_FX66");
580 mapResult.insert(67,"EM_ST9PLUS");
581 mapResult.insert(68,"EM_ST7");
582 mapResult.insert(69,"EM_68HC16");
583 mapResult.insert(70,"EM_68HC11");
584 mapResult.insert(71,"EM_68HC08");
585 mapResult.insert(72,"EM_68HC05");
586 mapResult.insert(73,"EM_SVX");
587 mapResult.insert(74,"EM_ST19");
588 mapResult.insert(75,"EM_VAX");
589 mapResult.insert(76,"EM_CRIS");
590 mapResult.insert(77,"EM_JAVELIN");
591 mapResult.insert(78,"EM_FIREPATH");
592 mapResult.insert(79,"EM_ZSP");
593 mapResult.insert(80,"EM_MMIX");
594 mapResult.insert(81,"EM_HUANY");
595 mapResult.insert(82,"EM_PRISM");
596 mapResult.insert(83,"EM_AVR");
597 mapResult.insert(84,"EM_FR30");
598 mapResult.insert(85,"EM_D10V");
599 mapResult.insert(86,"EM_D30V");
600 mapResult.insert(87,"EM_V850");
601 mapResult.insert(88,"EM_M32R");
602 mapResult.insert(89,"EM_MN10300");
603 mapResult.insert(90,"EM_MN10200");
604 mapResult.insert(91,"EM_PJ");
605 mapResult.insert(92,"EM_OPENRISC");
606 mapResult.insert(93,"EM_ARC_A5");
607 mapResult.insert(94,"EM_XTENSA");
608 mapResult.insert(95,"EM_NUM"); // TODO
609 mapResult.insert(106,"EM_BLACKFIN");
610 mapResult.insert(113,"EM_ALTERA_NIOS2");
611 mapResult.insert(140,"EM_TI_C6000");
612 mapResult.insert(183,"EM_AARCH64");
613 mapResult.insert(243,"EM_RISC_V");
614 mapResult.insert(0x5441,"EM_FRV");
615 mapResult.insert(0x18ad,"EM_AVR32");
616 mapResult.insert(0x9026,"EM_ALPHA");
617 mapResult.insert(0x9080,"EM_CYGNUS_V850");
618 mapResult.insert(0x9041,"EM_CYGNUS_M32R");
619 mapResult.insert(0xA390,"EM_S390_OLD");
620 mapResult.insert(0xbeef,"EM_CYGNUS_MN10300");
621
622 return mapResult;
623 }
624
getMachinesS()625 QMap<quint64, QString> XELF::getMachinesS()
626 {
627 QMap<quint64, QString> mapResult;
628
629 // TODO ftp://ftp.eso.org/pub/solaris/rec_patches/8/8_Recommended/109147-39/SUNWhea/reloc/usr/include/sys/elf.h
630 // TODO http://users.sosdg.org/~qiyong/mxr/source/sys/sys/elf.h
631 mapResult.insert(0,"NONE");
632 mapResult.insert(1,"M32");
633 mapResult.insert(2,"SPARC");
634 mapResult.insert(3,"386");
635 mapResult.insert(4,"68K");
636 mapResult.insert(5,"88K");
637 mapResult.insert(6,"486"); /* Perhaps disused */
638 mapResult.insert(7,"860");
639 mapResult.insert(8,"MIPS");
640 mapResult.insert(9,"S370");
641 mapResult.insert(10,"MIPS_RS3_LE");
642 mapResult.insert(11,"RS6000");
643 mapResult.insert(15,"PARISC");
644 mapResult.insert(16,"nCUBE");
645 mapResult.insert(17,"VPP500");
646 mapResult.insert(18,"SPARC32PLUS");
647 mapResult.insert(19,"960");
648 mapResult.insert(20,"PPC");
649 mapResult.insert(21,"PPC64");
650 mapResult.insert(22,"S390");
651 mapResult.insert(23,"SPU");
652 mapResult.insert(36,"V800");
653 mapResult.insert(37,"FR20");
654 mapResult.insert(38,"RH32");
655 mapResult.insert(39,"RCE");
656 mapResult.insert(40,"ARM");
657 mapResult.insert(41,"ALPHA");
658 mapResult.insert(42,"SH");
659 mapResult.insert(43,"SPARCV9");
660 mapResult.insert(44,"TRICORE");
661 mapResult.insert(45,"ARC");
662 mapResult.insert(46,"H8_300");
663 mapResult.insert(47,"H8_300H");
664 mapResult.insert(48,"H8S");
665 mapResult.insert(49,"H8_500");
666 mapResult.insert(50,"IA_64");
667 mapResult.insert(51,"MIPS_X");
668 mapResult.insert(52,"COLDFIRE");
669 mapResult.insert(53,"68HC12");
670 mapResult.insert(54,"MMA");
671 mapResult.insert(55,"PCP");
672 mapResult.insert(56,"NCPU");
673 mapResult.insert(57,"NDR1");
674 mapResult.insert(58,"STARCORE");
675 mapResult.insert(59,"ME16");
676 mapResult.insert(60,"ST100");
677 mapResult.insert(61,"TINYJ");
678 mapResult.insert(62,"AMD64"); // X86_64
679 mapResult.insert(63,"PDSP");
680 mapResult.insert(66,"FX66");
681 mapResult.insert(67,"ST9PLUS");
682 mapResult.insert(68,"ST7");
683 mapResult.insert(69,"68HC16");
684 mapResult.insert(70,"68HC11");
685 mapResult.insert(71,"68HC08");
686 mapResult.insert(72,"68HC05");
687 mapResult.insert(73,"SVX");
688 mapResult.insert(74,"ST19");
689 mapResult.insert(75,"VAX");
690 mapResult.insert(76,"CRIS");
691 mapResult.insert(77,"JAVELIN");
692 mapResult.insert(78,"FIREPATH");
693 mapResult.insert(79,"ZSP");
694 mapResult.insert(80,"MMIX");
695 mapResult.insert(81,"HUANY");
696 mapResult.insert(82,"PRISM");
697 mapResult.insert(83,"AVR");
698 mapResult.insert(84,"FR30");
699 mapResult.insert(85,"D10V");
700 mapResult.insert(86,"D30V");
701 mapResult.insert(87,"V850");
702 mapResult.insert(88,"M32R");
703 mapResult.insert(89,"MN10300");
704 mapResult.insert(89,"MN10300");
705 mapResult.insert(90,"MN10200");
706 mapResult.insert(91,"PJ"); // TODO
707 mapResult.insert(92,"OPENRISC");
708 mapResult.insert(93,"ARC_A5");
709 mapResult.insert(94,"XTENSA");
710 mapResult.insert(95,"NUM");
711 mapResult.insert(106,"BLACKFIN");
712 mapResult.insert(113,"ALTERA_NIOS2");
713 mapResult.insert(140,"TI_C6000");
714 mapResult.insert(183,"AARCH64");
715 mapResult.insert(243,"RISC_V");
716 mapResult.insert(0x5441,"FRV");
717 mapResult.insert(0x18ad,"AVR32");
718 mapResult.insert(0x9026,"ALPHA");
719 mapResult.insert(0x9080,"CYGNUS_V850");
720 mapResult.insert(0x9041,"CYGNUS_M32R");
721 mapResult.insert(0xA390,"S390_OLD");
722 mapResult.insert(0xbeef,"CYGNUS_MN10300");
723
724 return mapResult;
725 }
726
getHeaderVersionList()727 QMap<quint64, QString> XELF::getHeaderVersionList()
728 {
729 QMap<quint64, QString> mapResult;
730
731 mapResult.insert(1,"EV_CURRENT");
732
733 return mapResult;
734 }
735
getIndentMag()736 QMap<quint64, QString> XELF::getIndentMag()
737 {
738 QMap<quint64, QString> mapResult;
739
740 mapResult.insert(0x464C457F,"ELFMAG");
741
742 return mapResult;
743 }
744
getIndentMagS()745 QMap<quint64, QString> XELF::getIndentMagS()
746 {
747 QMap<quint64, QString> mapResult;
748
749 mapResult.insert(0x464C457F,"ELFMAG");
750
751 return mapResult;
752 }
753
getIndentClasses()754 QMap<quint64, QString> XELF::getIndentClasses()
755 {
756 QMap<quint64, QString> mapResult;
757
758 mapResult.insert(0,"ELFCLASSNONE");
759 mapResult.insert(1,"ELFCLASS32");
760 mapResult.insert(2,"ELFCLASS64");
761
762 return mapResult;
763 }
764
getIndentClassesS()765 QMap<quint64, QString> XELF::getIndentClassesS()
766 {
767 QMap<quint64, QString> mapResult;
768
769 mapResult.insert(0,"NONE");
770 mapResult.insert(1,"32");
771 mapResult.insert(2,"64");
772
773 return mapResult;
774 }
775
getIndentDatas()776 QMap<quint64, QString> XELF::getIndentDatas()
777 {
778 QMap<quint64, QString> mapResult;
779
780 mapResult.insert(0,"ELFDATANONE");
781 mapResult.insert(1,"ELFDATA2LSB");
782 mapResult.insert(2,"ELFDATA2MSB");
783
784 return mapResult;
785 }
786
getIndentDatasS()787 QMap<quint64, QString> XELF::getIndentDatasS()
788 {
789 QMap<quint64, QString> mapResult;
790
791 mapResult.insert(0,"NONE");
792 mapResult.insert(1,"2LSB");
793 mapResult.insert(2,"2MSB");
794
795 return mapResult;
796 }
797
getIndentVersions()798 QMap<quint64, QString> XELF::getIndentVersions()
799 {
800 QMap<quint64, QString> mapResult;
801
802 mapResult.insert(1,"EV_CURRENT");
803
804 return mapResult;
805 }
806
getIndentVersionsS()807 QMap<quint64, QString> XELF::getIndentVersionsS()
808 {
809 QMap<quint64, QString> mapResult;
810
811 mapResult.insert(1,"CURRENT");
812
813 return mapResult;
814 }
815
getIndentOsabis()816 QMap<quint64, QString> XELF::getIndentOsabis()
817 {
818 QMap<quint64, QString> mapResult;
819
820 mapResult.insert(0,"ELFOSABI_SYSV");
821 mapResult.insert(1,"ELFOSABI_HPUX");
822 mapResult.insert(2,"ELFOSABI_NETBSD");
823 mapResult.insert(3,"ELFOSABI_LINUX");
824 mapResult.insert(4,"ELFOSABI_HURD");
825 mapResult.insert(5,"ELFOSABI_86OPEN");
826 mapResult.insert(6,"ELFOSABI_SOLARIS");
827 mapResult.insert(7,"ELFOSABI_AIX");
828 mapResult.insert(8,"ELFOSABI_IRIX");
829 mapResult.insert(9,"ELFOSABI_FREEBSD");
830 mapResult.insert(10,"ELFOSABI_TRU64");
831 mapResult.insert(11,"ELFOSABI_MODESTO");
832 mapResult.insert(12,"ELFOSABI_OPENBSD");
833 mapResult.insert(13,"ELFOSABI_OPENVMS");
834 mapResult.insert(14,"ELFOSABI_NSK");
835 mapResult.insert(15,"ELFOSABI_AROS");
836 mapResult.insert(16,"ELFOSABI_FENIXOS");
837 mapResult.insert(17,"ELFOSABI_CLOUDABI");
838 mapResult.insert(64,"ELFOSABI_ARM_AEABI");
839 mapResult.insert(97,"ELFOSABI_ARM");
840 mapResult.insert(255,"ELFOSABI_STANDALONE");
841
842 return mapResult;
843 }
844
getIndentOsabisS()845 QMap<quint64, QString> XELF::getIndentOsabisS()
846 {
847 QMap<quint64, QString> mapResult;
848
849 mapResult.insert(0,"SYSV");
850 mapResult.insert(1,"HPUX");
851 mapResult.insert(2,"NETBSD");
852 mapResult.insert(3,"LINUX");
853 mapResult.insert(4,"HURD");
854 mapResult.insert(5,"86OPEN");
855 mapResult.insert(6,"SOLARIS");
856 mapResult.insert(7,"AIX");
857 mapResult.insert(8,"IRIX");
858 mapResult.insert(9,"FREEBSD");
859 mapResult.insert(10,"TRU64");
860 mapResult.insert(11,"MODESTO");
861 mapResult.insert(12,"OPENBSD");
862 mapResult.insert(13,"OPENVMS");
863 mapResult.insert(14,"NSK");
864 mapResult.insert(15,"AROS");
865 mapResult.insert(16,"FENIXOS");
866 mapResult.insert(17,"CLOUDABI");
867 mapResult.insert(64,"ARM_AEABI");
868 mapResult.insert(97,"ARM");
869 mapResult.insert(255,"STANDALONE");
870
871 return mapResult;
872 }
873
getSectionTypes()874 QMap<quint64, QString> XELF::getSectionTypes()
875 {
876 QMap<quint64, QString> mapResult;
877
878 mapResult.insert(0,"SHT_NULL");
879 mapResult.insert(1,"SHT_PROGBITS");
880 mapResult.insert(2,"SHT_SYMTAB");
881 mapResult.insert(3,"SHT_STRTAB");
882 mapResult.insert(4,"SHT_RELA");
883 mapResult.insert(5,"SHT_HASH");
884 mapResult.insert(6,"SHT_DYNAMIC");
885 mapResult.insert(7,"SHT_NOTE");
886 mapResult.insert(8,"SHT_NOBITS");
887 mapResult.insert(9,"SHT_REL");
888 mapResult.insert(10,"SHT_SHLIB");
889 mapResult.insert(11,"SHT_DYNSYM");
890 mapResult.insert(14,"SHT_INIT_ARRAY");
891 mapResult.insert(15,"SHT_FINI_ARRAY");
892 mapResult.insert(16,"SHT_PREINIT_ARRAY");
893 mapResult.insert(17,"SHT_GROUP");
894 mapResult.insert(18,"SHT_SYMTAB_SHNDX");
895 mapResult.insert(19,"SHT_NUM");
896 mapResult.insert(0x60000000,"SHT_LOOS");
897 mapResult.insert(0x6ffffff6,"SHT_GNU_HASH");
898 mapResult.insert(0x6ffffffa,"SHT_SUNW_move");
899 mapResult.insert(0x6ffffffc,"SHT_SUNW_syminfo");
900 mapResult.insert(0x6ffffffd,"SHT_GNU_verdef");
901 mapResult.insert(0x6ffffffe,"SHT_GNU_verneed");
902 mapResult.insert(0x6fffffff,"SHT_GNU_versym");
903 mapResult.insert(0x70000000,"SHT_LOPROC");
904 mapResult.insert(0x70000001,"SHT_AMD64_UNWIND");
905 mapResult.insert(0x70000002,"SHT_ARM_PREEMPTMAP");
906 mapResult.insert(0x70000003,"SHT_ARM_ATTRIBUTES");
907 mapResult.insert(0x70000004,"SHT_ARM_DEBUGOVERLAY");
908 mapResult.insert(0x70000005,"SHT_ARM_OVERLAYSECTION");
909 mapResult.insert(0x70000006,"SHT_MIPS_REGINFO");
910 mapResult.insert(0x70000007,"SHT_MIPS_PACKAGE");
911 mapResult.insert(0x70000008,"SHT_MIPS_PACKSYM");
912 mapResult.insert(0x70000009,"SHT_MIPS_RELD");
913 mapResult.insert(0x7000000b,"SHT_MIPS_IFACE");
914 mapResult.insert(0x7000000c,"SHT_MIPS_CONTENT");
915 mapResult.insert(0x7000000d,"SHT_MIPS_OPTIONS");
916 mapResult.insert(0x70000010,"SHT_MIPS_SHDR");
917 mapResult.insert(0x70000011,"SHT_MIPS_FDESC");
918 mapResult.insert(0x70000012,"SHT_MIPS_EXTSYM");
919 mapResult.insert(0x70000013,"SHT_MIPS_DENSE");
920 mapResult.insert(0x70000014,"SHT_MIPS_PDESC");
921 mapResult.insert(0x70000015,"SHT_MIPS_LOCSYM");
922 mapResult.insert(0x70000016,"SHT_MIPS_AUXSYM");
923 mapResult.insert(0x70000017,"SHT_MIPS_OPTSYM");
924 mapResult.insert(0x70000018,"SHT_MIPS_LOCSTR");
925 mapResult.insert(0x70000019,"SHT_MIPS_LINE");
926 mapResult.insert(0x7000001a,"SHT_MIPS_RFDESC");
927 mapResult.insert(0x7000001b,"SHT_MIPS_DELTASYM");
928 mapResult.insert(0x7000001c,"SHT_MIPS_DELTAINST");
929 mapResult.insert(0x7000001d,"SHT_MIPS_DELTACLASS");
930 mapResult.insert(0x7000001e,"SHT_MIPS_DWARF");
931 mapResult.insert(0x7000001f,"SHT_MIPS_DELTADECL");
932 mapResult.insert(0x70000020,"SHT_MIPS_SYMBOL_LIB");
933 mapResult.insert(0x70000021,"SHT_MIPS_EVENTS");
934 mapResult.insert(0x70000022,"SHT_MIPS_TRANSLATE");
935 mapResult.insert(0x70000023,"SHT_MIPS_PIXIE");
936 mapResult.insert(0x70000024,"SHT_MIPS_XLATE");
937 mapResult.insert(0x70000025,"SHT_MIPS_XLATE_DEBUG");
938 mapResult.insert(0x70000026,"SHT_MIPS_WHIRL");
939 mapResult.insert(0x70000027,"SHT_MIPS_EH_REGION");
940 mapResult.insert(0x70000028,"SHT_MIPS_XLATE_OLD");
941 mapResult.insert(0x70000029,"SHT_MIPS_PDR_EXCEPTION");
942 mapResult.insert(0x7000002a,"SHT_MIPS_ABIFLAGS");
943 mapResult.insert(0x7fffffff,"SHT_HIPROC");
944 mapResult.insert(0x80000000,"SHT_LOUSER");
945 mapResult.insert(0xffffffff,"SHT_HIUSER");
946
947 return mapResult;
948 }
949
getSectionTypesS()950 QMap<quint64, QString> XELF::getSectionTypesS()
951 {
952 QMap<quint64, QString> mapResult;
953
954 mapResult.insert(0,"NULL");
955 mapResult.insert(1,"PROGBITS");
956 mapResult.insert(2,"SYMTAB");
957 mapResult.insert(3,"STRTAB");
958 mapResult.insert(4,"RELA");
959 mapResult.insert(5,"HASH");
960 mapResult.insert(6,"DYNAMIC");
961 mapResult.insert(7,"NOTE");
962 mapResult.insert(8,"NOBITS");
963 mapResult.insert(9,"REL");
964 mapResult.insert(10,"SHLIB");
965 mapResult.insert(11,"DYNSYM");
966 mapResult.insert(14,"INIT_ARRAY");
967 mapResult.insert(15,"FINI_ARRAY");
968 mapResult.insert(16,"PREINIT_ARRAY");
969 mapResult.insert(17,"GROUP");
970 mapResult.insert(18,"SYMTAB_SHNDX");
971 mapResult.insert(19,"NUM");
972 mapResult.insert(0x60000000,"LOOS");
973 mapResult.insert(0x6ffffff6,"GNU_HASH");
974 mapResult.insert(0x6ffffffa,"SUNW_move");
975 mapResult.insert(0x6ffffffc,"SUNW_syminfo");
976 mapResult.insert(0x6ffffffd,"GNU_verdef");
977 mapResult.insert(0x6ffffffe,"GNU_verneed");
978 mapResult.insert(0x6fffffff,"GNU_versym");
979 mapResult.insert(0x70000000,"LOPROC");
980 mapResult.insert(0x70000001,"AMD64_UNWIND");
981 mapResult.insert(0x70000002,"ARM_PREEMPTMAP");
982 mapResult.insert(0x70000003,"ARM_ATTRIBUTES");
983 mapResult.insert(0x70000004,"ARM_DEBUGOVERLAY");
984 mapResult.insert(0x70000005,"ARM_OVERLAYSECTION");
985 mapResult.insert(0x70000006,"MIPS_REGINFO");
986 mapResult.insert(0x70000007,"MIPS_PACKAGE");
987 mapResult.insert(0x70000008,"MIPS_PACKSYM");
988 mapResult.insert(0x70000009,"MIPS_RELD");
989 mapResult.insert(0x7000000b,"MIPS_IFACE");
990 mapResult.insert(0x7000000c,"MIPS_CONTENT");
991 mapResult.insert(0x7000000d,"MIPS_OPTIONS");
992 mapResult.insert(0x70000010,"MIPS_SHDR");
993 mapResult.insert(0x70000011,"MIPS_FDESC");
994 mapResult.insert(0x70000012,"MIPS_EXTSYM");
995 mapResult.insert(0x70000013,"MIPS_DENSE");
996 mapResult.insert(0x70000014,"MIPS_PDESC");
997 mapResult.insert(0x70000015,"MIPS_LOCSYM");
998 mapResult.insert(0x70000016,"MIPS_AUXSYM");
999 mapResult.insert(0x70000017,"MIPS_OPTSYM");
1000 mapResult.insert(0x70000018,"MIPS_LOCSTR");
1001 mapResult.insert(0x70000019,"MIPS_LINE");
1002 mapResult.insert(0x7000001a,"MIPS_RFDESC");
1003 mapResult.insert(0x7000001b,"MIPS_DELTASYM");
1004 mapResult.insert(0x7000001c,"MIPS_DELTAINST");
1005 mapResult.insert(0x7000001d,"MIPS_DELTACLASS");
1006 mapResult.insert(0x7000001e,"MIPS_DWARF");
1007 mapResult.insert(0x7000001f,"MIPS_DELTADECL");
1008 mapResult.insert(0x70000020,"MIPS_SYMBOL_LIB");
1009 mapResult.insert(0x70000021,"MIPS_EVENTS");
1010 mapResult.insert(0x70000022,"MIPS_TRANSLATE");
1011 mapResult.insert(0x70000023,"MIPS_PIXIE");
1012 mapResult.insert(0x70000024,"MIPS_XLATE");
1013 mapResult.insert(0x70000025,"MIPS_XLATE_DEBUG");
1014 mapResult.insert(0x70000026,"MIPS_WHIRL");
1015 mapResult.insert(0x70000027,"MIPS_EH_REGION");
1016 mapResult.insert(0x70000028,"MIPS_XLATE_OLD");
1017 mapResult.insert(0x70000029,"MIPS_PDR_EXCEPTION");
1018 mapResult.insert(0x7000002a,"MIPS_ABIFLAGS");
1019 mapResult.insert(0x7fffffff,"HIPROC");
1020 mapResult.insert(0x80000000,"LOUSER");
1021 mapResult.insert(0xffffffff,"HIUSER");
1022
1023 return mapResult;
1024 }
1025
getSectionFlags()1026 QMap<quint64, QString> XELF::getSectionFlags()
1027 {
1028 QMap<quint64, QString> mapResult;
1029
1030 mapResult.insert(0x00000001,"SHF_WRITE");
1031 mapResult.insert(0x00000002,"SHF_ALLOC");
1032 mapResult.insert(0x00000004,"SHF_EXECINSTR");
1033 mapResult.insert(0x00000010,"SHF_MERGE");
1034 mapResult.insert(0x00000020,"SHF_STRINGS");
1035 mapResult.insert(0x00000040,"SHF_INFO_LINK");
1036 mapResult.insert(0x00000080,"SHF_LINK_ORDER");
1037 mapResult.insert(0x00000100,"SHF_OS_NONCONFORMING");
1038 mapResult.insert(0x00000200,"SHF_GROUP");
1039 mapResult.insert(0x00000400,"SHF_TLS");
1040 mapResult.insert(0x0ff00000,"SHF_MASKOS");
1041 mapResult.insert(0xf0000000,"SHF_MASKPROC");
1042 mapResult.insert(0x40000000,"SHF_ORDERED");
1043 mapResult.insert(0x80000000,"SHF_EXCLUDE");
1044
1045 return mapResult;
1046 }
1047
getSectionFlagsS()1048 QMap<quint64, QString> XELF::getSectionFlagsS()
1049 {
1050 QMap<quint64, QString> mapResult;
1051
1052 mapResult.insert(0x00000001,"WRITE");
1053 mapResult.insert(0x00000002,"ALLOC");
1054 mapResult.insert(0x00000004,"EXECINSTR");
1055 mapResult.insert(0x00000010,"MERGE");
1056 mapResult.insert(0x00000020,"STRINGS");
1057 mapResult.insert(0x00000040,"INFO_LINK");
1058 mapResult.insert(0x00000080,"LINK_ORDER");
1059 mapResult.insert(0x00000100,"OS_NONCONFORMING");
1060 mapResult.insert(0x00000200,"GROUP");
1061 mapResult.insert(0x00000400,"TLS");
1062 mapResult.insert(0x0ff00000,"MASKOS");
1063 mapResult.insert(0xf0000000,"MASKPROC");
1064 mapResult.insert(0x40000000,"ORDERED");
1065 mapResult.insert(0x80000000,"EXCLUDE");
1066
1067 return mapResult;
1068 }
1069
getProgramTypes()1070 QMap<quint64, QString> XELF::getProgramTypes()
1071 {
1072 QMap<quint64, QString> mapResult;
1073
1074 mapResult.insert(0,"PT_NULL");
1075 mapResult.insert(1,"PT_LOAD");
1076 mapResult.insert(2,"PT_DYNAMIC");
1077 mapResult.insert(3,"PT_INTERP");
1078 mapResult.insert(4,"PT_NOTE");
1079 mapResult.insert(5,"PT_SHLIB");
1080 mapResult.insert(6,"PT_PHDR");
1081 mapResult.insert(7,"PT_TLS");
1082 mapResult.insert(8,"PT_NUM");
1083 mapResult.insert(0x60000000,"PT_LOOS");
1084 mapResult.insert(0x6464e550,"PT_SUNW_UNWIND");
1085 mapResult.insert(0x6474e550,"PT_GNU_EH_FRAME"); // PT_SUNW_EH_FRAME
1086 mapResult.insert(0x6474e551,"PT_GNU_STACK");
1087 mapResult.insert(0x6474e552,"PT_GNU_RELRO");
1088 mapResult.insert(0x6ffffffa,"PT_LOSUNW");
1089 mapResult.insert(0x6ffffffa,"PT_SUNWBSS");
1090 mapResult.insert(0x6ffffffb,"PT_SUNWSTACK");
1091 mapResult.insert(0x6ffffffc,"PT_SUNWDTRACE");
1092 mapResult.insert(0x6ffffffd,"PT_SUNWCAP");
1093 mapResult.insert(0x6fffffff,"PT_HIOS"); // PT_HISUNW
1094 mapResult.insert(0x70000000,"PT_LOPROC");
1095 mapResult.insert(0x7fffffff,"PT_HIPROC");
1096 // mapResult.insert(0x70000000,"PT_MIPXELF_DEF::REGINFO");
1097
1098 return mapResult;
1099 }
1100
getProgramTypesS()1101 QMap<quint64, QString> XELF::getProgramTypesS()
1102 {
1103 QMap<quint64, QString> mapResult;
1104
1105 mapResult.insert(0,"NULL");
1106 mapResult.insert(1,"LOAD");
1107 mapResult.insert(2,"DYNAMIC");
1108 mapResult.insert(3,"INTERP");
1109 mapResult.insert(4,"NOTE");
1110 mapResult.insert(5,"SHLIB");
1111 mapResult.insert(6,"PHDR");
1112 mapResult.insert(7,"TLS");
1113 mapResult.insert(8,"NUM");
1114 mapResult.insert(0x60000000,"LOOS");
1115 mapResult.insert(0x6464e550,"SUNW_UNWIND");
1116 mapResult.insert(0x6474e550,"GNU_EH_FRAME"); // SUNW_EH_FRAME
1117 mapResult.insert(0x6474e551,"GNU_STACK");
1118 mapResult.insert(0x6474e552,"GNU_RELRO");
1119 mapResult.insert(0x6ffffffa,"LOSUNW");
1120 mapResult.insert(0x6ffffffa,"SUNWBSS");
1121 mapResult.insert(0x6ffffffb,"SUNWSTACK");
1122 mapResult.insert(0x6ffffffc,"SUNWDTRACE");
1123 mapResult.insert(0x6ffffffd,"SUNWCAP");
1124 mapResult.insert(0x6fffffff,"HIOS"); // HISUNW
1125 mapResult.insert(0x70000000,"LOPROC");
1126 mapResult.insert(0x7fffffff,"HIPROC");
1127 // mapResult.insert(0x70000000,"MIPXELF_DEF::REGINFO");
1128
1129 return mapResult;
1130 }
1131
getProgramFlags()1132 QMap<quint64, QString> XELF::getProgramFlags()
1133 {
1134 QMap<quint64, QString> mapResult;
1135
1136 mapResult.insert(0x00000001,"PF_X");
1137 mapResult.insert(0x00000002,"PF_W");
1138 mapResult.insert(0x00000004,"PF_R");
1139 mapResult.insert(0x0ff00000,"PF_MASKOS");
1140 mapResult.insert(0xf0000000,"PF_MASKPROC");
1141
1142 return mapResult;
1143 }
1144
getProgramFlagsS()1145 QMap<quint64, QString> XELF::getProgramFlagsS()
1146 {
1147 QMap<quint64, QString> mapResult;
1148
1149 mapResult.insert(0x00000001,"X");
1150 mapResult.insert(0x00000002,"W");
1151 mapResult.insert(0x00000004,"R");
1152 mapResult.insert(0x0ff00000,"MASKOS");
1153 mapResult.insert(0xf0000000,"MASKPROC");
1154
1155 return mapResult;
1156 }
1157
getSectionStringTable()1158 quint16 XELF::getSectionStringTable()
1159 {
1160 return getSectionStringTable(is64());
1161 }
1162
getSectionStringTable(bool bIs64)1163 quint16 XELF::getSectionStringTable(bool bIs64)
1164 {
1165 quint32 nResult=0;
1166
1167 if(bIs64)
1168 {
1169 nResult=getHdr64_shstrndx();
1170 }
1171 else
1172 {
1173 nResult=getHdr32_shstrndx();
1174 }
1175
1176 return nResult;
1177 }
1178
getSectionOffsetSize(quint32 nSection)1179 XBinary::OFFSETSIZE XELF::getSectionOffsetSize(quint32 nSection)
1180 {
1181 OFFSETSIZE result={};
1182
1183 if(is64())
1184 {
1185 XELF_DEF::Elf64_Shdr section_header=getElf64_Shdr(nSection);
1186 result.nOffset=section_header.sh_offset;
1187 result.nSize=section_header.sh_size;
1188 }
1189 else
1190 {
1191 XELF_DEF::Elf32_Shdr section_header=getElf32_Shdr(nSection);
1192 result.nOffset=section_header.sh_offset;
1193 result.nSize=section_header.sh_size;
1194 }
1195
1196 return result;
1197 }
1198
getStringsFromSection(quint32 nSection)1199 QMap<quint32, QString> XELF::getStringsFromSection(quint32 nSection)
1200 {
1201 QMap<quint32, QString> mapResult;
1202
1203 if(nSection!= XELF_DEF::SHN_UNDEF)
1204 {
1205 QByteArray baSection=getSection(nSection);
1206
1207 mapResult=getStringsFromSectionData(&baSection);
1208 }
1209
1210 return mapResult;
1211 }
1212
getStringsFromSectionData(QByteArray * pbaData)1213 QMap<quint32, QString> XELF::getStringsFromSectionData(QByteArray *pbaData)
1214 {
1215 QMap<quint32, QString> mapResult;
1216
1217 int nSize=pbaData->size();
1218 char *pOffset=pbaData->data();
1219 quint32 nCurrentOffset=0;
1220
1221 while(nSize>0)
1222 {
1223 QString sString(pOffset+nCurrentOffset);
1224
1225 if(sString.length())
1226 {
1227 mapResult.insert(nCurrentOffset,sString);
1228 }
1229
1230 nCurrentOffset+=(quint32)sString.length()+1;
1231 nSize-=sString.length()+1;
1232 }
1233
1234 return mapResult;
1235 }
1236
getStringFromSection(quint32 nIndex,quint32 nSection)1237 QString XELF::getStringFromSection(quint32 nIndex, quint32 nSection)
1238 {
1239 QString sResult;
1240
1241 XBinary::OFFSETSIZE offsetSize=getSectionOffsetSize(nSection);
1242
1243 sResult=getStringFromIndex(offsetSize.nOffset,offsetSize.nSize,nIndex);
1244
1245 return sResult;
1246 }
1247
getStringsFromMainSection()1248 QMap<quint32, QString> XELF::getStringsFromMainSection()
1249 {
1250 quint32 nSection=getSectionStringTable();
1251
1252 return getStringsFromSection(nSection);
1253 }
1254
getStringFromMainSection(quint32 nIndex)1255 QString XELF::getStringFromMainSection(quint32 nIndex)
1256 {
1257 quint32 nSection=getSectionStringTable();
1258
1259 return getStringFromSection(nIndex,nSection); // TODO optimize
1260 }
1261
getSection(quint32 nIndex)1262 QByteArray XELF::getSection(quint32 nIndex)
1263 {
1264 qint64 nOffset=0;
1265 qint64 nSize=0;
1266
1267 if(is64())
1268 {
1269 XELF_DEF::Elf64_Shdr section_header=getElf64_Shdr(nIndex);
1270 nSize=section_header.sh_size;
1271 nOffset=(isImage())?(section_header.sh_addr):(section_header.sh_offset);
1272 }
1273 else
1274 {
1275 XELF_DEF::Elf32_Shdr section_header=getElf32_Shdr(nIndex);
1276 nSize=section_header.sh_size;
1277 nOffset=(isImage())?(section_header.sh_addr):(section_header.sh_offset);
1278 }
1279
1280 return read_array(nOffset,nSize);
1281 }
1282
isSectionValid(quint32 nIndex)1283 bool XELF::isSectionValid(quint32 nIndex)
1284 {
1285 quint32 nNumberOfSections=getHdr32_shnum();
1286
1287 return (nIndex<nNumberOfSections)&&(nIndex!=(quint32)-1);
1288 }
1289
getElf32_ShdrList()1290 QList<XELF_DEF::Elf32_Shdr> XELF::getElf32_ShdrList()
1291 {
1292 QList<XELF_DEF::Elf32_Shdr> listResult;
1293
1294 quint32 nNumberOfSections=getHdr32_shnum();
1295 nNumberOfSections=qMin((quint32)1000,nNumberOfSections);
1296
1297 quint32 nOffset=getHdr32_shoff();
1298 bool bIsBigEndian=isBigEndian();
1299
1300 for(quint32 i=0; i<nNumberOfSections; i++)
1301 {
1302 XELF_DEF::Elf32_Shdr record=_readElf32_Shdr(nOffset,bIsBigEndian);
1303
1304 listResult.append(record);
1305
1306 nOffset+=sizeof(XELF_DEF::Elf32_Shdr);
1307 }
1308
1309 return listResult;
1310 }
1311
getElf64_ShdrList()1312 QList<XELF_DEF::Elf64_Shdr> XELF::getElf64_ShdrList()
1313 {
1314 QList<XELF_DEF::Elf64_Shdr> listResult;
1315
1316 quint32 nNumberOfSections=getHdr64_shnum();
1317 nNumberOfSections=qMin((quint32)1000,nNumberOfSections);
1318
1319 quint64 nOffset=getHdr64_shoff();
1320 bool bIsBigEndian=isBigEndian();
1321
1322 for(quint32 i=0; i<nNumberOfSections; i++)
1323 {
1324 XELF_DEF::Elf64_Shdr record=_readElf64_Shdr(nOffset,bIsBigEndian);
1325
1326 listResult.append(record);
1327
1328 nOffset+=sizeof(XELF_DEF::Elf64_Shdr);
1329 }
1330
1331 return listResult;
1332 }
1333
getElf_ShdrList()1334 QList<XELF_DEF::Elf_Shdr> XELF::getElf_ShdrList()
1335 {
1336 QList<XELF_DEF::Elf_Shdr> listResult;
1337
1338 bool bIs64=is64();
1339
1340 if(bIs64)
1341 {
1342 QList<XELF_DEF::Elf64_Shdr> listSectionHeaders=getElf64_ShdrList();
1343 int nNumberOfSections=listSectionHeaders.count();
1344
1345 for(int i=0;i<nNumberOfSections;i++)
1346 {
1347 XELF_DEF::Elf_Shdr record={};
1348
1349 record.sh_name=listSectionHeaders.at(i).sh_name;
1350 record.sh_type=listSectionHeaders.at(i).sh_type;
1351 record.sh_flags=listSectionHeaders.at(i).sh_flags;
1352 record.sh_addr=listSectionHeaders.at(i).sh_addr;
1353 record.sh_offset=listSectionHeaders.at(i).sh_offset;
1354 record.sh_size=listSectionHeaders.at(i).sh_size;
1355 record.sh_link=listSectionHeaders.at(i).sh_link;
1356 record.sh_info=listSectionHeaders.at(i).sh_info;
1357 record.sh_addralign=listSectionHeaders.at(i).sh_addralign;
1358 record.sh_entsize=listSectionHeaders.at(i).sh_entsize;
1359
1360 listResult.append(record);
1361 }
1362 }
1363 else
1364 {
1365 QList<XELF_DEF::Elf32_Shdr> listSectionHeaders=getElf32_ShdrList();
1366 int nNumberOfSections=listSectionHeaders.count();
1367
1368 for(int i=0;i<nNumberOfSections;i++)
1369 {
1370 XELF_DEF::Elf_Shdr record={};
1371
1372 record.sh_name=listSectionHeaders.at(i).sh_name;
1373 record.sh_type=listSectionHeaders.at(i).sh_type;
1374 record.sh_flags=listSectionHeaders.at(i).sh_flags;
1375 record.sh_addr=listSectionHeaders.at(i).sh_addr;
1376 record.sh_offset=listSectionHeaders.at(i).sh_offset;
1377 record.sh_size=listSectionHeaders.at(i).sh_size;
1378 record.sh_link=listSectionHeaders.at(i).sh_link;
1379 record.sh_info=listSectionHeaders.at(i).sh_info;
1380 record.sh_addralign=listSectionHeaders.at(i).sh_addralign;
1381 record.sh_entsize=listSectionHeaders.at(i).sh_entsize;
1382
1383 listResult.append(record);
1384 }
1385 }
1386
1387 return listResult;
1388 }
1389
getElf32_Shdr(quint32 nIndex)1390 XELF_DEF::Elf32_Shdr XELF::getElf32_Shdr(quint32 nIndex)
1391 {
1392 XELF_DEF::Elf32_Shdr result={};
1393
1394 quint32 nNumberOfSections=getHdr32_shnum();
1395 quint32 nOffset=getHdr32_shoff();
1396 bool bIsBigEndian=isBigEndian();
1397
1398 if(nIndex<nNumberOfSections)
1399 {
1400 nOffset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1401
1402 result=_readElf32_Shdr(nOffset,bIsBigEndian);
1403 }
1404
1405 return result;
1406 }
1407
getElf64_Shdr(quint32 nIndex)1408 XELF_DEF::Elf64_Shdr XELF::getElf64_Shdr(quint32 nIndex)
1409 {
1410 XELF_DEF::Elf64_Shdr result={};
1411
1412 quint32 nNumberOfSections=getHdr64_shnum();
1413 quint64 nOffset=getHdr64_shoff();
1414 bool bIsBigEndian=isBigEndian();
1415
1416 if(nIndex<nNumberOfSections)
1417 {
1418 nOffset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1419
1420 result=_readElf64_Shdr(nOffset,bIsBigEndian);
1421 }
1422
1423 return result;
1424 }
1425
_readElf32_Shdr(qint64 nOffset,bool bIsBigEndian)1426 XELF_DEF::Elf32_Shdr XELF::_readElf32_Shdr(qint64 nOffset,bool bIsBigEndian)
1427 {
1428 XELF_DEF::Elf32_Shdr result={};
1429
1430 result.sh_name=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_name),bIsBigEndian);
1431 result.sh_type=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_type),bIsBigEndian);
1432 result.sh_flags=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_flags),bIsBigEndian);
1433 result.sh_addr=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_addr),bIsBigEndian);
1434 result.sh_offset=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_offset),bIsBigEndian);
1435 result.sh_size=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_size),bIsBigEndian);
1436 result.sh_link=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_link),bIsBigEndian);
1437 result.sh_info=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_info),bIsBigEndian);
1438 result.sh_addralign=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_addralign),bIsBigEndian);
1439 result.sh_entsize=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Shdr,sh_entsize),bIsBigEndian);
1440
1441 return result;
1442 }
1443
_readElf64_Shdr(qint64 nOffset,bool bIsBigEndian)1444 XELF_DEF::Elf64_Shdr XELF::_readElf64_Shdr(qint64 nOffset,bool bIsBigEndian)
1445 {
1446 XELF_DEF::Elf64_Shdr result={};
1447
1448 result.sh_name=read_uint32(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_name),bIsBigEndian);
1449 result.sh_type=read_uint32(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_type),bIsBigEndian);
1450 result.sh_flags=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_flags),bIsBigEndian);
1451 result.sh_addr=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_addr),bIsBigEndian);
1452 result.sh_offset=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_offset),bIsBigEndian);
1453 result.sh_size=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_size),bIsBigEndian);
1454 result.sh_link=read_uint32(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_link),bIsBigEndian);
1455 result.sh_info=read_uint32(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_info),bIsBigEndian);
1456 result.sh_addralign=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_addralign),bIsBigEndian);
1457 result.sh_entsize=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Shdr,sh_entsize),bIsBigEndian);
1458
1459 return result;
1460 }
1461
getElf32_Shdr_name(quint32 nIndex)1462 quint32 XELF::getElf32_Shdr_name(quint32 nIndex)
1463 {
1464 quint32 result=0;
1465
1466 quint32 nNumberOfSections=getHdr32_shnum();
1467 quint32 offset=getHdr32_shoff();
1468 bool bIsBigEndian=isBigEndian();
1469
1470 if(nIndex<nNumberOfSections)
1471 {
1472 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1473 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_name),bIsBigEndian);
1474 }
1475
1476 return result;
1477 }
1478
getElf32_Shdr_type(quint32 nIndex)1479 quint32 XELF::getElf32_Shdr_type(quint32 nIndex)
1480 {
1481 quint32 result=0;
1482
1483 quint32 nNumberOfSections=getHdr32_shnum();
1484 quint32 offset=getHdr32_shoff();
1485 bool bIsBigEndian=isBigEndian();
1486
1487 if(nIndex<nNumberOfSections)
1488 {
1489 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1490 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_type),bIsBigEndian);
1491 }
1492
1493 return result;
1494 }
1495
getElf32_Shdr_flags(quint32 nIndex)1496 quint32 XELF::getElf32_Shdr_flags(quint32 nIndex)
1497 {
1498 quint32 result=0;
1499
1500 quint32 nNumberOfSections=getHdr32_shnum();
1501 quint32 offset=getHdr32_shoff();
1502 bool bIsBigEndian=isBigEndian();
1503
1504 if(nIndex<nNumberOfSections)
1505 {
1506 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1507 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_flags),bIsBigEndian);
1508 }
1509
1510 return result;
1511 }
1512
getElf32_Shdr_addr(quint32 nIndex)1513 quint32 XELF::getElf32_Shdr_addr(quint32 nIndex)
1514 {
1515 quint32 result=0;
1516
1517 quint32 nNumberOfSections=getHdr32_shnum();
1518 quint32 offset=getHdr32_shoff();
1519 bool bIsBigEndian=isBigEndian();
1520
1521 if(nIndex<nNumberOfSections)
1522 {
1523 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1524 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_addr),bIsBigEndian);
1525 }
1526
1527 return result;
1528 }
1529
getElf32_Shdr_offset(quint32 nIndex)1530 quint32 XELF::getElf32_Shdr_offset(quint32 nIndex)
1531 {
1532 quint32 result=0;
1533
1534 quint32 nNumberOfSections=getHdr32_shnum();
1535 quint32 offset=getHdr32_shoff();
1536 bool bIsBigEndian=isBigEndian();
1537
1538 if(nIndex<nNumberOfSections)
1539 {
1540 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1541 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_offset),bIsBigEndian);
1542 }
1543
1544 return result;
1545 }
1546
getElf32_Shdr_size(quint32 nIndex)1547 quint32 XELF::getElf32_Shdr_size(quint32 nIndex)
1548 {
1549 quint32 result=0;
1550
1551 quint32 nNumberOfSections=getHdr32_shnum();
1552 quint32 offset=getHdr32_shoff();
1553 bool bIsBigEndian=isBigEndian();
1554
1555 if(nIndex<nNumberOfSections)
1556 {
1557 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1558 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_size),bIsBigEndian);
1559 }
1560
1561 return result;
1562 }
1563
getElf32_Shdr_link(quint32 nIndex)1564 quint32 XELF::getElf32_Shdr_link(quint32 nIndex)
1565 {
1566 quint32 result=0;
1567
1568 quint32 nNumberOfSections=getHdr32_shnum();
1569 quint32 offset=getHdr32_shoff();
1570 bool bIsBigEndian=isBigEndian();
1571
1572 if(nIndex<nNumberOfSections)
1573 {
1574 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1575 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_link),bIsBigEndian);
1576 }
1577
1578 return result;
1579 }
1580
getElf32_Shdr_info(quint32 nIndex)1581 quint32 XELF::getElf32_Shdr_info(quint32 nIndex)
1582 {
1583 quint32 result=0;
1584
1585 quint32 nNumberOfSections=getHdr32_shnum();
1586 quint32 offset=getHdr32_shoff();
1587 bool bIsBigEndian=isBigEndian();
1588
1589 if(nIndex<nNumberOfSections)
1590 {
1591 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1592 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_info),bIsBigEndian);
1593 }
1594
1595 return result;
1596 }
1597
getElf32_Shdr_addralign(quint32 nIndex)1598 quint32 XELF::getElf32_Shdr_addralign(quint32 nIndex)
1599 {
1600 quint32 result=0;
1601
1602 quint32 nNumberOfSections=getHdr32_shnum();
1603 quint32 offset=getHdr32_shoff();
1604 bool bIsBigEndian=isBigEndian();
1605
1606 if(nIndex<nNumberOfSections)
1607 {
1608 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1609 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_addralign),bIsBigEndian);
1610 }
1611
1612 return result;
1613 }
1614
getElf32_Shdr_entsize(quint32 nIndex)1615 quint32 XELF::getElf32_Shdr_entsize(quint32 nIndex)
1616 {
1617 quint32 result=0;
1618
1619 quint32 nNumberOfSections=getHdr32_shnum();
1620 quint32 offset=getHdr32_shoff();
1621 bool bIsBigEndian=isBigEndian();
1622
1623 if(nIndex<nNumberOfSections)
1624 {
1625 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1626 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_entsize),bIsBigEndian);
1627 }
1628
1629 return result;
1630 }
1631
setElf32_Shdr_name(quint32 nIndex,quint32 nValue)1632 void XELF::setElf32_Shdr_name(quint32 nIndex, quint32 nValue)
1633 {
1634 quint32 nNumberOfSections=getHdr32_shnum();
1635 quint32 offset=getHdr32_shoff();
1636 bool bIsBigEndian=isBigEndian();
1637
1638 if(nIndex<nNumberOfSections)
1639 {
1640 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1641 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_name),nValue,bIsBigEndian);
1642 }
1643 }
1644
setElf32_Shdr_type(quint32 nIndex,quint32 nValue)1645 void XELF::setElf32_Shdr_type(quint32 nIndex, quint32 nValue)
1646 {
1647 quint32 nNumberOfSections=getHdr32_shnum();
1648 quint32 offset=getHdr32_shoff();
1649 bool bIsBigEndian=isBigEndian();
1650
1651 if(nIndex<nNumberOfSections)
1652 {
1653 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1654 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_type),nValue,bIsBigEndian);
1655 }
1656 }
1657
setElf32_Shdr_flags(quint32 nIndex,quint32 nValue)1658 void XELF::setElf32_Shdr_flags(quint32 nIndex, quint32 nValue)
1659 {
1660 quint32 nNumberOfSections=getHdr32_shnum();
1661 quint32 offset=getHdr32_shoff();
1662 bool bIsBigEndian=isBigEndian();
1663
1664 if(nIndex<nNumberOfSections)
1665 {
1666 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1667 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_flags),nValue,bIsBigEndian);
1668 }
1669 }
1670
setElf32_Shdr_addr(quint32 nIndex,quint32 nValue)1671 void XELF::setElf32_Shdr_addr(quint32 nIndex, quint32 nValue)
1672 {
1673 quint32 nNumberOfSections=getHdr32_shnum();
1674 quint32 offset=getHdr32_shoff();
1675 bool bIsBigEndian=isBigEndian();
1676
1677 if(nIndex<nNumberOfSections)
1678 {
1679 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1680 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_addr),nValue,bIsBigEndian);
1681 }
1682 }
1683
setElf32_Shdr_offset(quint32 nIndex,quint32 nValue)1684 void XELF::setElf32_Shdr_offset(quint32 nIndex, quint32 nValue)
1685 {
1686 quint32 nNumberOfSections=getHdr32_shnum();
1687 quint32 offset=getHdr32_shoff();
1688 bool bIsBigEndian=isBigEndian();
1689
1690 if(nIndex<nNumberOfSections)
1691 {
1692 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1693 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_offset),nValue,bIsBigEndian);
1694 }
1695 }
1696
setElf32_Shdr_size(quint32 nIndex,quint32 nValue)1697 void XELF::setElf32_Shdr_size(quint32 nIndex, quint32 nValue)
1698 {
1699 quint32 nNumberOfSections=getHdr32_shnum();
1700 quint32 offset=getHdr32_shoff();
1701 bool bIsBigEndian=isBigEndian();
1702
1703 if(nIndex<nNumberOfSections)
1704 {
1705 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1706 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_size),nValue,bIsBigEndian);
1707 }
1708 }
1709
setElf32_Shdr_link(quint32 nIndex,quint32 nValue)1710 void XELF::setElf32_Shdr_link(quint32 nIndex, quint32 nValue)
1711 {
1712 quint32 nNumberOfSections=getHdr32_shnum();
1713 quint32 offset=getHdr32_shoff();
1714 bool bIsBigEndian=isBigEndian();
1715
1716 if(nIndex<nNumberOfSections)
1717 {
1718 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1719 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_link),nValue,bIsBigEndian);
1720 }
1721 }
1722
setElf32_Shdr_info(quint32 nIndex,quint32 nValue)1723 void XELF::setElf32_Shdr_info(quint32 nIndex, quint32 nValue)
1724 {
1725 quint32 nNumberOfSections=getHdr32_shnum();
1726 quint32 offset=getHdr32_shoff();
1727 bool bIsBigEndian=isBigEndian();
1728
1729 if(nIndex<nNumberOfSections)
1730 {
1731 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1732 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_info),nValue,bIsBigEndian);
1733 }
1734 }
1735
setElf32_Shdr_addralign(quint32 nIndex,quint32 nValue)1736 void XELF::setElf32_Shdr_addralign(quint32 nIndex, quint32 nValue)
1737 {
1738 quint32 nNumberOfSections=getHdr32_shnum();
1739 quint32 offset=getHdr32_shoff();
1740 bool bIsBigEndian=isBigEndian();
1741
1742 if(nIndex<nNumberOfSections)
1743 {
1744 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1745 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_addralign),nValue,bIsBigEndian);
1746 }
1747 }
1748
setElf32_Shdr_entsize(quint32 nIndex,quint32 nValue)1749 void XELF::setElf32_Shdr_entsize(quint32 nIndex, quint32 nValue)
1750 {
1751 quint32 nNumberOfSections=getHdr32_shnum();
1752 quint32 offset=getHdr32_shoff();
1753 bool bIsBigEndian=isBigEndian();
1754
1755 if(nIndex<nNumberOfSections)
1756 {
1757 offset+=nIndex*sizeof(XELF_DEF::Elf32_Shdr);
1758 write_uint32(offset+offsetof(XELF_DEF::Elf32_Shdr,sh_entsize),nValue,bIsBigEndian);
1759 }
1760 }
1761
getElf64_Shdr_name(quint32 nIndex)1762 quint32 XELF::getElf64_Shdr_name(quint32 nIndex)
1763 {
1764 quint32 result=0;
1765
1766 quint32 nNumberOfSections=getHdr64_shnum();
1767 quint64 offset=getHdr64_shoff();
1768 bool bIsBigEndian=isBigEndian();
1769
1770 if(nIndex<nNumberOfSections)
1771 {
1772 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1773 result=read_uint32(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_name),bIsBigEndian);
1774 }
1775
1776 return result;
1777 }
1778
getElf64_Shdr_type(quint32 nIndex)1779 quint32 XELF::getElf64_Shdr_type(quint32 nIndex)
1780 {
1781 quint32 result=0;
1782
1783 quint32 nNumberOfSections=getHdr64_shnum();
1784 quint64 offset=getHdr64_shoff();
1785 bool bIsBigEndian=isBigEndian();
1786
1787 if(nIndex<nNumberOfSections)
1788 {
1789 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1790 result=read_uint32(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_type),bIsBigEndian);
1791 }
1792
1793 return result;
1794 }
1795
getElf64_Shdr_flags(quint32 nIndex)1796 quint64 XELF::getElf64_Shdr_flags(quint32 nIndex)
1797 {
1798 quint64 result=0;
1799
1800 quint32 nNumberOfSections=getHdr64_shnum();
1801 quint64 offset=getHdr64_shoff();
1802 bool bIsBigEndian=isBigEndian();
1803
1804 if(nIndex<nNumberOfSections)
1805 {
1806 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1807 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_flags),bIsBigEndian);
1808 }
1809
1810 return result;
1811 }
1812
getElf64_Shdr_addr(quint32 nIndex)1813 quint64 XELF::getElf64_Shdr_addr(quint32 nIndex)
1814 {
1815 quint64 result=0;
1816
1817 quint32 nNumberOfSections=getHdr64_shnum();
1818 quint64 offset=getHdr64_shoff();
1819 bool bIsBigEndian=isBigEndian();
1820
1821 if(nIndex<nNumberOfSections)
1822 {
1823 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1824 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_addr),bIsBigEndian);
1825 }
1826
1827 return result;
1828 }
1829
getElf64_Shdr_offset(quint32 nIndex)1830 quint64 XELF::getElf64_Shdr_offset(quint32 nIndex)
1831 {
1832 quint64 result=0;
1833
1834 quint32 nNumberOfSections=getHdr64_shnum();
1835 quint64 offset=getHdr64_shoff();
1836 bool bIsBigEndian=isBigEndian();
1837
1838 if(nIndex<nNumberOfSections)
1839 {
1840 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1841 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_offset),bIsBigEndian);
1842 }
1843
1844 return result;
1845 }
1846
getElf64_Shdr_size(quint32 nIndex)1847 quint64 XELF::getElf64_Shdr_size(quint32 nIndex)
1848 {
1849 quint64 result=0;
1850
1851 quint32 nNumberOfSections=getHdr64_shnum();
1852 quint64 offset=getHdr64_shoff();
1853 bool bIsBigEndian=isBigEndian();
1854
1855 if(nIndex<nNumberOfSections)
1856 {
1857 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1858 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_size),bIsBigEndian);
1859 }
1860
1861 return result;
1862 }
1863
getElf64_Shdr_link(quint32 nIndex)1864 quint32 XELF::getElf64_Shdr_link(quint32 nIndex)
1865 {
1866 quint32 result=0;
1867
1868 quint32 nNumberOfSections=getHdr64_shnum();
1869 quint64 offset=getHdr64_shoff();
1870 bool bIsBigEndian=isBigEndian();
1871
1872 if(nIndex<nNumberOfSections)
1873 {
1874 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1875 result=read_uint32(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_link),bIsBigEndian);
1876 }
1877
1878 return result;
1879 }
1880
getElf64_Shdr_info(quint32 nIndex)1881 quint32 XELF::getElf64_Shdr_info(quint32 nIndex)
1882 {
1883 quint32 result=0;
1884
1885 quint32 nNumberOfSections=getHdr64_shnum();
1886 quint64 offset=getHdr64_shoff();
1887 bool bIsBigEndian=isBigEndian();
1888
1889 if(nIndex<nNumberOfSections)
1890 {
1891 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1892 result=read_uint32(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_info),bIsBigEndian);
1893 }
1894
1895 return result;
1896 }
1897
getElf64_Shdr_addralign(quint32 nIndex)1898 quint64 XELF::getElf64_Shdr_addralign(quint32 nIndex)
1899 {
1900 quint64 result=0;
1901
1902 quint32 nNumberOfSections=getHdr64_shnum();
1903 quint64 offset=getHdr64_shoff();
1904 bool bIsBigEndian=isBigEndian();
1905
1906 if(nIndex<nNumberOfSections)
1907 {
1908 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1909 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_addralign),bIsBigEndian);
1910 }
1911
1912 return result;
1913 }
1914
getElf64_Shdr_entsize(quint32 nIndex)1915 quint64 XELF::getElf64_Shdr_entsize(quint32 nIndex)
1916 {
1917 quint64 result=0;
1918
1919 quint32 nNumberOfSections=getHdr64_shnum();
1920 quint64 offset=getHdr64_shoff();
1921 bool bIsBigEndian=isBigEndian();
1922
1923 if(nIndex<nNumberOfSections)
1924 {
1925 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1926 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_entsize),bIsBigEndian);
1927 }
1928
1929 return result;
1930 }
1931
setElf64_Shdr_name(quint32 nIndex,quint32 nValue)1932 void XELF::setElf64_Shdr_name(quint32 nIndex, quint32 nValue)
1933 {
1934 quint32 nNumberOfSections=getHdr64_shnum();
1935 quint64 offset=getHdr64_shoff();
1936 bool bIsBigEndian=isBigEndian();
1937
1938 if(nIndex<nNumberOfSections)
1939 {
1940 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1941 write_uint32(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_name),nValue,bIsBigEndian);
1942 }
1943 }
1944
setElf64_Shdr_type(quint32 nIndex,quint32 nValue)1945 void XELF::setElf64_Shdr_type(quint32 nIndex, quint32 nValue)
1946 {
1947 quint32 nNumberOfSections=getHdr64_shnum();
1948 quint64 offset=getHdr64_shoff();
1949 bool bIsBigEndian=isBigEndian();
1950
1951 if(nIndex<nNumberOfSections)
1952 {
1953 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1954 write_uint32(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_type),nValue,bIsBigEndian);
1955 }
1956 }
1957
setElf64_Shdr_flags(quint32 nIndex,quint64 nValue)1958 void XELF::setElf64_Shdr_flags(quint32 nIndex, quint64 nValue)
1959 {
1960 quint32 nNumberOfSections=getHdr64_shnum();
1961 quint64 offset=getHdr64_shoff();
1962 bool bIsBigEndian=isBigEndian();
1963
1964 if(nIndex<nNumberOfSections)
1965 {
1966 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1967 write_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_flags),nValue,bIsBigEndian);
1968 }
1969 }
1970
setElf64_Shdr_addr(quint32 nIndex,quint64 nValue)1971 void XELF::setElf64_Shdr_addr(quint32 nIndex, quint64 nValue)
1972 {
1973 quint32 nNumberOfSections=getHdr64_shnum();
1974 quint64 offset=getHdr64_shoff();
1975 bool bIsBigEndian=isBigEndian();
1976
1977 if(nIndex<nNumberOfSections)
1978 {
1979 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1980 write_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_addr),nValue,bIsBigEndian);
1981 }
1982 }
1983
setElf64_Shdr_offset(quint32 nIndex,quint64 nValue)1984 void XELF::setElf64_Shdr_offset(quint32 nIndex, quint64 nValue)
1985 {
1986 quint32 nNumberOfSections=getHdr64_shnum();
1987 quint64 offset=getHdr64_shoff();
1988 bool bIsBigEndian=isBigEndian();
1989
1990 if(nIndex<nNumberOfSections)
1991 {
1992 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
1993 write_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_offset),nValue,bIsBigEndian);
1994 }
1995 }
1996
setElf64_Shdr_size(quint32 nIndex,quint64 nValue)1997 void XELF::setElf64_Shdr_size(quint32 nIndex, quint64 nValue)
1998 {
1999 quint32 nNumberOfSections=getHdr64_shnum();
2000 quint64 offset=getHdr64_shoff();
2001 bool bIsBigEndian=isBigEndian();
2002
2003 if(nIndex<nNumberOfSections)
2004 {
2005 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
2006 write_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_size),nValue,bIsBigEndian);
2007 }
2008 }
2009
setElf64_Shdr_link(quint32 nIndex,quint32 nValue)2010 void XELF::setElf64_Shdr_link(quint32 nIndex, quint32 nValue)
2011 {
2012 quint32 nNumberOfSections=getHdr64_shnum();
2013 quint64 offset=getHdr64_shoff();
2014 bool bIsBigEndian=isBigEndian();
2015
2016 if(nIndex<nNumberOfSections)
2017 {
2018 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
2019 write_uint32(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_link),nValue,bIsBigEndian);
2020 }
2021 }
2022
setElf64_Shdr_info(quint32 nIndex,quint32 nValue)2023 void XELF::setElf64_Shdr_info(quint32 nIndex, quint32 nValue)
2024 {
2025 quint32 nNumberOfSections=getHdr64_shnum();
2026 quint64 offset=getHdr64_shoff();
2027 bool bIsBigEndian=isBigEndian();
2028
2029 if(nIndex<nNumberOfSections)
2030 {
2031 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
2032 write_uint32(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_info),nValue,bIsBigEndian);
2033 }
2034 }
2035
setElf64_Shdr_addralign(quint32 nIndex,quint64 nValue)2036 void XELF::setElf64_Shdr_addralign(quint32 nIndex, quint64 nValue)
2037 {
2038 quint32 nNumberOfSections=getHdr64_shnum();
2039 quint64 offset=getHdr64_shoff();
2040 bool bIsBigEndian=isBigEndian();
2041
2042 if(nIndex<nNumberOfSections)
2043 {
2044 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
2045 write_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_addralign),nValue,bIsBigEndian);
2046 }
2047 }
2048
setElf64_Shdr_entsize(quint32 nIndex,quint64 nValue)2049 void XELF::setElf64_Shdr_entsize(quint32 nIndex, quint64 nValue)
2050 {
2051 quint32 nNumberOfSections=getHdr64_shnum();
2052 quint64 offset=getHdr64_shoff();
2053 bool bIsBigEndian=isBigEndian();
2054
2055 if(nIndex<nNumberOfSections)
2056 {
2057 offset+=nIndex*sizeof(XELF_DEF::Elf64_Shdr);
2058 write_uint64(offset+offsetof(XELF_DEF::Elf64_Shdr,sh_entsize),nValue,bIsBigEndian);
2059 }
2060 }
2061
getElf_Shdr_name(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2062 quint32 XELF::getElf_Shdr_name(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2063 {
2064 quint32 nResult=0;
2065
2066 if(nIndex<(quint32)pListSectionHeaders->count())
2067 {
2068 nResult=pListSectionHeaders->at(nIndex).sh_name;
2069 }
2070
2071 return nResult;
2072 }
2073
getElf_Shdr_type(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2074 quint32 XELF::getElf_Shdr_type(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2075 {
2076 quint32 nResult=0;
2077
2078 if(nIndex<(quint32)pListSectionHeaders->count())
2079 {
2080 nResult=pListSectionHeaders->at(nIndex).sh_type;
2081 }
2082
2083 return nResult;
2084 }
2085
getElf_Shdr_flags(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2086 quint64 XELF::getElf_Shdr_flags(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2087 {
2088 quint64 nResult=0;
2089
2090 if(nIndex<(quint32)pListSectionHeaders->count())
2091 {
2092 nResult=pListSectionHeaders->at(nIndex).sh_flags;
2093 }
2094
2095 return nResult;
2096 }
2097
getElf_Shdr_addr(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2098 quint64 XELF::getElf_Shdr_addr(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2099 {
2100 quint64 nResult=0;
2101
2102 if(nIndex<(quint32)pListSectionHeaders->count())
2103 {
2104 nResult=pListSectionHeaders->at(nIndex).sh_addr;
2105 }
2106
2107 return nResult;
2108 }
2109
getElf_Shdr_offset(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2110 quint64 XELF::getElf_Shdr_offset(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2111 {
2112 quint64 nResult=0;
2113
2114 if(nIndex<(quint32)pListSectionHeaders->count())
2115 {
2116 nResult=pListSectionHeaders->at(nIndex).sh_offset;
2117 }
2118
2119 return nResult;
2120 }
2121
getElf_Shdr_size(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2122 quint64 XELF::getElf_Shdr_size(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2123 {
2124 quint64 nResult=0;
2125
2126 if(nIndex<(quint32)pListSectionHeaders->count())
2127 {
2128 nResult=pListSectionHeaders->at(nIndex).sh_size;
2129 }
2130
2131 return nResult;
2132 }
2133
getElf_Shdr_link(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2134 quint32 XELF::getElf_Shdr_link(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2135 {
2136 quint32 nResult=0;
2137
2138 if(nIndex<(quint32)pListSectionHeaders->count())
2139 {
2140 nResult=pListSectionHeaders->at(nIndex).sh_link;
2141 }
2142
2143 return nResult;
2144 }
2145
getElf_Shdr_info(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2146 quint32 XELF::getElf_Shdr_info(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2147 {
2148 quint32 nResult=0;
2149
2150 if(nIndex<(quint32)pListSectionHeaders->count())
2151 {
2152 nResult=pListSectionHeaders->at(nIndex).sh_info;
2153 }
2154
2155 return nResult;
2156 }
2157
getElf_Shdr_addralign(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2158 quint64 XELF::getElf_Shdr_addralign(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2159 {
2160 quint64 nResult=0;
2161
2162 if(nIndex<(quint32)pListSectionHeaders->count())
2163 {
2164 nResult=pListSectionHeaders->at(nIndex).sh_addralign;
2165 }
2166
2167 return nResult;
2168 }
2169
getElf_Shdr_entsize(quint32 nIndex,QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)2170 quint64 XELF::getElf_Shdr_entsize(quint32 nIndex, QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
2171 {
2172 quint32 nResult=0;
2173
2174 if(nIndex<(quint32)pListSectionHeaders->count())
2175 {
2176 nResult=pListSectionHeaders->at(nIndex).sh_entsize;
2177 }
2178
2179 return nResult;
2180 }
2181
getShdrOffset(quint32 nIndex)2182 qint64 XELF::getShdrOffset(quint32 nIndex)
2183 {
2184 quint64 nResult=-1;
2185
2186 bool bIs64=is64();
2187 quint32 nNumberOfSections=0;
2188
2189 if(bIs64)
2190 {
2191 nNumberOfSections=getHdr64_shnum();
2192
2193 if(nIndex<nNumberOfSections)
2194 {
2195 nResult=getHdr64_shoff()+nIndex*sizeof(XELF_DEF::Elf64_Shdr);
2196 }
2197 }
2198 else
2199 {
2200 nNumberOfSections=getHdr32_shnum();
2201
2202 if(nIndex<nNumberOfSections)
2203 {
2204 nResult=getHdr32_shoff()+nIndex*sizeof(XELF_DEF::Elf32_Shdr);
2205 }
2206 }
2207
2208 return nResult;
2209 }
2210
getShdrSize()2211 qint64 XELF::getShdrSize()
2212 {
2213 quint64 nResult=0;
2214
2215 bool bIs64=is64();
2216
2217 if(bIs64)
2218 {
2219 nResult=sizeof(XELF_DEF::Elf64_Shdr);
2220 }
2221 else
2222 {
2223 nResult=sizeof(XELF_DEF::Elf32_Shdr);
2224 }
2225
2226 return nResult;
2227 }
2228
getElf32_PhdrList()2229 QList<XELF_DEF::Elf32_Phdr> XELF::getElf32_PhdrList()
2230 {
2231 QList<XELF_DEF::Elf32_Phdr> result;
2232
2233 quint32 nNumberOfProgramms=getHdr32_phnum();
2234 nNumberOfProgramms=qMin((quint32)1000,nNumberOfProgramms);
2235 quint32 nOffset=getHdr32_phoff();
2236 bool bIsBigEndian=isBigEndian();
2237
2238 for(quint32 i=0; i<nNumberOfProgramms; i++)
2239 {
2240 XELF_DEF::Elf32_Phdr record=_readElf32_Phdr(nOffset,bIsBigEndian);
2241
2242 result.append(record);
2243
2244 nOffset+=sizeof(XELF_DEF::Elf32_Phdr);
2245 }
2246
2247 return result;
2248 }
2249
getElf64_PhdrList()2250 QList<XELF_DEF::Elf64_Phdr> XELF::getElf64_PhdrList()
2251 {
2252 QList<XELF_DEF::Elf64_Phdr> result;
2253
2254 quint32 nNumberOfProgramms=getHdr64_phnum();
2255 nNumberOfProgramms=qMin((quint32)1000,nNumberOfProgramms);
2256 quint64 nOffset=getHdr64_phoff();
2257 bool bIsBigEndian=isBigEndian();
2258
2259 for(quint32 i=0; i<nNumberOfProgramms; i++)
2260 {
2261 XELF_DEF::Elf64_Phdr record=_readElf64_Phdr(nOffset,bIsBigEndian);
2262
2263 result.append(record);
2264
2265 nOffset+=sizeof(XELF_DEF::Elf64_Phdr);
2266 }
2267
2268 return result;
2269 }
2270
getElf_PhdrList()2271 QList<XELF_DEF::Elf_Phdr> XELF::getElf_PhdrList()
2272 {
2273 QList<XELF_DEF::Elf_Phdr> listResult;
2274
2275 bool bIs64=is64();
2276
2277 if(bIs64)
2278 {
2279 QList<XELF_DEF::Elf64_Phdr> listProgramHeaders=getElf64_PhdrList();
2280
2281 int nNumberOfPrograms=listProgramHeaders.count();
2282
2283 for(int i=0;i<nNumberOfPrograms;i++)
2284 {
2285 XELF_DEF::Elf_Phdr record={};
2286
2287 record.p_type=listProgramHeaders.at(i).p_type;
2288 record.p_flags=listProgramHeaders.at(i).p_flags;
2289 record.p_offset=listProgramHeaders.at(i).p_offset;
2290 record.p_vaddr=listProgramHeaders.at(i).p_vaddr;
2291 record.p_paddr=listProgramHeaders.at(i).p_paddr;
2292 record.p_filesz=listProgramHeaders.at(i).p_filesz;
2293 record.p_memsz=listProgramHeaders.at(i).p_memsz;
2294 record.p_align=listProgramHeaders.at(i).p_align;
2295
2296 listResult.append(record);
2297 }
2298 }
2299 else
2300 {
2301 QList<XELF_DEF::Elf32_Phdr> listProgramHeaders=getElf32_PhdrList();
2302
2303 int nNumberOfPrograms=listProgramHeaders.count();
2304
2305 for(int i=0;i<nNumberOfPrograms;i++)
2306 {
2307 XELF_DEF::Elf_Phdr record={};
2308
2309 record.p_type=listProgramHeaders.at(i).p_type;
2310 record.p_flags=listProgramHeaders.at(i).p_flags;
2311 record.p_offset=listProgramHeaders.at(i).p_offset;
2312 record.p_vaddr=listProgramHeaders.at(i).p_vaddr;
2313 record.p_paddr=listProgramHeaders.at(i).p_paddr;
2314 record.p_filesz=listProgramHeaders.at(i).p_filesz;
2315 record.p_memsz=listProgramHeaders.at(i).p_memsz;
2316 record.p_align=listProgramHeaders.at(i).p_align;
2317
2318 listResult.append(record);
2319 }
2320 }
2321
2322 return listResult;
2323 }
2324
getElf32_Phdr(quint32 nIndex)2325 XELF_DEF::Elf32_Phdr XELF::getElf32_Phdr(quint32 nIndex)
2326 {
2327 XELF_DEF::Elf32_Phdr result={};
2328
2329 quint32 nNumberOfPrograms=getHdr32_phnum();
2330 quint32 nOffset=getHdr32_phoff();
2331 bool bIsBigEndian=isBigEndian();
2332
2333 if(nIndex<nNumberOfPrograms)
2334 {
2335 nOffset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2336 result=_readElf32_Phdr(nOffset,bIsBigEndian);
2337 }
2338
2339 return result;
2340 }
2341
getElf64_Phdr(quint32 nIndex)2342 XELF_DEF::Elf64_Phdr XELF::getElf64_Phdr(quint32 nIndex)
2343 {
2344 XELF_DEF::Elf64_Phdr result={};
2345
2346 quint32 nNumberOfPrograms=getHdr64_phnum();
2347 quint64 nOffset=getHdr64_phoff();
2348 bool bIsBigEndian=isBigEndian();
2349
2350 if(nIndex<nNumberOfPrograms)
2351 {
2352 nOffset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2353 result=_readElf64_Phdr(nOffset,bIsBigEndian);
2354 }
2355
2356 return result;
2357 }
2358
_readElf32_Phdr(qint64 nOffset,bool bIsBigEndian)2359 XELF_DEF::Elf32_Phdr XELF::_readElf32_Phdr(qint64 nOffset, bool bIsBigEndian)
2360 {
2361 XELF_DEF::Elf32_Phdr result={};
2362
2363 result.p_type=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Phdr,p_type),bIsBigEndian);
2364 result.p_offset=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Phdr,p_offset),bIsBigEndian);
2365 result.p_vaddr=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Phdr,p_vaddr),bIsBigEndian);
2366 result.p_paddr=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Phdr,p_paddr),bIsBigEndian);
2367 result.p_filesz=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Phdr,p_filesz),bIsBigEndian);
2368 result.p_memsz=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Phdr,p_memsz),bIsBigEndian);
2369 result.p_flags=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Phdr,p_flags),bIsBigEndian);
2370 result.p_align=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Phdr,p_align),bIsBigEndian);
2371
2372 return result;
2373 }
2374
_readElf64_Phdr(qint64 nOffset,bool bIsBigEndian)2375 XELF_DEF::Elf64_Phdr XELF::_readElf64_Phdr(qint64 nOffset, bool bIsBigEndian)
2376 {
2377 XELF_DEF::Elf64_Phdr result={};
2378
2379 result.p_type=read_uint32(nOffset+offsetof(XELF_DEF::Elf64_Phdr,p_type),bIsBigEndian);
2380 result.p_offset=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Phdr,p_offset),bIsBigEndian);
2381 result.p_vaddr=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Phdr,p_vaddr),bIsBigEndian);
2382 result.p_paddr=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Phdr,p_paddr),bIsBigEndian);
2383 result.p_filesz=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Phdr,p_filesz),bIsBigEndian);
2384 result.p_memsz=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Phdr,p_memsz),bIsBigEndian);
2385 result.p_flags=read_uint32(nOffset+offsetof(XELF_DEF::Elf64_Phdr,p_flags),bIsBigEndian);
2386 result.p_align=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Phdr,p_align),bIsBigEndian);
2387
2388 return result;
2389 }
2390
getElf32_Phdr_type(quint32 nIndex)2391 quint32 XELF::getElf32_Phdr_type(quint32 nIndex)
2392 {
2393 quint32 result=0;
2394
2395 quint32 nNumberOfPrograms=getHdr32_phnum();
2396 quint32 offset=getHdr32_phoff();
2397 bool bIsBigEndian=isBigEndian();
2398
2399 if(nIndex<nNumberOfPrograms)
2400 {
2401 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2402 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_type),bIsBigEndian);
2403 }
2404
2405 return result;
2406 }
2407
getElf32_Phdr_offset(quint32 nIndex)2408 quint32 XELF::getElf32_Phdr_offset(quint32 nIndex)
2409 {
2410 quint32 result=0;
2411
2412 quint32 nNumberOfPrograms=getHdr32_phnum();
2413 quint32 offset=getHdr32_phoff();
2414 bool bIsBigEndian=isBigEndian();
2415
2416 if(nIndex<nNumberOfPrograms)
2417 {
2418 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2419 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_offset),bIsBigEndian);
2420 }
2421
2422 return result;
2423 }
2424
getElf32_Phdr_vaddr(quint32 nIndex)2425 quint32 XELF::getElf32_Phdr_vaddr(quint32 nIndex)
2426 {
2427 quint32 result=0;
2428
2429 quint32 nNumberOfPrograms=getHdr32_phnum();
2430 quint32 offset=getHdr32_phoff();
2431 bool bIsBigEndian=isBigEndian();
2432
2433 if(nIndex<nNumberOfPrograms)
2434 {
2435 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2436 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_vaddr),bIsBigEndian);
2437 }
2438
2439 return result;
2440 }
2441
getElf32_Phdr_paddr(quint32 nIndex)2442 quint32 XELF::getElf32_Phdr_paddr(quint32 nIndex)
2443 {
2444 quint32 result=0;
2445
2446 quint32 nNumberOfPrograms=getHdr32_phnum();
2447 quint32 offset=getHdr32_phoff();
2448 bool bIsBigEndian=isBigEndian();
2449
2450 if(nIndex<nNumberOfPrograms)
2451 {
2452 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2453 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_paddr),bIsBigEndian);
2454 }
2455
2456 return result;
2457 }
2458
getElf32_Phdr_filesz(quint32 nIndex)2459 quint32 XELF::getElf32_Phdr_filesz(quint32 nIndex)
2460 {
2461 quint32 result=0;
2462
2463 quint32 nNumberOfPrograms=getHdr32_phnum();
2464 quint32 offset=getHdr32_phoff();
2465 bool bIsBigEndian=isBigEndian();
2466
2467 if(nIndex<nNumberOfPrograms)
2468 {
2469 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2470 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_filesz),bIsBigEndian);
2471 }
2472
2473 return result;
2474 }
2475
getElf32_Phdr_memsz(quint32 nIndex)2476 quint32 XELF::getElf32_Phdr_memsz(quint32 nIndex)
2477 {
2478 quint32 result=0;
2479
2480 quint32 nNumberOfPrograms=getHdr32_phnum();
2481 quint32 offset=getHdr32_phoff();
2482 bool bIsBigEndian=isBigEndian();
2483
2484 if(nIndex<nNumberOfPrograms)
2485 {
2486 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2487 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_memsz),bIsBigEndian);
2488 }
2489
2490 return result;
2491 }
2492
getElf32_Phdr_flags(quint32 nIndex)2493 quint32 XELF::getElf32_Phdr_flags(quint32 nIndex)
2494 {
2495 quint32 result=0;
2496
2497 quint32 nNumberOfPrograms=getHdr32_phnum();
2498 quint32 offset=getHdr32_phoff();
2499 bool bIsBigEndian=isBigEndian();
2500
2501 if(nIndex<nNumberOfPrograms)
2502 {
2503 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2504 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_flags),bIsBigEndian);
2505 }
2506
2507 return result;
2508 }
2509
getElf32_Phdr_align(quint32 nIndex)2510 quint32 XELF::getElf32_Phdr_align(quint32 nIndex)
2511 {
2512 quint32 result=0;
2513
2514 quint32 nNumberOfPrograms=getHdr32_phnum();
2515 quint32 offset=getHdr32_phoff();
2516 bool bIsBigEndian=isBigEndian();
2517
2518 if(nIndex<nNumberOfPrograms)
2519 {
2520 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2521 result=read_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_align),bIsBigEndian);
2522 }
2523
2524 return result;
2525 }
2526
setElf32_Phdr_type(quint32 nIndex,quint32 nValue)2527 void XELF::setElf32_Phdr_type(quint32 nIndex, quint32 nValue)
2528 {
2529 quint32 nNumberOfPrograms=getHdr32_phnum();
2530 quint32 offset=getHdr32_phoff();
2531 bool bIsBigEndian=isBigEndian();
2532
2533 if(nIndex<nNumberOfPrograms)
2534 {
2535 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2536 write_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_type),nValue,bIsBigEndian);
2537 }
2538 }
2539
setElf32_Phdr_offset(quint32 nIndex,quint32 nValue)2540 void XELF::setElf32_Phdr_offset(quint32 nIndex, quint32 nValue)
2541 {
2542 quint32 nNumberOfPrograms=getHdr32_phnum();
2543 quint32 offset=getHdr32_phoff();
2544 bool bIsBigEndian=isBigEndian();
2545
2546 if(nIndex<nNumberOfPrograms)
2547 {
2548 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2549 write_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_offset),nValue,bIsBigEndian);
2550 }
2551 }
2552
setElf32_Phdr_vaddr(quint32 nIndex,quint32 nValue)2553 void XELF::setElf32_Phdr_vaddr(quint32 nIndex, quint32 nValue)
2554 {
2555 quint32 nNumberOfPrograms=getHdr32_phnum();
2556 quint32 offset=getHdr32_phoff();
2557 bool bIsBigEndian=isBigEndian();
2558
2559 if(nIndex<nNumberOfPrograms)
2560 {
2561 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2562 write_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_vaddr),nValue,bIsBigEndian);
2563 }
2564 }
2565
setElf32_Phdr_paddr(quint32 nIndex,quint32 nValue)2566 void XELF::setElf32_Phdr_paddr(quint32 nIndex, quint32 nValue)
2567 {
2568 quint32 nNumberOfPrograms=getHdr32_phnum();
2569 quint32 offset=getHdr32_phoff();
2570 bool bIsBigEndian=isBigEndian();
2571
2572 if(nIndex<nNumberOfPrograms)
2573 {
2574 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2575 write_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_paddr),nValue,bIsBigEndian);
2576 }
2577 }
2578
setElf32_Phdr_filesz(quint32 nIndex,quint32 nValue)2579 void XELF::setElf32_Phdr_filesz(quint32 nIndex, quint32 nValue)
2580 {
2581 quint32 nNumberOfPrograms=getHdr32_phnum();
2582 quint32 offset=getHdr32_phoff();
2583 bool bIsBigEndian=isBigEndian();
2584
2585 if(nIndex<nNumberOfPrograms)
2586 {
2587 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2588 write_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_filesz),nValue,bIsBigEndian);
2589 }
2590 }
2591
setElf32_Phdr_memsz(quint32 nIndex,quint32 nValue)2592 void XELF::setElf32_Phdr_memsz(quint32 nIndex, quint32 nValue)
2593 {
2594 quint32 nNumberOfPrograms=getHdr32_phnum();
2595 quint32 offset=getHdr32_phoff();
2596 bool bIsBigEndian=isBigEndian();
2597
2598 if(nIndex<nNumberOfPrograms)
2599 {
2600 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2601 write_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_memsz),nValue,bIsBigEndian);
2602 }
2603 }
2604
setElf32_Phdr_flags(quint32 nIndex,quint32 nValue)2605 void XELF::setElf32_Phdr_flags(quint32 nIndex, quint32 nValue)
2606 {
2607 quint32 nNumberOfPrograms=getHdr32_phnum();
2608 quint32 offset=getHdr32_phoff();
2609 bool bIsBigEndian=isBigEndian();
2610
2611 if(nIndex<nNumberOfPrograms)
2612 {
2613 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2614 write_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_flags),nValue,bIsBigEndian);
2615 }
2616 }
2617
setElf32_Phdr_align(quint32 nIndex,quint32 nValue)2618 void XELF::setElf32_Phdr_align(quint32 nIndex, quint32 nValue)
2619 {
2620 quint32 nNumberOfPrograms=getHdr32_phnum();
2621 quint32 offset=getHdr32_phoff();
2622 bool bIsBigEndian=isBigEndian();
2623
2624 if(nIndex<nNumberOfPrograms)
2625 {
2626 offset+=nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2627 write_uint32(offset+offsetof(XELF_DEF::Elf32_Phdr,p_align),nValue,bIsBigEndian);
2628 }
2629 }
2630
getElf64_Phdr_type(quint32 nIndex)2631 quint32 XELF::getElf64_Phdr_type(quint32 nIndex)
2632 {
2633 quint32 result=0;
2634
2635 quint32 nNumberOfPrograms=getHdr64_phnum();
2636 quint64 offset=getHdr64_phoff();
2637 bool bIsBigEndian=isBigEndian();
2638
2639 if(nIndex<nNumberOfPrograms)
2640 {
2641 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2642 result=read_uint32(offset+offsetof(XELF_DEF::Elf64_Phdr,p_type),bIsBigEndian);
2643 }
2644
2645 return result;
2646 }
2647
getElf64_Phdr_offset(quint32 nIndex)2648 quint64 XELF::getElf64_Phdr_offset(quint32 nIndex)
2649 {
2650 quint64 result=0;
2651
2652 quint32 nNumberOfPrograms=getHdr64_phnum();
2653 quint64 offset=getHdr64_phoff();
2654 bool bIsBigEndian=isBigEndian();
2655
2656 if(nIndex<nNumberOfPrograms)
2657 {
2658 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2659 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_offset),bIsBigEndian);
2660 }
2661
2662 return result;
2663 }
2664
getElf64_Phdr_vaddr(quint32 nIndex)2665 quint64 XELF::getElf64_Phdr_vaddr(quint32 nIndex)
2666 {
2667 quint64 result=0;
2668
2669 quint32 nNumberOfPrograms=getHdr64_phnum();
2670 quint64 offset=getHdr64_phoff();
2671 bool bIsBigEndian=isBigEndian();
2672
2673 if(nIndex<nNumberOfPrograms)
2674 {
2675 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2676 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_vaddr),bIsBigEndian);
2677 }
2678
2679 return result;
2680 }
2681
getElf64_Phdr_paddr(quint32 nIndex)2682 quint64 XELF::getElf64_Phdr_paddr(quint32 nIndex)
2683 {
2684 quint64 result=0;
2685
2686 quint32 nNumberOfPrograms=getHdr64_phnum();
2687 quint64 offset=getHdr64_phoff();
2688 bool bIsBigEndian=isBigEndian();
2689
2690 if(nIndex<nNumberOfPrograms)
2691 {
2692 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2693 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_paddr),bIsBigEndian);
2694 }
2695
2696 return result;
2697 }
2698
getElf64_Phdr_filesz(quint32 nIndex)2699 quint64 XELF::getElf64_Phdr_filesz(quint32 nIndex)
2700 {
2701 quint64 result=0;
2702
2703 quint32 nNumberOfPrograms=getHdr64_phnum();
2704 quint64 offset=getHdr64_phoff();
2705 bool bIsBigEndian=isBigEndian();
2706
2707 if(nIndex<nNumberOfPrograms)
2708 {
2709 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2710 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_filesz),bIsBigEndian);
2711 }
2712
2713 return result;
2714 }
2715
getElf64_Phdr_memsz(quint32 nIndex)2716 quint64 XELF::getElf64_Phdr_memsz(quint32 nIndex)
2717 {
2718 quint64 result=0;
2719
2720 quint32 nNumberOfPrograms=getHdr64_phnum();
2721 quint64 offset=getHdr64_phoff();
2722 bool bIsBigEndian=isBigEndian();
2723
2724 if(nIndex<nNumberOfPrograms)
2725 {
2726 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2727 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_memsz),bIsBigEndian);
2728 }
2729
2730 return result;
2731 }
2732
getElf64_Phdr_flags(quint32 nIndex)2733 quint32 XELF::getElf64_Phdr_flags(quint32 nIndex)
2734 {
2735 quint32 result=0;
2736
2737 quint32 nNumberOfPrograms=getHdr64_phnum();
2738 quint64 offset=getHdr64_phoff();
2739 bool bIsBigEndian=isBigEndian();
2740
2741 if(nIndex<nNumberOfPrograms)
2742 {
2743 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2744 result=read_uint32(offset+offsetof(XELF_DEF::Elf64_Phdr,p_flags),bIsBigEndian);
2745 }
2746
2747 return result;
2748 }
2749
getElf64_Phdr_align(quint32 nIndex)2750 quint64 XELF::getElf64_Phdr_align(quint32 nIndex)
2751 {
2752 quint64 result=0;
2753
2754 quint32 nNumberOfPrograms=getHdr64_phnum();
2755 quint64 offset=getHdr64_phoff();
2756 bool bIsBigEndian=isBigEndian();
2757
2758 if(nIndex<nNumberOfPrograms)
2759 {
2760 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2761 result=read_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_align),bIsBigEndian);
2762 }
2763
2764 return result;
2765 }
2766
setElf64_Phdr_type(quint32 nIndex,quint32 nValue)2767 void XELF::setElf64_Phdr_type(quint32 nIndex, quint32 nValue)
2768 {
2769 quint32 nNumberOfPrograms=getHdr64_phnum();
2770 quint64 offset=getHdr64_phoff();
2771 bool bIsBigEndian=isBigEndian();
2772
2773 if(nIndex<nNumberOfPrograms)
2774 {
2775 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2776 write_uint32(offset+offsetof(XELF_DEF::Elf64_Phdr,p_type),nValue,bIsBigEndian);
2777 }
2778 }
2779
setElf64_Phdr_offset(quint32 nIndex,quint64 nValue)2780 void XELF::setElf64_Phdr_offset(quint32 nIndex, quint64 nValue)
2781 {
2782 quint32 nNumberOfPrograms=getHdr64_phnum();
2783 quint64 offset=getHdr64_phoff();
2784 bool bIsBigEndian=isBigEndian();
2785
2786 if(nIndex<nNumberOfPrograms)
2787 {
2788 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2789 write_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_offset),nValue,bIsBigEndian);
2790 }
2791 }
2792
setElf64_Phdr_vaddr(quint32 nIndex,quint64 nValue)2793 void XELF::setElf64_Phdr_vaddr(quint32 nIndex, quint64 nValue)
2794 {
2795 quint32 nNumberOfPrograms=getHdr64_phnum();
2796 quint64 offset=getHdr64_phoff();
2797 bool bIsBigEndian=isBigEndian();
2798
2799 if(nIndex<nNumberOfPrograms)
2800 {
2801 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2802 write_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_vaddr),nValue,bIsBigEndian);
2803 }
2804 }
2805
setElf64_Phdr_paddr(quint32 nIndex,quint64 nValue)2806 void XELF::setElf64_Phdr_paddr(quint32 nIndex, quint64 nValue)
2807 {
2808 quint32 nNumberOfPrograms=getHdr64_phnum();
2809 quint64 offset=getHdr64_phoff();
2810 bool bIsBigEndian=isBigEndian();
2811
2812 if(nIndex<nNumberOfPrograms)
2813 {
2814 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2815 write_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_paddr),nValue,bIsBigEndian);
2816 }
2817 }
2818
setElf64_Phdr_filesz(quint32 nIndex,quint64 nValue)2819 void XELF::setElf64_Phdr_filesz(quint32 nIndex, quint64 nValue)
2820 {
2821 quint32 nNumberOfPrograms=getHdr64_phnum();
2822 quint64 offset=getHdr64_phoff();
2823 bool bIsBigEndian=isBigEndian();
2824
2825 if(nIndex<nNumberOfPrograms)
2826 {
2827 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2828 write_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_filesz),nValue,bIsBigEndian);
2829 }
2830 }
2831
setElf64_Phdr_memsz(quint32 nIndex,quint64 nValue)2832 void XELF::setElf64_Phdr_memsz(quint32 nIndex, quint64 nValue)
2833 {
2834 quint32 nNumberOfPrograms=getHdr64_phnum();
2835 quint64 offset=getHdr64_phoff();
2836 bool bIsBigEndian=isBigEndian();
2837
2838 if(nIndex<nNumberOfPrograms)
2839 {
2840 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2841 write_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_memsz),nValue,bIsBigEndian);
2842 }
2843 }
2844
setElf64_Phdr_flags(quint32 nIndex,quint32 nValue)2845 void XELF::setElf64_Phdr_flags(quint32 nIndex, quint32 nValue)
2846 {
2847 quint32 nNumberOfPrograms=getHdr64_phnum();
2848 quint64 offset=getHdr64_phoff();
2849 bool bIsBigEndian=isBigEndian();
2850
2851 if(nIndex<nNumberOfPrograms)
2852 {
2853 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2854 write_uint32(offset+offsetof(XELF_DEF::Elf64_Phdr,p_flags),nValue,bIsBigEndian);
2855 }
2856 }
2857
setElf64_Phdr_align(quint32 nIndex,quint64 nValue)2858 void XELF::setElf64_Phdr_align(quint32 nIndex, quint64 nValue)
2859 {
2860 quint32 nNumberOfPrograms=getHdr64_phnum();
2861 quint64 offset=getHdr64_phoff();
2862 bool bIsBigEndian=isBigEndian();
2863
2864 if(nIndex<nNumberOfPrograms)
2865 {
2866 offset+=nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2867 write_uint64(offset+offsetof(XELF_DEF::Elf64_Phdr,p_align),nValue,bIsBigEndian);
2868 }
2869 }
2870
getElf_Phdr_type(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)2871 quint32 XELF::getElf_Phdr_type(quint32 nIndex, QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
2872 {
2873 quint32 nResult=0;
2874
2875 if(nIndex<(quint32)pListProgramHeaders->count())
2876 {
2877 nResult=pListProgramHeaders->at(nIndex).p_type;
2878 }
2879
2880 return nResult;
2881 }
2882
getElf_Phdr_offset(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)2883 quint64 XELF::getElf_Phdr_offset(quint32 nIndex, QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
2884 {
2885 quint64 nResult=0;
2886
2887 if(nIndex<(quint32)pListProgramHeaders->count())
2888 {
2889 nResult=pListProgramHeaders->at(nIndex).p_offset;
2890 }
2891
2892 return nResult;
2893 }
2894
getElf_Phdr_vaddr(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)2895 quint64 XELF::getElf_Phdr_vaddr(quint32 nIndex, QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
2896 {
2897 quint64 nResult=0;
2898
2899 if(nIndex<(quint32)pListProgramHeaders->count())
2900 {
2901 nResult=pListProgramHeaders->at(nIndex).p_vaddr;
2902 }
2903
2904 return nResult;
2905 }
2906
getElf_Phdr_paddr(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)2907 quint64 XELF::getElf_Phdr_paddr(quint32 nIndex, QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
2908 {
2909 quint64 nResult=0;
2910
2911 if(nIndex<(quint32)pListProgramHeaders->count())
2912 {
2913 nResult=pListProgramHeaders->at(nIndex).p_paddr;
2914 }
2915
2916 return nResult;
2917 }
2918
getElf_Phdr_filesz(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)2919 quint64 XELF::getElf_Phdr_filesz(quint32 nIndex, QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
2920 {
2921 quint64 nResult=0;
2922
2923 if(nIndex<(quint32)pListProgramHeaders->count())
2924 {
2925 nResult=pListProgramHeaders->at(nIndex).p_filesz;
2926 }
2927
2928 return nResult;
2929 }
2930
getElf_Phdr_memsz(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)2931 quint64 XELF::getElf_Phdr_memsz(quint32 nIndex, QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
2932 {
2933 quint64 nResult=0;
2934
2935 if(nIndex<(quint32)pListProgramHeaders->count())
2936 {
2937 nResult=pListProgramHeaders->at(nIndex).p_memsz;
2938 }
2939
2940 return nResult;
2941 }
2942
getElf_Phdr_flags(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)2943 quint32 XELF::getElf_Phdr_flags(quint32 nIndex, QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
2944 {
2945 quint32 nResult=0;
2946
2947 if(nIndex<(quint32)pListProgramHeaders->count())
2948 {
2949 nResult=pListProgramHeaders->at(nIndex).p_flags;
2950 }
2951
2952 return nResult;
2953 }
2954
getElf_Phdr_align(quint32 nIndex,QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)2955 quint64 XELF::getElf_Phdr_align(quint32 nIndex, QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
2956 {
2957 quint64 nResult=0;
2958
2959 if(nIndex<(quint32)pListProgramHeaders->count())
2960 {
2961 nResult=pListProgramHeaders->at(nIndex).p_align;
2962 }
2963
2964 return nResult;
2965 }
2966
getPhdrOffset(quint32 nIndex)2967 qint64 XELF::getPhdrOffset(quint32 nIndex)
2968 {
2969 quint64 nResult=-1;
2970
2971 bool bIs64=is64();
2972 quint32 nNumberOfPrograms=0;
2973
2974 if(bIs64)
2975 {
2976 nNumberOfPrograms=getHdr64_phnum();
2977
2978 if(nIndex<nNumberOfPrograms)
2979 {
2980 nResult=getHdr64_phoff()+nIndex*sizeof(XELF_DEF::Elf64_Phdr);
2981 }
2982 }
2983 else
2984 {
2985 nNumberOfPrograms=getHdr32_phnum();
2986
2987 if(nIndex<nNumberOfPrograms)
2988 {
2989 nResult=getHdr32_phoff()+nIndex*sizeof(XELF_DEF::Elf32_Phdr);
2990 }
2991 }
2992
2993 return nResult;
2994 }
2995
getPhdrSize()2996 qint64 XELF::getPhdrSize()
2997 {
2998 quint64 nResult=0;
2999
3000 bool bIs64=is64();
3001
3002 if(bIs64)
3003 {
3004 nResult=sizeof(XELF_DEF::Elf64_Phdr);
3005 }
3006 else
3007 {
3008 nResult=sizeof(XELF_DEF::Elf32_Phdr);
3009 }
3010
3011 return nResult;
3012 }
3013
getSectionIndexByName(QString sSectionName)3014 int XELF::getSectionIndexByName(QString sSectionName)
3015 {
3016 int nResult=-1;
3017
3018 if(is64())
3019 {
3020 for(quint32 i=0; i<getHdr64_shnum(); i++)
3021 {
3022 quint32 nCurrentNameIndex=getElf64_Shdr_name(i);
3023
3024 if(getStringFromMainSection(nCurrentNameIndex)==sSectionName)
3025 {
3026 nResult=i;
3027 break;
3028 }
3029 }
3030 }
3031 else
3032 {
3033 for(quint32 i=0; i<getHdr32_shnum(); i++)
3034 {
3035 quint32 nCurrentNameIndex=getElf32_Shdr_name(i);
3036
3037 if(getStringFromMainSection(nCurrentNameIndex)==sSectionName)
3038 {
3039 nResult=i;
3040 break;
3041 }
3042 }
3043 }
3044
3045 return nResult;
3046 }
3047
getSectionByName(QString sSectionName)3048 QByteArray XELF::getSectionByName(QString sSectionName)
3049 {
3050 QByteArray baResult;
3051
3052 quint32 nIndex=getSectionIndexByName(sSectionName);
3053
3054 if(nIndex!=(quint32)-1)
3055 {
3056 baResult=getSection(nIndex);
3057 }
3058
3059 return baResult;
3060 }
3061
getProgramInterpreterName()3062 XBinary::OS_ANSISTRING XELF::getProgramInterpreterName()
3063 {
3064 QList<XELF_DEF::Elf_Phdr> listProgramHeaders=getElf_PhdrList();
3065
3066 return getProgramInterpreterName(&listProgramHeaders);
3067 }
3068
getProgramInterpreterName(QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)3069 XBinary::OS_ANSISTRING XELF::getProgramInterpreterName(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
3070 {
3071 OS_ANSISTRING result={};
3072
3073 QList<XELF_DEF::Elf_Phdr> listInterps=_getPrograms(pListProgramHeaders,XELF_DEF::PT_INTERP);
3074
3075 if(listInterps.count())
3076 {
3077 result=getOsAnsiString(listInterps.at(0).p_offset,listInterps.at(0).p_filesz);
3078 }
3079
3080 return result;
3081 }
3082
getCommentStrings()3083 QList<QString> XELF::getCommentStrings()
3084 {
3085 // TODO Optimize
3086 return getCommentStrings(getSectionIndexByName(".comment"));
3087 }
3088
getCommentStrings(int nSection)3089 QList<QString> XELF::getCommentStrings(int nSection)
3090 {
3091 return getStringsFromSection(nSection).values();
3092 }
3093
getNotes()3094 QList<XELF::NOTE> XELF::getNotes()
3095 {
3096 QList<XELF_DEF::Elf_Phdr> listProgramHeaders=getElf_PhdrList();
3097
3098 return getNotes(&listProgramHeaders);
3099 }
3100
3101 //QString XELF::getCompatibleKernelVersion()
3102 //{
3103 // QString sResult;
3104
3105 // QByteArray baData=getSectionByName(".note.ABI-tag");
3106 // bool bIsBigEndian=isBigEndian();
3107 // NOTE note=getNote(baData,bIsBigEndian);
3108
3109 // if((note.nType==1)&&(note.name=="GNU"))
3110 // {
3111 // quint32 kv[4];
3112 // kv[0]=_read_uint32(note.desc.data()+0,bIsBigEndian);
3113 // kv[1]=_read_uint32(note.desc.data()+4,bIsBigEndian);
3114 // kv[2]=_read_uint32(note.desc.data()+8,bIsBigEndian);
3115 // kv[3]=_read_uint32(note.desc.data()+12,bIsBigEndian);
3116
3117 // if(kv[0]==0)
3118 // {
3119 // sResult=QString("%1.%2.%3").arg(QString::number(kv[1]),QString::number(kv[2]),QString::number(kv[3]));
3120 // }
3121 // }
3122
3123 // return sResult;
3124 //}
3125
getNotes(QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)3126 QList<XELF::NOTE> XELF::getNotes(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
3127 {
3128 QList<NOTE> listResult;
3129
3130 QList<XELF_DEF::Elf_Phdr> listNotes=_getPrograms(pListProgramHeaders,XELF_DEF::PT_NOTE);
3131
3132 bool bIsBigEndian=isBigEndian();
3133
3134 int nNumberOfNotes=listNotes.count();
3135
3136 for(int i=0;i<nNumberOfNotes;i++)
3137 {
3138 qint64 nOffset=listNotes.at(i).p_offset;
3139 qint64 nSize=listNotes.at(i).p_filesz;
3140
3141 listResult=_getNotes(nOffset,nSize,bIsBigEndian);
3142 }
3143
3144 return listResult;
3145 }
3146
_getNotes(qint64 nOffset,qint64 nSize,bool bIsBigEndian)3147 QList<XELF::NOTE> XELF::_getNotes(qint64 nOffset, qint64 nSize, bool bIsBigEndian)
3148 {
3149 QList<NOTE> listResult;
3150
3151 int nNumberOfRecords=0;
3152
3153 while(nSize>0)
3154 {
3155 NOTE note=_readNote(nOffset,nSize,bIsBigEndian);
3156
3157 if(note.nSize)
3158 {
3159 listResult.append(note);
3160
3161 nOffset+=note.nSize;
3162 nSize-=note.nSize;
3163 }
3164 else
3165 {
3166 break;
3167 }
3168
3169 nNumberOfRecords++;
3170
3171 if(nNumberOfRecords>1000)
3172 {
3173 break;
3174 }
3175 }
3176
3177 return listResult;
3178 }
3179
_readNote(qint64 nOffset,qint64 nSize,bool bIsBigEndian)3180 XELF::NOTE XELF::_readNote(qint64 nOffset, qint64 nSize, bool bIsBigEndian)
3181 {
3182 NOTE result={};
3183
3184 if(nSize>=6)
3185 {
3186 quint16 nNameLength= read_uint32(nOffset+0,bIsBigEndian);
3187 quint16 nDescLength= read_uint32(nOffset+4,bIsBigEndian);
3188 quint16 nType= read_uint32(nOffset+8,bIsBigEndian);
3189
3190 qint32 nNoteSize=12+S_ALIGN_UP(nNameLength,4)+S_ALIGN_UP(nDescLength,4);
3191
3192 if(nSize>=nNoteSize)
3193 {
3194 result.nOffset=nOffset;
3195 result.nSize=nNoteSize;
3196 result.nType=nType;
3197
3198 if(nNameLength>=1)
3199 {
3200 result.sName=read_ansiString(nOffset+12,nNameLength-1);
3201 }
3202
3203 result.nDataOffset=nOffset+12+S_ALIGN_UP(nNameLength,4);
3204 result.nDataSize=qMax((nOffset+nSize)-result.nDataOffset,(qint64)0);
3205 }
3206 }
3207
3208 return result;
3209 }
3210
isNotePresent(QList<NOTE> * pListNotes,QString sName)3211 bool XELF::isNotePresent(QList<NOTE> *pListNotes, QString sName)
3212 {
3213 bool bResult=false;
3214
3215 for(int i=0;i<pListNotes->count();i++)
3216 {
3217 if(pListNotes->at(i).sName==sName)
3218 {
3219 bResult=true;
3220 false;
3221 }
3222 }
3223
3224 return bResult;
3225 }
3226
getNote(QList<NOTE> * pListNotes,QString sName)3227 XELF::NOTE XELF::getNote(QList<NOTE> *pListNotes, QString sName)
3228 {
3229 NOTE result={};
3230
3231 for(int i=0;i<pListNotes->count();i++)
3232 {
3233 if(pListNotes->at(i).sName==sName)
3234 {
3235 result=pListNotes->at(i);
3236 false;
3237 }
3238 }
3239
3240 return result;
3241 }
3242
getTagStructs()3243 QList<XELF::TAG_STRUCT> XELF::getTagStructs()
3244 {
3245 _MEMORY_MAP memoryMap=getMemoryMap();
3246 QList<XELF_DEF::Elf_Phdr> listProgramHeaders=getElf_PhdrList();
3247
3248 return getTagStructs(&listProgramHeaders,&memoryMap);
3249 }
3250
getTagStructs(QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders,XBinary::_MEMORY_MAP * pMemoryMap)3251 QList<XELF::TAG_STRUCT> XELF::getTagStructs(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders, XBinary::_MEMORY_MAP *pMemoryMap)
3252 {
3253 QList<TAG_STRUCT> listResult;
3254
3255 bool bIs64=is64();
3256 bool bIsBigEndian=isBigEndian();
3257
3258 QList<XELF_DEF::Elf_Phdr> listTags=_getPrograms(pListProgramHeaders,XELF_DEF::PT_DYNAMIC);
3259
3260 int nNumberOfTags=listTags.count();
3261
3262 for(int i=0;i<nNumberOfTags;i++)
3263 {
3264 qint64 nOffset=listTags.at(i).p_offset; // Check image
3265 qint64 nSize=listTags.at(i).p_filesz;
3266
3267 if(isOffsetAndSizeValid(pMemoryMap,nOffset,nSize))
3268 {
3269 listResult.append(_getTagStructs(nOffset,nSize,bIs64,bIsBigEndian));
3270 }
3271 }
3272
3273 return listResult;
3274 }
3275
_getTagStructs(qint64 nOffset,qint64 nSize,bool bIs64,bool bIsBigEndian)3276 QList<XELF::TAG_STRUCT> XELF::_getTagStructs(qint64 nOffset, qint64 nSize, bool bIs64, bool bIsBigEndian)
3277 {
3278 QList<TAG_STRUCT> listResult;
3279
3280 while(nSize>0)
3281 {
3282 TAG_STRUCT tagStruct={};
3283 tagStruct.nOffset=nOffset;
3284
3285 if(bIs64)
3286 {
3287 tagStruct.nTag=read_int64(nOffset,bIsBigEndian);
3288 tagStruct.nValue=read_int64(nOffset+8,bIsBigEndian);
3289 nOffset+=16;
3290 nSize-=16;
3291 }
3292 else
3293 {
3294 tagStruct.nTag=read_int32(nOffset,bIsBigEndian);
3295 tagStruct.nValue=read_int32(nOffset+4,bIsBigEndian);
3296 nOffset+=8;
3297 nSize-=8;
3298 }
3299
3300 if(tagStruct.nTag)
3301 {
3302 listResult.append(tagStruct);
3303 }
3304 else
3305 {
3306 break;
3307 }
3308 }
3309
3310 return listResult;
3311 }
3312
_getTagStructs(QList<XELF::TAG_STRUCT> * pListTagStructs,qint64 nTag)3313 QList<XELF::TAG_STRUCT> XELF::_getTagStructs(QList<XELF::TAG_STRUCT> *pListTagStructs, qint64 nTag)
3314 {
3315 QList<TAG_STRUCT> listResult;
3316
3317 int nNumberOfTags=pListTagStructs->count();
3318
3319 for(int i=0;i<nNumberOfTags;i++)
3320 {
3321 if(pListTagStructs->at(i).nTag==nTag)
3322 {
3323 listResult.append(pListTagStructs->at(i));
3324 }
3325 }
3326
3327 return listResult;
3328 }
3329
getDynamicArraySize()3330 qint64 XELF::getDynamicArraySize()
3331 {
3332 quint64 nResult=0;
3333
3334 bool bIs64=is64();
3335
3336 if(bIs64)
3337 {
3338 nResult=16; // TODO defs
3339 }
3340 else
3341 {
3342 nResult=8; // TODO defs
3343 }
3344
3345 return nResult;
3346 }
3347
getDynamicArrayTag(qint64 nOffset)3348 qint64 XELF::getDynamicArrayTag(qint64 nOffset)
3349 {
3350 qint64 nResult=0;
3351
3352 bool bIs64=is64();
3353 bool bIsBigEndian=isBigEndian();
3354
3355 if(bIs64)
3356 {
3357 nResult=read_int64(nOffset,bIsBigEndian);
3358 }
3359 else
3360 {
3361 nResult=read_int32(nOffset,bIsBigEndian);
3362 }
3363
3364 return nResult;
3365 }
3366
getDynamicArrayValue(qint64 nOffset)3367 qint64 XELF::getDynamicArrayValue(qint64 nOffset)
3368 {
3369 qint64 nResult=0;
3370
3371 bool bIs64=is64();
3372 bool bIsBigEndian=isBigEndian();
3373
3374 if(bIs64)
3375 {
3376 nResult=read_int64(nOffset+8,bIsBigEndian);
3377 }
3378 else
3379 {
3380 nResult=read_int32(nOffset+4,bIsBigEndian);
3381 }
3382
3383 return nResult;
3384 }
3385
setDynamicArrayTag(qint64 nOffset,qint64 nValue)3386 void XELF::setDynamicArrayTag(qint64 nOffset, qint64 nValue)
3387 {
3388 bool bIs64=is64();
3389 bool bIsBigEndian=isBigEndian();
3390
3391 if(bIs64)
3392 {
3393 write_int64(nOffset,nValue,bIsBigEndian);
3394 }
3395 else
3396 {
3397 write_int32(nOffset,(qint32)nValue,bIsBigEndian);
3398 }
3399 }
3400
setDynamicArrayValue(qint64 nOffset,qint64 nValue)3401 void XELF::setDynamicArrayValue(qint64 nOffset, qint64 nValue)
3402 {
3403 bool bIs64=is64();
3404 bool bIsBigEndian=isBigEndian();
3405
3406 if(bIs64)
3407 {
3408 write_int64(nOffset+8,nValue,bIsBigEndian);
3409 }
3410 else
3411 {
3412 write_int32(nOffset+4,(qint32)nValue,bIsBigEndian);
3413 }
3414 }
3415
getStringTable()3416 XBinary::OFFSETSIZE XELF::getStringTable()
3417 {
3418 _MEMORY_MAP memoryMap=getMemoryMap();
3419 QList<TAG_STRUCT> listStructs=getTagStructs();
3420
3421 return getStringTable(&memoryMap,&listStructs);
3422 }
3423
getStringTable(XBinary::_MEMORY_MAP * pMemoryMap,QList<XELF::TAG_STRUCT> * pListTagStructs)3424 XBinary::OFFSETSIZE XELF::getStringTable(XBinary::_MEMORY_MAP *pMemoryMap, QList<XELF::TAG_STRUCT> *pListTagStructs)
3425 {
3426 OFFSETSIZE result={};
3427
3428 QList<TAG_STRUCT> listStrTab=_getTagStructs(pListTagStructs,XELF_DEF::DT_STRTAB);
3429 QList<TAG_STRUCT> listStrSize=_getTagStructs(pListTagStructs,XELF_DEF::DT_STRSZ);
3430
3431 if(listStrTab.count()&&listStrSize.count())
3432 {
3433 qint64 nOffset=addressToOffset(pMemoryMap,listStrTab.at(0).nValue);
3434 qint64 nSize=listStrSize.at(0).nValue;
3435
3436 if(isOffsetAndSizeValid(pMemoryMap,nOffset,nSize))
3437 {
3438 result.nOffset=nOffset;
3439 result.nSize=nSize;
3440 }
3441 }
3442
3443 return result;
3444 }
3445
getLibraries()3446 QList<QString> XELF::getLibraries()
3447 {
3448 _MEMORY_MAP memoryMap=getMemoryMap();
3449 QList<TAG_STRUCT> listTagStructs=getTagStructs();
3450
3451 return getLibraries(&memoryMap,&listTagStructs);
3452 }
3453
getLibraries(_MEMORY_MAP * pMemoryMap,QList<XELF::TAG_STRUCT> * pList)3454 QList<QString> XELF::getLibraries(_MEMORY_MAP *pMemoryMap,QList<XELF::TAG_STRUCT> *pList)
3455 {
3456 QList<QString> listResult;
3457
3458 QList<TAG_STRUCT> listNeeded=_getTagStructs(pList,XELF_DEF::DT_NEEDED);
3459
3460 OFFSETSIZE offsetSize=getStringTable(pMemoryMap,pList);
3461
3462 if(offsetSize.nSize)
3463 {
3464 qint64 nOffset=offsetSize.nOffset;
3465
3466 QByteArray baSection=read_array(nOffset,offsetSize.nSize);
3467
3468 qint64 nSectionTableSize=baSection.size();
3469
3470 int nNumberOfNeededs=listNeeded.count();
3471
3472 for(int i=0;i<nNumberOfNeededs;i++)
3473 {
3474 qint64 nValue=listNeeded.at(i).nValue;
3475
3476 if(nValue<nSectionTableSize)
3477 {
3478 QString sLibrary=baSection.data()+nValue;
3479
3480 listResult.append(sLibrary);
3481 }
3482 }
3483 }
3484
3485 return listResult;
3486 }
3487
getRunPath()3488 XBinary::OS_ANSISTRING XELF::getRunPath()
3489 {
3490 _MEMORY_MAP memoryMap=getMemoryMap();
3491 QList<TAG_STRUCT> listTagStructs=getTagStructs();
3492
3493 return getRunPath(&memoryMap,&listTagStructs);
3494 }
3495
getRunPath(XBinary::_MEMORY_MAP * pMemoryMap,QList<XELF::TAG_STRUCT> * pListTagStructs)3496 XBinary::OS_ANSISTRING XELF::getRunPath(XBinary::_MEMORY_MAP *pMemoryMap, QList<XELF::TAG_STRUCT> *pListTagStructs)
3497 {
3498 OS_ANSISTRING result={};
3499
3500 QList<TAG_STRUCT> listRunPath=_getTagStructs(pListTagStructs,XELF_DEF::DT_RUNPATH);
3501 QList<TAG_STRUCT> listStrTab=_getTagStructs(pListTagStructs,XELF_DEF::DT_STRTAB);
3502 QList<TAG_STRUCT> listStrSize=_getTagStructs(pListTagStructs,XELF_DEF::DT_STRSZ);
3503
3504 if(listStrTab.count()&&listStrSize.count()&&listRunPath.count())
3505 {
3506 qint64 nOffset=addressToOffset(pMemoryMap,listStrTab.at(0).nValue);
3507 qint64 nSize=listStrSize.at(0).nValue;
3508 qint64 nRunPath=listRunPath.at(0).nValue;
3509
3510 if(nRunPath<nSize)
3511 {
3512 result.nOffset=nOffset+nRunPath;
3513 result.sAnsiString=read_ansiString(result.nOffset);
3514 result.nSize=result.sAnsiString.length();
3515 }
3516 }
3517
3518 return result;
3519 }
3520
getDynamicTags()3521 QMap<quint64, QString> XELF::getDynamicTags()
3522 {
3523 QMap<quint64, QString> mapResult;
3524
3525 mapResult.insert(0,"DT_NULL");
3526 mapResult.insert(1,"DT_NEEDED");
3527 mapResult.insert(2,"DT_PLTRELSZ");
3528 mapResult.insert(3,"DT_PLTGOT");
3529 mapResult.insert(4,"DT_HASH");
3530 mapResult.insert(5,"DT_STRTAB");
3531 mapResult.insert(6,"DT_SYMTAB");
3532 mapResult.insert(7,"DT_RELA");
3533 mapResult.insert(8,"DT_RELASZ");
3534 mapResult.insert(9,"DT_RELAENT");
3535 mapResult.insert(10,"DT_STRSZ");
3536 mapResult.insert(11,"DT_SYMENT");
3537 mapResult.insert(12,"DT_INIT");
3538 mapResult.insert(13,"DT_FINI");
3539 mapResult.insert(14,"DT_SONAME");
3540 mapResult.insert(15,"DT_RPATH");
3541 mapResult.insert(16,"DT_SYMBOLIC");
3542 mapResult.insert(17,"DT_REL");
3543 mapResult.insert(18,"DT_RELSZ");
3544 mapResult.insert(19,"DT_RELENT");
3545 mapResult.insert(20,"DT_PLTREL");
3546 mapResult.insert(21,"DT_DEBUG");
3547 mapResult.insert(22,"DT_TEXTREL");
3548 mapResult.insert(23,"DT_JMPREL");
3549 mapResult.insert(24,"DT_BIND_NOW");
3550 mapResult.insert(25,"DT_INIT_ARRAY");
3551 mapResult.insert(26,"DT_FINI_ARRAY");
3552 mapResult.insert(27,"DT_INIT_ARRAYSZ");
3553 mapResult.insert(28,"DT_FINI_ARRAYSZ");
3554 mapResult.insert(29,"DT_RUNPATH");
3555 mapResult.insert(30,"DT_FLAGS");
3556 mapResult.insert(32,"DT_PREINIT_ARRAY"); // DT_ENCODING
3557 mapResult.insert(33,"DT_PREINIT_ARRAYSZ");
3558 mapResult.insert(0x6000000d,"DT_LOOS");
3559 mapResult.insert(0x6000000e,"DT_SUNW_RTLDINF");
3560 mapResult.insert(0x6ffff000,"DT_HIOS");
3561 mapResult.insert(0x6ffffd00,"DT_VALRNGLO");
3562 mapResult.insert(0x6ffffdf8,"DT_CHECKSUM");
3563 mapResult.insert(0x6ffffdf9,"DT_PLTPADSZ");
3564 mapResult.insert(0x6ffffdfa,"DT_MOVEENT");
3565 mapResult.insert(0x6ffffdfb,"DT_MOVESZ");
3566 mapResult.insert(0x6ffffdfc,"DT_FEATURE_1");
3567 mapResult.insert(0x6ffffdfd,"DT_POSFLAG_1");
3568 mapResult.insert(0x6ffffdfe,"DT_SYMINSZ");
3569 mapResult.insert(0x6ffffdff,"DT_SYMINENT");
3570 mapResult.insert(0x6ffffdff,"DT_VALRNGHI");
3571 mapResult.insert(0x6ffffe00,"DT_ADDRRNGLO");
3572 mapResult.insert(0x6ffffef5,"DT_GNU_HASH");
3573 mapResult.insert(0x6ffffefa,"DT_CONFIG");
3574 mapResult.insert(0x6ffffefb,"DT_DEPAUDIT");
3575 mapResult.insert(0x6ffffefc,"DT_AUDIT");
3576 mapResult.insert(0x6ffffefd,"DT_PLTPAD");
3577 mapResult.insert(0x6ffffefe,"DT_MOVETAB");
3578 mapResult.insert(0x6ffffeff,"DT_SYMINFO");
3579 mapResult.insert(0x6ffffeff,"DT_ADDRRNGHI");
3580 mapResult.insert(0x6ffffff0,"DT_VERSYM");
3581 mapResult.insert(0x6ffffff9,"DT_RELACOUNT");
3582 mapResult.insert(0x6ffffffa,"DT_RELCOUNT");
3583 mapResult.insert(0x6ffffffb,"DT_FLAGS_1");
3584 mapResult.insert(0x6ffffffc,"DT_VERDEF");
3585 mapResult.insert(0x6ffffffd,"DT_VERDEFNUM");
3586 mapResult.insert(0x6ffffffe,"DT_VERNEED");
3587 mapResult.insert(0x6fffffff,"DT_VERNEEDNUM");
3588 mapResult.insert(0x70000000,"DT_LOPROC");
3589 mapResult.insert(0x70000001,"DT_SPARC_REGISTER");
3590 mapResult.insert(0x7ffffffd,"DT_AUXILIARY");
3591 mapResult.insert(0x7ffffffe,"DT_USED");
3592 mapResult.insert(0x7fffffff,"DT_HIPROC"); // DT_FILTER
3593
3594 return mapResult;
3595 }
3596
getDynamicTagsS()3597 QMap<quint64, QString> XELF::getDynamicTagsS()
3598 {
3599 QMap<quint64, QString> mapResult;
3600
3601 mapResult.insert(0,"NULL");
3602 mapResult.insert(1,"NEEDED");
3603 mapResult.insert(2,"PLTRELSZ");
3604 mapResult.insert(3,"PLTGOT");
3605 mapResult.insert(4,"HASH");
3606 mapResult.insert(5,"STRTAB");
3607 mapResult.insert(6,"SYMTAB");
3608 mapResult.insert(7,"RELA");
3609 mapResult.insert(8,"RELASZ");
3610 mapResult.insert(9,"RELAENT");
3611 mapResult.insert(10,"STRSZ");
3612 mapResult.insert(11,"SYMENT");
3613 mapResult.insert(12,"INIT");
3614 mapResult.insert(13,"FINI");
3615 mapResult.insert(14,"SONAME");
3616 mapResult.insert(15,"RPATH");
3617 mapResult.insert(16,"SYMBOLIC");
3618 mapResult.insert(17,"REL");
3619 mapResult.insert(18,"RELSZ");
3620 mapResult.insert(19,"RELENT");
3621 mapResult.insert(20,"PLTREL");
3622 mapResult.insert(21,"DEBUG");
3623 mapResult.insert(22,"TEXTREL");
3624 mapResult.insert(23,"JMPREL");
3625 mapResult.insert(24,"BIND_NOW");
3626 mapResult.insert(25,"INIT_ARRAY");
3627 mapResult.insert(26,"FINI_ARRAY");
3628 mapResult.insert(27,"INIT_ARRAYSZ");
3629 mapResult.insert(28,"FINI_ARRAYSZ");
3630 mapResult.insert(29,"RUNPATH");
3631 mapResult.insert(30,"FLAGS");
3632 mapResult.insert(32,"PREINIT_ARRAY"); // ENCODING
3633 mapResult.insert(33,"PREINIT_ARRAYSZ");
3634 mapResult.insert(0x6000000d,"LOOS");
3635 mapResult.insert(0x6000000e,"SUNW_RTLDINF");
3636 mapResult.insert(0x6ffff000,"HIOS");
3637 mapResult.insert(0x6ffffd00,"VALRNGLO");
3638 mapResult.insert(0x6ffffdf8,"CHECKSUM");
3639 mapResult.insert(0x6ffffdf9,"PLTPADSZ");
3640 mapResult.insert(0x6ffffdfa,"MOVEENT");
3641 mapResult.insert(0x6ffffdfb,"MOVESZ");
3642 mapResult.insert(0x6ffffdfc,"FEATURE_1");
3643 mapResult.insert(0x6ffffdfd,"POSFLAG_1");
3644 mapResult.insert(0x6ffffdfe,"SYMINSZ");
3645 mapResult.insert(0x6ffffdff,"SYMINENT");
3646 mapResult.insert(0x6ffffdff,"VALRNGHI");
3647 mapResult.insert(0x6ffffe00,"ADDRRNGLO");
3648 mapResult.insert(0x6ffffef5,"GNU_HASH");
3649 mapResult.insert(0x6ffffefa,"CONFIG");
3650 mapResult.insert(0x6ffffefb,"DEPAUDIT");
3651 mapResult.insert(0x6ffffefc,"AUDIT");
3652 mapResult.insert(0x6ffffefd,"PLTPAD");
3653 mapResult.insert(0x6ffffefe,"MOVETAB");
3654 mapResult.insert(0x6ffffeff,"SYMINFO");
3655 mapResult.insert(0x6ffffeff,"ADDRRNGHI");
3656 mapResult.insert(0x6ffffff0,"VERSYM");
3657 mapResult.insert(0x6ffffff9,"RELACOUNT");
3658 mapResult.insert(0x6ffffffa,"RELCOUNT");
3659 mapResult.insert(0x6ffffffb,"FLAGS_1");
3660 mapResult.insert(0x6ffffffc,"VERDEF");
3661 mapResult.insert(0x6ffffffd,"VERDEFNUM");
3662 mapResult.insert(0x6ffffffe,"VERNEED");
3663 mapResult.insert(0x6fffffff,"VERNEEDNUM");
3664 mapResult.insert(0x70000000,"LOPROC");
3665 mapResult.insert(0x70000001,"SPARC_REGISTER");
3666 mapResult.insert(0x7ffffffd,"AUXILIARY");
3667 mapResult.insert(0x7ffffffe,"USED");
3668 mapResult.insert(0x7fffffff,"HIPROC"); // FILTER
3669
3670 return mapResult;
3671 }
3672
getMemoryMap()3673 XBinary::_MEMORY_MAP XELF::getMemoryMap()
3674 {
3675 // TODO Check alignment!
3676 XBinary::_MEMORY_MAP result={};
3677
3678 qint32 nIndex=0;
3679
3680 result.mode=getMode();
3681 if(result.mode==MODE_64)
3682 {
3683 result.fileType=FT_ELF64;
3684 }
3685 else
3686 {
3687 result.fileType=FT_ELF32;
3688 }
3689
3690 result.sArch=getArch();
3691 result.bIsBigEndian=isBigEndian();
3692 result.sType=getTypeAsString();
3693
3694 result.nRawSize=getSize();
3695
3696 QList<XELF_DEF::Elf_Phdr> listProgramHeaders=getElf_PhdrList();
3697 QList<XELF_DEF::Elf_Phdr> listSegments=_getPrograms(&listProgramHeaders,XELF_DEF::PT_LOAD);
3698
3699 // bool bIs64=is64();
3700 int nNumberOfSegments=listSegments.count();
3701
3702 bool bImageAddressInit=false;
3703
3704 qint64 nMaxOffset=0;
3705 qint64 nMaxAddress=0;
3706
3707 for(int i=0; i<nNumberOfSegments; i++)
3708 {
3709 QString sName=QString("%1(%2)").arg(tr("Segment"),QString::number(i));
3710
3711 quint64 nVirtualAlign=listSegments.at(i).p_align; // TODO Check!
3712 quint64 nFileAlign=0x1; // TODO Check!!!
3713 qint64 nVirtualAddress=S_ALIGN_DOWN(listSegments.at(i).p_vaddr,nVirtualAlign);
3714 qint64 nFileOffset=S_ALIGN_DOWN(listSegments.at(i).p_offset,nFileAlign);
3715 qint64 nVirtualSize=S_ALIGN_UP(listSegments.at(i).p_memsz,nVirtualAlign);
3716 qint64 nFileSize=S_ALIGN_UP(listSegments.at(i).p_filesz,nFileAlign);
3717
3718 if(listSegments.at(i).p_vaddr>(quint64)nVirtualAddress)
3719 {
3720 XBinary::_MEMORY_RECORD record={};
3721
3722 record.type=MMT_LOADSEGMENT;
3723 record.sName=sName;
3724 // TODO Section number!
3725 record.nAddress=nVirtualAddress;
3726 record.nSize=listSegments.at(i).p_vaddr-nVirtualAddress;
3727 record.nOffset=-1;
3728 record.nIndex=nIndex++;
3729 record.bIsVirtual=true;
3730
3731 result.listRecords.append(record);
3732 }
3733
3734 if(nFileSize)
3735 {
3736 XBinary::_MEMORY_RECORD record={};
3737
3738 record.type=MMT_LOADSEGMENT;
3739 record.sName=sName;
3740 // TODO Section number!
3741 record.nAddress=listSegments.at(i).p_vaddr;
3742 record.nSize=nFileSize;
3743 record.nOffset=nFileOffset;
3744 record.nIndex=nIndex++;
3745
3746 result.listRecords.append(record);
3747 }
3748
3749 if(nVirtualSize>(nFileSize+((qint64)listSegments.at(i).p_vaddr-nVirtualAddress)))
3750 {
3751 XBinary::_MEMORY_RECORD record={};
3752
3753 record.type=MMT_LOADSEGMENT;
3754 record.sName=sName;
3755 // TODO Section number!
3756 record.nAddress=listSegments.at(i).p_vaddr+nFileSize;
3757 record.nSize=nVirtualSize-nFileSize-(listSegments.at(i).p_vaddr-nVirtualAddress);
3758 record.nOffset=-1;
3759 record.nIndex=nIndex++;
3760 record.bIsVirtual=true;
3761
3762 result.listRecords.append(record);
3763 }
3764
3765 if(!bImageAddressInit)
3766 {
3767 result.nModuleAddress=nVirtualAddress;
3768 bImageAddressInit=true;
3769 }
3770
3771 nMaxOffset=qMax(nMaxOffset,nFileOffset+nFileSize);
3772
3773 result.nModuleAddress=qMin(nVirtualAddress,result.nModuleAddress);
3774 nMaxAddress=qMax(nVirtualAddress+nVirtualSize,nMaxAddress);
3775 }
3776
3777 result.nImageSize=nMaxAddress-result.nModuleAddress;
3778
3779 qint64 nNoLoadableSize=result.nRawSize-nMaxOffset;
3780
3781 if(nNoLoadableSize>0)
3782 {
3783 XBinary::_MEMORY_RECORD record={};
3784
3785 record.type=MMT_NOLOADABLE;
3786 // TODO Section number!
3787 // TODO virtual sections!
3788 record.nAddress=-1;
3789 record.nSize=nNoLoadableSize;
3790 record.nOffset=nMaxOffset;
3791 record.nIndex=nIndex++;
3792
3793 result.listRecords.append(record);
3794 }
3795
3796 return result;
3797 }
3798
getEntryPointOffset(_MEMORY_MAP * pMemoryMap)3799 qint64 XELF::getEntryPointOffset(_MEMORY_MAP *pMemoryMap)
3800 {
3801 qint64 nAddress=-1;
3802
3803 bool bIs64=is64();
3804
3805 if(bIs64)
3806 {
3807 nAddress=getHdr64_entry();
3808 }
3809 else
3810 {
3811 nAddress=getHdr32_entry();
3812 }
3813
3814 return addressToOffset(pMemoryMap,nAddress);
3815 }
3816
getSectionRecords(QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders,bool bIsImage,QByteArray * pbaSectionTable)3817 QList<XELF::SECTION_RECORD> XELF::getSectionRecords(QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders, bool bIsImage, QByteArray *pbaSectionTable)
3818 {
3819 QList<SECTION_RECORD> listRecords;
3820
3821 int nNumberOfSections=pListSectionHeaders->count();
3822 quint32 nSectionTableSize=pbaSectionTable->size();
3823
3824 for(int i=0;i<nNumberOfSections;i++)
3825 {
3826 SECTION_RECORD record={};
3827
3828 record.nSize=pListSectionHeaders->at(i).sh_size;
3829 record.nFlags=pListSectionHeaders->at(i).sh_flags;
3830
3831 if(bIsImage)
3832 {
3833 record.nOffset=pListSectionHeaders->at(i).sh_addr;
3834 }
3835 else
3836 {
3837 record.nOffset=pListSectionHeaders->at(i).sh_offset;
3838 }
3839
3840 if(pListSectionHeaders->at(i).sh_name<nSectionTableSize)
3841 {
3842 record.sName=pbaSectionTable->data()+pListSectionHeaders->at(i).sh_name;
3843 }
3844
3845 listRecords.append(record);
3846 }
3847
3848 return listRecords;
3849 }
3850
isSectionNamePresent(QString sSectionName)3851 bool XELF::isSectionNamePresent(QString sSectionName)
3852 {
3853 bool bIs64=is64();
3854 quint16 nStringTableSection=getSectionStringTable(bIs64);
3855 QByteArray baStringTable=getSection(nStringTableSection);
3856 QList<XELF_DEF::Elf_Shdr> listSectionHeaders=getElf_ShdrList();
3857
3858 QList<SECTION_RECORD> listSectionRecords=getSectionRecords(&listSectionHeaders,bIs64,&baStringTable);
3859
3860 return isSectionNamePresent(sSectionName,&listSectionRecords);
3861 }
3862
isSectionNamePresent(QString sSectionName,QList<XELF::SECTION_RECORD> * pListSectionRecords)3863 bool XELF::isSectionNamePresent(QString sSectionName, QList<XELF::SECTION_RECORD> *pListSectionRecords)
3864 {
3865 bool bResult=false;
3866
3867 int nNumberOfSections=pListSectionRecords->count();
3868
3869 for(int i=0; i<nNumberOfSections; i++)
3870 {
3871 if(pListSectionRecords->at(i).sName==sSectionName)
3872 {
3873 bResult=true;
3874 break;
3875 }
3876 }
3877
3878 return bResult;
3879 }
3880
getSectionNumber(QString sSectionName)3881 qint32 XELF::getSectionNumber(QString sSectionName)
3882 {
3883 bool bIs64=is64();
3884 quint16 nStringTableSection=getSectionStringTable(bIs64);
3885 QByteArray baStringTable=getSection(nStringTableSection);
3886 QList<XELF_DEF::Elf_Shdr> listSectionHeaders=getElf_ShdrList();
3887
3888 QList<SECTION_RECORD> listSectionRecords=getSectionRecords(&listSectionHeaders,bIs64,&baStringTable);
3889
3890 return getSectionNumber(sSectionName,&listSectionRecords);
3891 }
3892
getSectionNumber(QString sSectionName,QList<XELF::SECTION_RECORD> * pListSectionRecords)3893 qint32 XELF::getSectionNumber(QString sSectionName, QList<XELF::SECTION_RECORD> *pListSectionRecords)
3894 {
3895 qint32 nResult=-1;
3896
3897 int nNumberOfSections=pListSectionRecords->count();
3898
3899 for(int i=0; i<nNumberOfSections; i++)
3900 {
3901 if(pListSectionRecords->at(i).sName==sSectionName)
3902 {
3903 nResult=i;
3904 break;
3905 }
3906 }
3907
3908 return nResult;
3909 }
3910
getSectionRecord(QString sSectionName,QList<XELF::SECTION_RECORD> * pListSectionRecords)3911 XELF::SECTION_RECORD XELF::getSectionRecord(QString sSectionName, QList<XELF::SECTION_RECORD> *pListSectionRecords)
3912 {
3913 SECTION_RECORD result={};
3914
3915 int nNumberOfSections=pListSectionRecords->count();
3916
3917 for(int i=0; i<nNumberOfSections; i++)
3918 {
3919 if(pListSectionRecords->at(i).sName==sSectionName)
3920 {
3921 result=pListSectionRecords->at(i);
3922 break;
3923 }
3924 }
3925
3926 return result;
3927 }
3928
getMode()3929 XBinary::MODE XELF::getMode()
3930 {
3931 MODE result=MODE_32;
3932
3933 quint8 ident=getIdent_class();
3934
3935 if(ident== XELF_DEF::ELFCLASS32)
3936 {
3937 result=MODE_32;
3938 }
3939 else if(ident== XELF_DEF::ELFCLASS64)
3940 {
3941 result=MODE_64;
3942 }
3943
3944 return result;
3945 }
3946
getArch()3947 QString XELF::getArch()
3948 {
3949 return getMachinesS().value(getHdr32_machine(),QString("UNKNOWN"));
3950 }
3951
getType()3952 int XELF::getType()
3953 {
3954 int nResult=TYPE_UNKNOWN;
3955
3956 quint16 nType=0;
3957
3958 if(is64())
3959 {
3960 nType=getHdr64_type();
3961 }
3962 else
3963 {
3964 nType=getHdr32_type();
3965 }
3966
3967 if(nType==XELF_DEF::ET_REL)
3968 {
3969 nResult=TYPE_REL;
3970 }
3971 else if(nType==XELF_DEF::ET_EXEC)
3972 {
3973 nResult=TYPE_EXEC;
3974 }
3975 else if(nType==XELF_DEF::ET_DYN)
3976 {
3977 nResult=TYPE_DYN;
3978 }
3979 else if(nType==XELF_DEF::ET_CORE)
3980 {
3981 nResult=TYPE_CORE;
3982 }
3983 else if(nType==XELF_DEF::ET_NUM)
3984 {
3985 nResult=TYPE_NUM;
3986 }
3987
3988 return nResult;
3989 }
3990
getFileType()3991 XBinary::FT XELF::getFileType()
3992 {
3993 FT result=FT_ELF32;
3994
3995 MODE mode=getMode();
3996
3997 if(mode==MODE_32)
3998 {
3999 result=FT_ELF32;
4000 }
4001 else if(mode==MODE_64)
4002 {
4003 result=FT_ELF64;
4004 }
4005
4006 return result;
4007 }
4008
typeIdToString(int nType)4009 QString XELF::typeIdToString(int nType)
4010 {
4011 QString sResult="Unknown"; // mb TODO translate
4012
4013 switch(nType)
4014 {
4015 case TYPE_UNKNOWN: sResult=QString("Unknown"); break; // mb TODO translate
4016 case TYPE_REL: sResult=QString("REL"); break;
4017 case TYPE_EXEC: sResult=QString("EXEC"); break;
4018 case TYPE_DYN: sResult=QString("DYN"); break;
4019 case TYPE_CORE: sResult=QString("CORE"); break;
4020 case TYPE_NUM: sResult=QString("NUM"); break;
4021 }
4022
4023 return sResult;
4024 }
4025
getBaseAddress()4026 qint64 XELF::getBaseAddress()
4027 {
4028 return getMemoryMap().nModuleAddress; // TODO Check !!!
4029 }
4030
_getPrograms(QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders,quint32 nType)4031 QList<XELF_DEF::Elf_Phdr> XELF::_getPrograms(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders, quint32 nType)
4032 {
4033 QList<XELF_DEF::Elf_Phdr> listResult;
4034
4035 int nNumberOfPrograms=pListProgramHeaders->count();
4036
4037 for(int i=0;i<nNumberOfPrograms;i++)
4038 {
4039 if(pListProgramHeaders->at(i).p_type==nType)
4040 {
4041 listResult.append(pListProgramHeaders->at(i));
4042 }
4043 }
4044
4045 return listResult;
4046 }
4047
getDatasetsFromSections(QList<XELF_DEF::Elf_Shdr> * pListSectionHeaders)4048 QList<XBinary::DATASET> XELF::getDatasetsFromSections(QList<XELF_DEF::Elf_Shdr> *pListSectionHeaders)
4049 {
4050 QList<XBinary::DATASET> listResult;
4051
4052 quint32 nMainStringSection=getSectionStringTable();
4053
4054 XBinary::OFFSETSIZE osStringTable=getSectionOffsetSize(nMainStringSection);
4055
4056 int nNumberOfSections=pListSectionHeaders->count();
4057
4058 for(int i=0;i<nNumberOfSections;i++)
4059 {
4060 QString sSectionName=getStringFromIndex(osStringTable.nOffset,osStringTable.nSize,pListSectionHeaders->at(i).sh_name);
4061
4062 if((pListSectionHeaders->at(i).sh_type==1)&&(sSectionName==".interp")) // Interpreter TODO const
4063 {
4064 DATASET dataset={};
4065
4066 dataset.nAddress=pListSectionHeaders->at(i).sh_addr;
4067 dataset.nOffset=pListSectionHeaders->at(i).sh_offset;
4068 dataset.nSize=pListSectionHeaders->at(i).sh_size;
4069 dataset.nType=DS_INTERPRETER;
4070 dataset.sName=QString("%1[%2]").arg("Interpreter",sSectionName); // TODO mb translate
4071
4072 listResult.append(dataset);
4073 }
4074 else if(pListSectionHeaders->at(i).sh_type==2) // Symbol table TODO const
4075 {
4076 DATASET dataset={};
4077
4078 dataset.nAddress=pListSectionHeaders->at(i).sh_addr;
4079 dataset.nOffset=pListSectionHeaders->at(i).sh_offset;
4080 dataset.nSize=pListSectionHeaders->at(i).sh_size;
4081 dataset.nType=DS_SYMBOLTABLE;
4082 dataset.sName=QString("%1[%2]").arg("Symbol table",sSectionName); // TODO mb translate
4083
4084 int nSectionIndex=getSectionIndexByName(".strtab");
4085
4086 if(nSectionIndex!=-1)
4087 {
4088 XBinary::OFFSETSIZE osStringTable=getSectionOffsetSize(nSectionIndex);
4089
4090 dataset.nStringTableOffset=osStringTable.nOffset;
4091 dataset.nStringTableSize=osStringTable.nSize;
4092 }
4093
4094 listResult.append(dataset);
4095 }
4096 else if(pListSectionHeaders->at(i).sh_type==0xb) // Symbol table dynamic TODO const
4097 {
4098 DATASET dataset={};
4099
4100 dataset.nAddress=pListSectionHeaders->at(i).sh_addr;
4101 dataset.nOffset=pListSectionHeaders->at(i).sh_offset;
4102 dataset.nSize=pListSectionHeaders->at(i).sh_size;
4103 dataset.nType=DS_SYMBOLTABLE;
4104 dataset.sName=QString("%1[%2]").arg("Symbol table",sSectionName); // TODO mb translate
4105
4106 int nSectionIndex=getSectionIndexByName(".dynstr");
4107
4108 if(nSectionIndex!=-1)
4109 {
4110 XBinary::OFFSETSIZE osStringTable=getSectionOffsetSize(nSectionIndex);
4111
4112 dataset.nStringTableOffset=osStringTable.nOffset;
4113 dataset.nStringTableSize=osStringTable.nSize;
4114 }
4115
4116 listResult.append(dataset);
4117 }
4118 else if(pListSectionHeaders->at(i).sh_type==3) // String table TODO const
4119 {
4120 DATASET dataset={};
4121
4122 dataset.nAddress=pListSectionHeaders->at(i).sh_addr;
4123 dataset.nOffset=pListSectionHeaders->at(i).sh_offset;
4124 dataset.nSize=pListSectionHeaders->at(i).sh_size;
4125 dataset.nType=DS_STRINGTABLE;
4126 dataset.sName=QString("%1[%2]").arg("String table",sSectionName); // TODO mb translate
4127
4128 listResult.append(dataset);
4129 }
4130 else if(pListSectionHeaders->at(i).sh_type==4) // RELA TODO const
4131 {
4132 DATASET dataset={};
4133
4134 dataset.nAddress=pListSectionHeaders->at(i).sh_addr;
4135 dataset.nOffset=pListSectionHeaders->at(i).sh_offset;
4136 dataset.nSize=pListSectionHeaders->at(i).sh_size;
4137 dataset.nType=DS_RELA;
4138 dataset.sName=QString("%1[%2]").arg("RELA",sSectionName); // TODO mb translate
4139
4140 listResult.append(dataset);
4141 }
4142 else if(pListSectionHeaders->at(i).sh_type==6) // Dynamic TODO const
4143 {
4144 DATASET dataset={};
4145
4146 dataset.nAddress=pListSectionHeaders->at(i).sh_addr;
4147 dataset.nOffset=pListSectionHeaders->at(i).sh_offset;
4148 dataset.nSize=pListSectionHeaders->at(i).sh_size;
4149 dataset.nType=DS_DYNAMICTAGS;
4150 dataset.sName=QString("%1[%2]").arg("Dynamic tags",sSectionName); // TODO mb translate
4151
4152 listResult.append(dataset);
4153 }
4154 else if(pListSectionHeaders->at(i).sh_type==7) // Notes TODO const
4155 {
4156 DATASET dataset={};
4157
4158 dataset.nAddress=pListSectionHeaders->at(i).sh_addr;
4159 dataset.nOffset=pListSectionHeaders->at(i).sh_offset;
4160 dataset.nSize=pListSectionHeaders->at(i).sh_size;
4161 dataset.nType=DS_NOTES;
4162 dataset.sName=QString("%1[%2]").arg("Notes",sSectionName); // TODO mb translate
4163
4164 listResult.append(dataset);
4165 }
4166 else if(pListSectionHeaders->at(i).sh_type==9) // REL TODO const
4167 {
4168 DATASET dataset={};
4169
4170 dataset.nAddress=pListSectionHeaders->at(i).sh_addr;
4171 dataset.nOffset=pListSectionHeaders->at(i).sh_offset;
4172 dataset.nSize=pListSectionHeaders->at(i).sh_size;
4173 dataset.nType=DS_REL;
4174 dataset.sName=QString("%1[%2]").arg("REL",sSectionName); // TODO mb translate
4175
4176 listResult.append(dataset);
4177 }
4178 }
4179
4180 return listResult;
4181 }
4182
getDatasetsFromPrograms(QList<XELF_DEF::Elf_Phdr> * pListProgramHeaders)4183 QList<XBinary::DATASET> XELF::getDatasetsFromPrograms(QList<XELF_DEF::Elf_Phdr> *pListProgramHeaders)
4184 {
4185 QList<XBinary::DATASET> listResult;
4186
4187 int nNumberOfPrograms=pListProgramHeaders->count();
4188
4189 for(int i=0;i<nNumberOfPrograms;i++)
4190 {
4191 if((pListProgramHeaders->at(i).p_type==3)) // Interpreter TODO const
4192 {
4193 DATASET dataset={};
4194
4195 dataset.nAddress=pListProgramHeaders->at(i).p_vaddr;
4196 dataset.nOffset=pListProgramHeaders->at(i).p_offset;
4197 dataset.nSize=pListProgramHeaders->at(i).p_filesz;
4198 dataset.nType=DS_INTERPRETER;
4199 dataset.sName=QString("%1").arg("Interpreter"); // TODO mb translate
4200
4201 listResult.append(dataset);
4202 }
4203 else if((pListProgramHeaders->at(i).p_type==4)) // Notes TODO const
4204 {
4205 DATASET dataset={};
4206
4207 dataset.nAddress=pListProgramHeaders->at(i).p_vaddr;
4208 dataset.nOffset=pListProgramHeaders->at(i).p_offset;
4209 dataset.nSize=pListProgramHeaders->at(i).p_filesz;
4210 dataset.nType=DS_NOTES;
4211 dataset.sName=QString("%1").arg("Notes"); // TODO mb translate
4212
4213 listResult.append(dataset);
4214 }
4215 else if((pListProgramHeaders->at(i).p_type==2)) // Tags TODO const
4216 {
4217 DATASET dataset={};
4218
4219 dataset.nAddress=pListProgramHeaders->at(i).p_vaddr;
4220 dataset.nOffset=pListProgramHeaders->at(i).p_offset;
4221 dataset.nSize=pListProgramHeaders->at(i).p_filesz;
4222 dataset.nType=DS_DYNAMICTAGS;
4223 dataset.sName=QString("%1").arg("Dynamic tags"); // TODO mb translate
4224
4225 listResult.append(dataset);
4226 }
4227 }
4228
4229 return listResult;
4230 }
4231
getDatasetsFromTagStructs(XBinary::_MEMORY_MAP * pMemoryMap,QList<XELF::TAG_STRUCT> * pListTagStructs)4232 QList<XBinary::DATASET> XELF::getDatasetsFromTagStructs(XBinary::_MEMORY_MAP *pMemoryMap, QList<XELF::TAG_STRUCT> *pListTagStructs)
4233 {
4234 QList<XBinary::DATASET> listResult;
4235
4236 QList<TAG_STRUCT> listStrTab=_getTagStructs(pListTagStructs,XELF_DEF::DT_STRTAB);
4237 QList<TAG_STRUCT> listStrSize=_getTagStructs(pListTagStructs,XELF_DEF::DT_STRSZ);
4238 QList<TAG_STRUCT> listStrNeeded=_getTagStructs(pListTagStructs,XELF_DEF::DT_NEEDED);
4239 QList<TAG_STRUCT> listRunPath=_getTagStructs(pListTagStructs,0x1d); // TODO const
4240 QList<TAG_STRUCT> listSymbols=_getTagStructs(pListTagStructs,XELF_DEF::DT_SYMTAB);
4241 QList<TAG_STRUCT> listRelaTab=_getTagStructs(pListTagStructs,XELF_DEF::DT_RELA);
4242 QList<TAG_STRUCT> listRelaSize=_getTagStructs(pListTagStructs,XELF_DEF::DT_RELASZ);
4243 QList<TAG_STRUCT> listRelTab=_getTagStructs(pListTagStructs,17); // TODO const
4244 QList<TAG_STRUCT> listRelSize=_getTagStructs(pListTagStructs,18); // TODO const
4245
4246 qint64 nStringTableOffset=0;
4247 qint64 nStringTableSize=0;
4248
4249 if(listStrTab.count()&&listStrSize.count())
4250 {
4251 DATASET dataset={};
4252
4253 dataset.nAddress=listStrTab.at(0).nValue;
4254 dataset.nOffset=addressToOffset(pMemoryMap,dataset.nAddress);
4255 dataset.nSize=listStrSize.at(0).nValue;
4256 dataset.nType=DS_STRINGTABLE;
4257 dataset.sName="String table"; // TODO mb translate
4258
4259 if(isOffsetAndSizeValid(pMemoryMap,dataset.nOffset,dataset.nSize))
4260 {
4261 listResult.append(dataset);
4262 }
4263
4264 nStringTableOffset=dataset.nOffset;
4265 nStringTableSize=dataset.nSize;
4266 }
4267
4268 if(listRelaTab.count()&&listRelaSize.count())
4269 {
4270 DATASET dataset={};
4271
4272 dataset.nAddress=listRelaTab.at(0).nValue;
4273 dataset.nOffset=addressToOffset(pMemoryMap,dataset.nAddress);
4274 dataset.nSize=listRelaSize.at(0).nValue;
4275 dataset.nType=DS_RELA;
4276 dataset.sName="RELA"; // TODO mb translate
4277 dataset.nStringTableOffset=nStringTableOffset;
4278 dataset.nStringTableSize=nStringTableSize;
4279
4280 listResult.append(dataset);
4281 }
4282
4283 if(listRelTab.count()&&listRelSize.count())
4284 {
4285 DATASET dataset={};
4286
4287 dataset.nAddress=listRelTab.at(0).nValue;
4288 dataset.nOffset=addressToOffset(pMemoryMap,dataset.nAddress);
4289 dataset.nSize=listRelSize.at(0).nValue;
4290 dataset.nType=DS_REL;
4291 dataset.sName="REL"; // TODO mb translate
4292 dataset.nStringTableOffset=nStringTableOffset;
4293 dataset.nStringTableSize=nStringTableSize;
4294
4295 listResult.append(dataset);
4296 }
4297
4298 if(listStrNeeded.count())
4299 {
4300 DATASET dataset={};
4301
4302 dataset.nAddress=0;
4303 dataset.nOffset=0;
4304 dataset.nSize=0;
4305 dataset.nType=DS_LIBRARIES;
4306 dataset.sName="Libraries"; // TODO mb translate
4307 dataset.nStringTableOffset=nStringTableOffset;
4308 dataset.nStringTableSize=nStringTableSize;
4309
4310 listResult.append(dataset);
4311 }
4312
4313 if(listRunPath.count())
4314 {
4315 qint64 nAddress=listStrTab.at(0).nValue;
4316 qint64 nOffset=addressToOffset(pMemoryMap,nAddress);
4317 qint64 nRunPath=listRunPath.at(0).nValue;
4318 qint64 nSize=listStrSize.at(0).nValue;
4319
4320 if(nRunPath<nSize)
4321 {
4322 DATASET dataset={};
4323
4324 dataset.nAddress=nAddress+nRunPath;
4325 dataset.nOffset=nOffset+nRunPath;
4326 QString sAnsiString=read_ansiString(dataset.nOffset);
4327 dataset.nSize=sAnsiString.length();
4328 dataset.nType=DS_RUNPATH;
4329 dataset.sName="Run path"; // TODO mb translate
4330 dataset.nStringTableOffset=nStringTableOffset;
4331 dataset.nStringTableSize=nStringTableSize;
4332
4333 listResult.append(dataset);
4334 }
4335 }
4336
4337 if(listSymbols.count())
4338 {
4339 DATASET dataset={};
4340
4341 dataset.nAddress=listSymbols.at(0).nValue;
4342 dataset.nOffset=addressToOffset(pMemoryMap,dataset.nAddress);
4343 dataset.nSize=getSymTableSize(dataset.nOffset);
4344 dataset.nType=DS_SYMBOLTABLE;
4345 dataset.sName="Symbol table"; // TODO mb translate
4346 dataset.nStringTableOffset=nStringTableOffset;
4347 dataset.nStringTableSize=nStringTableSize;
4348
4349 listResult.append(dataset);
4350 }
4351
4352 return listResult;
4353 }
4354
getElf32_SymList(qint64 nOffset,qint64 nSize)4355 QList<XELF_DEF::Elf32_Sym> XELF::getElf32_SymList(qint64 nOffset, qint64 nSize)
4356 {
4357 QList<XELF_DEF::Elf32_Sym> listResult;
4358
4359 bool bIsBigEndian=isBigEndian();
4360
4361 while(nSize>0)
4362 {
4363 XELF_DEF::Elf32_Sym record=_readElf32_Sym(nOffset,bIsBigEndian);
4364
4365 listResult.append(record);
4366
4367 nOffset+=sizeof(XELF_DEF::Elf32_Sym);
4368 nSize-=sizeof(XELF_DEF::Elf32_Sym);
4369 }
4370
4371 return listResult;
4372 }
4373
getElf64_SymList(qint64 nOffset,qint64 nSize)4374 QList<XELF_DEF::Elf64_Sym> XELF::getElf64_SymList(qint64 nOffset, qint64 nSize)
4375 {
4376 QList<XELF_DEF::Elf64_Sym> listResult;
4377
4378 bool bIsBigEndian=isBigEndian();
4379
4380 while(nSize>0)
4381 {
4382 XELF_DEF::Elf64_Sym record=_readElf64_Sym(nOffset,bIsBigEndian);
4383
4384 listResult.append(record);
4385
4386 nOffset+=sizeof(XELF_DEF::Elf64_Sym);
4387 nSize-=sizeof(XELF_DEF::Elf64_Sym);
4388 }
4389
4390 return listResult;
4391 }
4392
_readElf32_Sym(qint64 nOffset,bool bIsBigEndian)4393 XELF_DEF::Elf32_Sym XELF::_readElf32_Sym(qint64 nOffset, bool bIsBigEndian)
4394 {
4395 XELF_DEF::Elf32_Sym result={};
4396
4397 result.st_name=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_name),bIsBigEndian);
4398 result.st_value=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_value),bIsBigEndian);
4399 result.st_size=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_size),bIsBigEndian);
4400 result.st_info=read_uint8(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_info));
4401 result.st_other=read_uint8(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_other));
4402 result.st_shndx=read_uint16(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_shndx),bIsBigEndian);
4403
4404 return result;
4405 }
4406
_readElf64_Sym(qint64 nOffset,bool bIsBigEndian)4407 XELF_DEF::Elf64_Sym XELF::_readElf64_Sym(qint64 nOffset, bool bIsBigEndian)
4408 {
4409 XELF_DEF::Elf64_Sym result={};
4410
4411 result.st_name=read_uint32(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_name),bIsBigEndian);
4412 result.st_info=read_uint8(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_info));
4413 result.st_other=read_uint8(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_other));
4414 result.st_shndx=read_uint16(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_shndx),bIsBigEndian);
4415 result.st_value=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_value),bIsBigEndian);
4416 result.st_size=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_size),bIsBigEndian);
4417
4418 return result;
4419 }
4420
setElf32_Sym_st_name(qint64 nOffset,quint32 nValue,bool bIsBigEndian)4421 void XELF::setElf32_Sym_st_name(qint64 nOffset, quint32 nValue, bool bIsBigEndian)
4422 {
4423 write_uint32(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_name),nValue,bIsBigEndian);
4424 }
4425
setElf32_Sym_st_value(qint64 nOffset,quint32 nValue,bool bIsBigEndian)4426 void XELF::setElf32_Sym_st_value(qint64 nOffset, quint32 nValue, bool bIsBigEndian)
4427 {
4428 write_uint32(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_value),nValue,bIsBigEndian);
4429 }
4430
setElf32_Sym_st_size(qint64 nOffset,quint32 nValue,bool bIsBigEndian)4431 void XELF::setElf32_Sym_st_size(qint64 nOffset, quint32 nValue, bool bIsBigEndian)
4432 {
4433 write_uint32(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_size),nValue,bIsBigEndian);
4434 }
4435
setElf32_Sym_st_info(qint64 nOffset,quint8 nValue)4436 void XELF::setElf32_Sym_st_info(qint64 nOffset, quint8 nValue)
4437 {
4438 write_uint8(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_info),nValue);
4439 }
4440
setElf32_Sym_st_other(qint64 nOffset,quint8 nValue)4441 void XELF::setElf32_Sym_st_other(qint64 nOffset, quint8 nValue)
4442 {
4443 write_uint8(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_other),nValue);
4444 }
4445
setElf32_Sym_st_shndx(qint64 nOffset,quint16 nValue,bool bIsBigEndian)4446 void XELF::setElf32_Sym_st_shndx(qint64 nOffset, quint16 nValue, bool bIsBigEndian)
4447 {
4448 write_uint16(nOffset+offsetof(XELF_DEF::Elf32_Sym,st_shndx),nValue,bIsBigEndian);
4449 }
4450
setElf64_Sym_st_name(qint64 nOffset,quint32 nValue,bool bIsBigEndian)4451 void XELF::setElf64_Sym_st_name(qint64 nOffset, quint32 nValue, bool bIsBigEndian)
4452 {
4453 write_uint32(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_name),nValue,bIsBigEndian);
4454 }
4455
setElf64_Sym_st_info(qint64 nOffset,quint8 nValue)4456 void XELF::setElf64_Sym_st_info(qint64 nOffset, quint8 nValue)
4457 {
4458 write_uint8(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_info),nValue);
4459 }
4460
setElf64_Sym_st_other(qint64 nOffset,quint8 nValue)4461 void XELF::setElf64_Sym_st_other(qint64 nOffset, quint8 nValue)
4462 {
4463 write_uint8(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_other),nValue);
4464 }
4465
setElf64_Sym_st_shndx(qint64 nOffset,quint16 nValue,bool bIsBigEndian)4466 void XELF::setElf64_Sym_st_shndx(qint64 nOffset, quint16 nValue, bool bIsBigEndian)
4467 {
4468 write_uint16(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_shndx),nValue,bIsBigEndian);
4469 }
4470
setElf64_Sym_st_value(qint64 nOffset,quint64 nValue,bool bIsBigEndian)4471 void XELF::setElf64_Sym_st_value(qint64 nOffset, quint64 nValue, bool bIsBigEndian)
4472 {
4473 write_uint64(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_value),nValue,bIsBigEndian);
4474 }
4475
setElf64_Sym_st_size(qint64 nOffset,quint64 nValue,bool bIsBigEndian)4476 void XELF::setElf64_Sym_st_size(qint64 nOffset, quint64 nValue, bool bIsBigEndian)
4477 {
4478 write_uint64(nOffset+offsetof(XELF_DEF::Elf64_Sym,st_size),nValue,bIsBigEndian);
4479 }
4480
getSymSize()4481 qint64 XELF::getSymSize()
4482 {
4483 quint64 nResult=0;
4484
4485 bool bIs64=is64();
4486
4487 if(bIs64)
4488 {
4489 nResult=sizeof(XELF_DEF::Elf64_Sym);
4490 }
4491 else
4492 {
4493 nResult=sizeof(XELF_DEF::Elf32_Sym);
4494 }
4495
4496 return nResult;
4497 }
4498
getSymTableSize(qint64 nOffset)4499 qint64 XELF::getSymTableSize(qint64 nOffset)
4500 {
4501 qint64 nResult=0;
4502
4503 bool bIsBigEndian=isBigEndian();
4504 bool bIs64=is64();
4505
4506 if(bIs64)
4507 {
4508 nResult+=sizeof(XELF_DEF::Elf64_Sym);
4509 nOffset+=sizeof(XELF_DEF::Elf64_Sym);
4510
4511 while(true)
4512 {
4513 XELF_DEF::Elf64_Sym record=_readElf64_Sym(nOffset,bIsBigEndian);
4514
4515 if((!record.st_info)||(record.st_other))
4516 {
4517 break;
4518 }
4519
4520 nResult+=sizeof(XELF_DEF::Elf64_Sym);
4521 nOffset+=sizeof(XELF_DEF::Elf64_Sym);
4522 }
4523 }
4524 else
4525 {
4526 nResult+=sizeof(XELF_DEF::Elf32_Sym);
4527 nOffset+=sizeof(XELF_DEF::Elf32_Sym);
4528
4529 while(true)
4530 {
4531 XELF_DEF::Elf32_Sym record=_readElf32_Sym(nOffset,bIsBigEndian);
4532
4533 if((!record.st_info)||(record.st_other))
4534 {
4535 break;
4536 }
4537
4538 nResult+=sizeof(XELF_DEF::Elf32_Sym);
4539 nOffset+=sizeof(XELF_DEF::Elf32_Sym);
4540 }
4541 }
4542
4543 return nResult;
4544 }
4545
_readElf32_Rel(qint64 nOffset,bool bIsBigEndian)4546 XELF_DEF::Elf32_Rel XELF::_readElf32_Rel(qint64 nOffset, bool bIsBigEndian)
4547 {
4548 XELF_DEF::Elf32_Rel result={};
4549
4550 result.r_offset=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Rel,r_offset),bIsBigEndian);
4551 result.r_info=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Rel,r_info),bIsBigEndian);
4552
4553 return result;
4554 }
4555
_readElf64_Rel(qint64 nOffset,bool bIsBigEndian)4556 XELF_DEF::Elf64_Rel XELF::_readElf64_Rel(qint64 nOffset, bool bIsBigEndian)
4557 {
4558 XELF_DEF::Elf64_Rel result={};
4559
4560 result.r_offset=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Rel,r_offset),bIsBigEndian);
4561 result.r_info=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Rel,r_info),bIsBigEndian);
4562
4563 return result;
4564 }
4565
_readElf32_Rela(qint64 nOffset,bool bIsBigEndian)4566 XELF_DEF::Elf32_Rela XELF::_readElf32_Rela(qint64 nOffset, bool bIsBigEndian)
4567 {
4568 XELF_DEF::Elf32_Rela result={};
4569
4570 result.r_offset=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Rela,r_offset),bIsBigEndian);
4571 result.r_info=read_uint32(nOffset+offsetof(XELF_DEF::Elf32_Rela,r_info),bIsBigEndian);
4572 result.r_addend=read_int32(nOffset+offsetof(XELF_DEF::Elf32_Rela,r_addend),bIsBigEndian);
4573
4574 return result;
4575 }
4576
_readElf64_Rela(qint64 nOffset,bool bIsBigEndian)4577 XELF_DEF::Elf64_Rela XELF::_readElf64_Rela(qint64 nOffset, bool bIsBigEndian)
4578 {
4579 XELF_DEF::Elf64_Rela result={};
4580
4581 result.r_offset=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Rela,r_offset),bIsBigEndian);
4582 result.r_info=read_uint64(nOffset+offsetof(XELF_DEF::Elf64_Rela,r_info),bIsBigEndian);
4583 result.r_addend=read_int64(nOffset+offsetof(XELF_DEF::Elf64_Rela,r_addend),bIsBigEndian);
4584
4585 return result;
4586 }
4587
getElf32_RelList(qint64 nOffset,qint64 nSize)4588 QList<XELF_DEF::Elf32_Rel> XELF::getElf32_RelList(qint64 nOffset, qint64 nSize)
4589 {
4590 QList<XELF_DEF::Elf32_Rel> listResult;
4591
4592 bool bIsBigEndian=isBigEndian();
4593
4594 while(nSize>0)
4595 {
4596 XELF_DEF::Elf32_Rel record=_readElf32_Rel(nOffset,bIsBigEndian);
4597
4598 listResult.append(record);
4599
4600 nOffset+=sizeof(XELF_DEF::Elf32_Rel);
4601 nSize-=sizeof(XELF_DEF::Elf32_Rel);
4602 }
4603
4604 return listResult;
4605 }
4606
getElf64_RelList(qint64 nOffset,qint64 nSize)4607 QList<XELF_DEF::Elf64_Rel> XELF::getElf64_RelList(qint64 nOffset, qint64 nSize)
4608 {
4609 QList<XELF_DEF::Elf64_Rel> listResult;
4610
4611 bool bIsBigEndian=isBigEndian();
4612
4613 while(nSize>0)
4614 {
4615 XELF_DEF::Elf64_Rel record=_readElf64_Rel(nOffset,bIsBigEndian);
4616
4617 listResult.append(record);
4618
4619 nOffset+=sizeof(XELF_DEF::Elf64_Rel);
4620 nSize-=sizeof(XELF_DEF::Elf64_Rel);
4621 }
4622
4623 return listResult;
4624 }
4625
getElf32_RelaList(qint64 nOffset,qint64 nSize)4626 QList<XELF_DEF::Elf32_Rela> XELF::getElf32_RelaList(qint64 nOffset, qint64 nSize)
4627 {
4628 QList<XELF_DEF::Elf32_Rela> listResult;
4629
4630 bool bIsBigEndian=isBigEndian();
4631
4632 while(nSize>0)
4633 {
4634 XELF_DEF::Elf32_Rela record=_readElf32_Rela(nOffset,bIsBigEndian);
4635
4636 listResult.append(record);
4637
4638 nOffset+=sizeof(XELF_DEF::Elf32_Rela);
4639 nSize-=sizeof(XELF_DEF::Elf32_Rela);
4640 }
4641
4642 return listResult;
4643 }
4644
getElf64_RelaList(qint64 nOffset,qint64 nSize)4645 QList<XELF_DEF::Elf64_Rela> XELF::getElf64_RelaList(qint64 nOffset, qint64 nSize)
4646 {
4647 QList<XELF_DEF::Elf64_Rela> listResult;
4648
4649 bool bIsBigEndian=isBigEndian();
4650
4651 while(nSize>0)
4652 {
4653 XELF_DEF::Elf64_Rela record=_readElf64_Rela(nOffset,bIsBigEndian);
4654
4655 listResult.append(record);
4656
4657 nOffset+=sizeof(XELF_DEF::Elf64_Rela);
4658 nSize-=sizeof(XELF_DEF::Elf64_Rela);
4659 }
4660
4661 return listResult;
4662 }
4663
setElf32_Rel_r_offset(qint64 nOffset,quint32 nValue,bool bIsBigEndian)4664 void XELF::setElf32_Rel_r_offset(qint64 nOffset, quint32 nValue, bool bIsBigEndian)
4665 {
4666 write_uint32(nOffset+offsetof(XELF_DEF::Elf32_Rel,r_offset),nValue,bIsBigEndian);
4667 }
4668
setElf32_Rel_r_info(qint64 nOffset,quint32 nValue,bool bIsBigEndian)4669 void XELF::setElf32_Rel_r_info(qint64 nOffset, quint32 nValue, bool bIsBigEndian)
4670 {
4671 write_uint32(nOffset+offsetof(XELF_DEF::Elf32_Rel,r_info),nValue,bIsBigEndian);
4672 }
4673
setElf64_Rel_r_offset(qint64 nOffset,quint64 nValue,bool bIsBigEndian)4674 void XELF::setElf64_Rel_r_offset(qint64 nOffset, quint64 nValue, bool bIsBigEndian)
4675 {
4676 write_uint64(nOffset+offsetof(XELF_DEF::Elf64_Rel,r_offset),nValue,bIsBigEndian);
4677 }
4678
setElf64_Rel_r_info(qint64 nOffset,quint64 nValue,bool bIsBigEndian)4679 void XELF::setElf64_Rel_r_info(qint64 nOffset, quint64 nValue, bool bIsBigEndian)
4680 {
4681 write_uint64(nOffset+offsetof(XELF_DEF::Elf64_Rel,r_info),nValue,bIsBigEndian);
4682 }
4683
setElf32_Rela_r_offset(qint64 nOffset,quint32 nValue,bool bIsBigEndian)4684 void XELF::setElf32_Rela_r_offset(qint64 nOffset, quint32 nValue, bool bIsBigEndian)
4685 {
4686 write_uint32(nOffset+offsetof(XELF_DEF::Elf32_Rela,r_offset),nValue,bIsBigEndian);
4687 }
4688
setElf32_Rela_r_info(qint64 nOffset,quint32 nValue,bool bIsBigEndian)4689 void XELF::setElf32_Rela_r_info(qint64 nOffset, quint32 nValue, bool bIsBigEndian)
4690 {
4691 write_uint32(nOffset+offsetof(XELF_DEF::Elf32_Rela,r_info),nValue,bIsBigEndian);
4692 }
4693
setElf32_Rela_r_addend(qint64 nOffset,quint32 nValue,bool bIsBigEndian)4694 void XELF::setElf32_Rela_r_addend(qint64 nOffset, quint32 nValue, bool bIsBigEndian)
4695 {
4696 write_uint32(nOffset+offsetof(XELF_DEF::Elf32_Rela,r_addend),nValue,bIsBigEndian);
4697 }
4698
setElf64_Rela_r_offset(qint64 nOffset,quint64 nValue,bool bIsBigEndian)4699 void XELF::setElf64_Rela_r_offset(qint64 nOffset, quint64 nValue, bool bIsBigEndian)
4700 {
4701 write_uint64(nOffset+offsetof(XELF_DEF::Elf64_Rela,r_offset),nValue,bIsBigEndian);
4702 }
4703
setElf64_Rela_r_info(qint64 nOffset,quint64 nValue,bool bIsBigEndian)4704 void XELF::setElf64_Rela_r_info(qint64 nOffset, quint64 nValue, bool bIsBigEndian)
4705 {
4706 write_uint64(nOffset+offsetof(XELF_DEF::Elf64_Rela,r_info),nValue,bIsBigEndian);
4707 }
4708
setElf64_Rela_r_addend(qint64 nOffset,quint64 nValue,bool bIsBigEndian)4709 void XELF::setElf64_Rela_r_addend(qint64 nOffset, quint64 nValue, bool bIsBigEndian)
4710 {
4711 write_uint64(nOffset+offsetof(XELF_DEF::Elf64_Rela,r_addend),nValue,bIsBigEndian);
4712 }
4713
getNumberOfSections()4714 quint16 XELF::getNumberOfSections()
4715 {
4716 quint16 nResult=0;
4717
4718 if(is64())
4719 {
4720 nResult=getHdr64_shnum();
4721 }
4722 else
4723 {
4724 nResult=getHdr32_shnum();
4725 }
4726
4727 return nResult;
4728 }
4729
getNumberOfPrograms()4730 quint16 XELF::getNumberOfPrograms()
4731 {
4732 quint16 nResult=0;
4733
4734 if(is64())
4735 {
4736 nResult=getHdr64_phnum();
4737 }
4738 else
4739 {
4740 nResult=getHdr32_phnum();
4741 }
4742
4743 return nResult;
4744 }
4745
isSectionsTablePresent()4746 bool XELF::isSectionsTablePresent()
4747 {
4748 return (bool)getNumberOfSections();
4749 }
4750
isProgramsTablePresent()4751 bool XELF::isProgramsTablePresent()
4752 {
4753 return (bool)getNumberOfPrograms();
4754 }
4755
getRelTypes_x86()4756 QMap<quint64, QString> XELF::getRelTypes_x86()
4757 {
4758 QMap<quint64, QString> mapResult;
4759
4760 mapResult.insert(0,"R_386_NONE");
4761 mapResult.insert(1,"R_386_32");
4762 mapResult.insert(2,"R_386_PC32");
4763 mapResult.insert(3,"R_386_GOT32");
4764 mapResult.insert(4,"R_386_PLT32");
4765 mapResult.insert(5,"R_386_COPY");
4766 mapResult.insert(6,"R_386_GLOB_DAT");
4767 mapResult.insert(7,"R_386_JMP_SLOT");
4768 mapResult.insert(8,"R_386_RELATIVE");
4769 mapResult.insert(9,"R_386_GOTOFF");
4770 mapResult.insert(10,"R_386_GOTPC");
4771 mapResult.insert(11,"R_386_32PLT");
4772 mapResult.insert(20,"R_386_16");
4773 mapResult.insert(21,"R_386_PC16");
4774 mapResult.insert(22,"R_386_8");
4775 mapResult.insert(23,"R_386_PC8");
4776 mapResult.insert(38,"R_386_SIZE32");
4777
4778 return mapResult;
4779 }
4780
getRelTypesS_x86()4781 QMap<quint64, QString> XELF::getRelTypesS_x86()
4782 {
4783 QMap<quint64, QString> mapResult;
4784
4785 mapResult.insert(0,"386_NONE");
4786 mapResult.insert(1,"386_32");
4787 mapResult.insert(2,"386_PC32");
4788 mapResult.insert(3,"386_GOT32");
4789 mapResult.insert(4,"386_PLT32");
4790 mapResult.insert(5,"386_COPY");
4791 mapResult.insert(6,"386_GLOB_DAT");
4792 mapResult.insert(7,"386_JMP_SLOT");
4793 mapResult.insert(8,"386_RELATIVE");
4794 mapResult.insert(9,"386_GOTOFF");
4795 mapResult.insert(10,"386_GOTPC");
4796 mapResult.insert(11,"386_32PLT");
4797 mapResult.insert(20,"386_16");
4798 mapResult.insert(21,"386_PC16");
4799 mapResult.insert(22,"386_8");
4800 mapResult.insert(23,"386_PC8");
4801 mapResult.insert(38,"386_SIZE32");
4802
4803 return mapResult;
4804 }
4805
getRelTypes_x64()4806 QMap<quint64, QString> XELF::getRelTypes_x64()
4807 {
4808 QMap<quint64, QString> mapResult;
4809
4810 mapResult.insert(0,"R_X86_64_NONE");
4811 mapResult.insert(1,"R_X86_64_32");
4812 mapResult.insert(2,"R_386_PC32");
4813 mapResult.insert(3,"R_386_GOT32");
4814 mapResult.insert(4,"R_X86_64_PLT32");
4815 mapResult.insert(5,"R_X86_64_COPY");
4816 mapResult.insert(6,"R_X86_64_GLOB_DAT");
4817 mapResult.insert(7,"R_X86_64_JMP_SLOT");
4818 mapResult.insert(8,"R_X86_64_RELATIVE");
4819 mapResult.insert(9,"R_X86_64_GOTPCREL");
4820 mapResult.insert(10,"R_X86_64_32");
4821 mapResult.insert(11,"R_X86_64_32S");
4822 mapResult.insert(12,"R_X86_64_16");
4823 mapResult.insert(13,"R_X86_64_PC16");
4824 mapResult.insert(14,"R_X86_64_8");
4825 mapResult.insert(15,"R_X86_64_PC8");
4826 mapResult.insert(24,"R_X86_64_PC64");
4827
4828 return mapResult;
4829 }
4830
getRelTypesS_x64()4831 QMap<quint64, QString> XELF::getRelTypesS_x64()
4832 {
4833 QMap<quint64, QString> mapResult;
4834
4835 mapResult.insert(0,"X86_64_NONE");
4836 mapResult.insert(1,"X86_64_32");
4837 mapResult.insert(2,"386_PC32");
4838 mapResult.insert(3,"386_GOT32");
4839 mapResult.insert(4,"X86_64_PLT32");
4840 mapResult.insert(5,"X86_64_COPY");
4841 mapResult.insert(6,"X86_64_GLOB_DAT");
4842 mapResult.insert(7,"X86_64_JMP_SLOT");
4843 mapResult.insert(8,"X86_64_RELATIVE");
4844 mapResult.insert(9,"X86_64_GOTPCREL");
4845 mapResult.insert(10,"X86_64_32");
4846 mapResult.insert(11,"X86_64_32S");
4847 mapResult.insert(12,"X86_64_16");
4848 mapResult.insert(13,"X86_64_PC16");
4849 mapResult.insert(14,"X86_64_8");
4850 mapResult.insert(15,"X86_64_PC8");
4851 mapResult.insert(24,"X86_64_PC64");
4852
4853 return mapResult;
4854 }
4855
getRelTypes_SPARC()4856 QMap<quint64, QString> XELF::getRelTypes_SPARC()
4857 {
4858 QMap<quint64, QString> mapResult;
4859
4860 mapResult.insert(0,"R_SPARC_NONE");
4861 mapResult.insert(1,"R_SPARC_8");
4862 mapResult.insert(2,"R_SPARC_16");
4863 mapResult.insert(3,"R_SPARC_32");
4864 mapResult.insert(4,"R_SPARC_DISP8");
4865 mapResult.insert(5,"R_SPARC_DISP16");
4866 mapResult.insert(6,"R_SPARC_DISP32");
4867 mapResult.insert(7,"R_SPARC_WDISP30");
4868 mapResult.insert(8,"R_SPARC_WDISP22");
4869 mapResult.insert(9,"R_SPARC_HI22");
4870 mapResult.insert(10,"R_SPARC_22");
4871 mapResult.insert(11,"R_SPARC_13");
4872 mapResult.insert(12,"R_SPARC_LO10");
4873 mapResult.insert(13,"R_SPARC_GOT10");
4874 mapResult.insert(14,"R_SPARC_GOT13");
4875 mapResult.insert(15,"R_SPARC_GOT22");
4876 mapResult.insert(16,"R_SPARC_PC10");
4877 mapResult.insert(17,"R_SPARC_PC22");
4878 mapResult.insert(18,"R_SPARC_WPLT30");
4879 mapResult.insert(19,"R_SPARC_COPY");
4880 mapResult.insert(20,"R_SPARC_GLOB_DAT");
4881 mapResult.insert(21,"R_SPARC_JMP_SLOT");
4882 mapResult.insert(22,"R_SPARC_RELATIVE");
4883 mapResult.insert(23,"R_SPARC_UA32");
4884 mapResult.insert(24,"R_SPARC_PLT32");
4885 mapResult.insert(25,"R_SPARC_HIPLT22");
4886 mapResult.insert(26,"R_SPARC_LOPLT10");
4887 mapResult.insert(27,"R_SPARC_PCPLT32");
4888 mapResult.insert(28,"R_SPARC_PCPLT22");
4889 mapResult.insert(29,"R_SPARC_PCPLT10");
4890 mapResult.insert(30,"R_SPARC_10");
4891 mapResult.insert(31,"R_SPARC_11");
4892 mapResult.insert(32,"R_SPARC_64");
4893 mapResult.insert(33,"R_SPARC_OLO10");
4894 mapResult.insert(34,"R_SPARC_HH22");
4895 mapResult.insert(35,"R_SPARC_HM10");
4896 mapResult.insert(36,"R_SPARC_LM22");
4897 mapResult.insert(37,"R_SPARC_PC_HH22");
4898 mapResult.insert(38,"R_SPARC_PC_HM10");
4899 mapResult.insert(39,"R_SPARC_PC_LM22");
4900 mapResult.insert(40,"R_SPARC_WDISP16");
4901 mapResult.insert(41,"R_SPARC_WDISP19");
4902 mapResult.insert(43,"R_SPARC_7");
4903 mapResult.insert(44,"R_SPARC_5");
4904 mapResult.insert(45,"R_SPARC_6");
4905 mapResult.insert(46,"R_SPARC_DISP64");
4906 mapResult.insert(47,"R_SPARC_PLT64");
4907 mapResult.insert(48,"R_SPARC_HIX22");
4908 mapResult.insert(49,"R_SPARC_LOX10");
4909 mapResult.insert(50,"R_SPARC_H44");
4910 mapResult.insert(51,"R_SPARC_M44");
4911 mapResult.insert(52,"R_SPARC_L44");
4912 mapResult.insert(53,"R_SPARC_REGISTER");
4913 mapResult.insert(54,"R_SPARC_UA64");
4914 mapResult.insert(55,"R_SPARC_UA16");
4915 mapResult.insert(80,"R_SPARC_GOTDATA_HIX22");
4916 mapResult.insert(81,"R_SPARC_GOTDATA_LOX10");
4917 mapResult.insert(82,"R_SPARC_GOTDATA_OP_HIX22");
4918 mapResult.insert(83,"R_SPARC_GOTDATA_OP_LOX10");
4919 mapResult.insert(84,"R_SPARC_GOTDATA_OP");
4920 mapResult.insert(85,"R_SPARC_SIZE32"); // mb TODO https://docs.oracle.com/cd/E19120-01/open.solaris/819-0690/6n33n7fct/index.html
4921 mapResult.insert(87,"R_SPARC_SIZE64");
4922
4923 return mapResult;
4924 }
4925
getRelTypesS_SPARC()4926 QMap<quint64, QString> XELF::getRelTypesS_SPARC()
4927 {
4928 QMap<quint64, QString> mapResult;
4929
4930 mapResult.insert(0,"SPARC_NONE");
4931 mapResult.insert(1,"SPARC_8");
4932 mapResult.insert(2,"SPARC_16");
4933 mapResult.insert(3,"SPARC_32");
4934 mapResult.insert(4,"SPARC_DISP8");
4935 mapResult.insert(5,"SPARC_DISP16");
4936 mapResult.insert(6,"SPARC_DISP32");
4937 mapResult.insert(7,"SPARC_WDISP30");
4938 mapResult.insert(8,"SPARC_WDISP22");
4939 mapResult.insert(9,"SPARC_HI22");
4940 mapResult.insert(10,"SPARC_22");
4941 mapResult.insert(11,"SPARC_13");
4942 mapResult.insert(12,"SPARC_LO10");
4943 mapResult.insert(13,"SPARC_GOT10");
4944 mapResult.insert(14,"SPARC_GOT13");
4945 mapResult.insert(15,"SPARC_GOT22");
4946 mapResult.insert(16,"SPARC_PC10");
4947 mapResult.insert(17,"SPARC_PC22");
4948 mapResult.insert(18,"SPARC_WPLT30");
4949 mapResult.insert(19,"SPARC_COPY");
4950 mapResult.insert(20,"SPARC_GLOB_DAT");
4951 mapResult.insert(21,"SPARC_JMP_SLOT");
4952 mapResult.insert(22,"SPARC_RELATIVE");
4953 mapResult.insert(23,"SPARC_UA32");
4954 mapResult.insert(24,"SPARC_PLT32");
4955 mapResult.insert(25,"SPARC_HIPLT22");
4956 mapResult.insert(26,"SPARC_LOPLT10");
4957 mapResult.insert(27,"SPARC_PCPLT32");
4958 mapResult.insert(28,"SPARC_PCPLT22");
4959 mapResult.insert(29,"SPARC_PCPLT10");
4960 mapResult.insert(30,"SPARC_10");
4961 mapResult.insert(31,"SPARC_11");
4962 mapResult.insert(32,"SPARC_64");
4963 mapResult.insert(33,"SPARC_OLO10");
4964 mapResult.insert(34,"SPARC_HH22");
4965 mapResult.insert(35,"SPARC_HM10");
4966 mapResult.insert(36,"SPARC_LM22");
4967 mapResult.insert(37,"SPARC_PC_HH22");
4968 mapResult.insert(38,"SPARC_PC_HM10");
4969 mapResult.insert(39,"SPARC_PC_LM22");
4970 mapResult.insert(40,"SPARC_WDISP16");
4971 mapResult.insert(41,"SPARC_WDISP19");
4972 mapResult.insert(43,"SPARC_7");
4973 mapResult.insert(44,"SPARC_5");
4974 mapResult.insert(45,"SPARC_6");
4975 mapResult.insert(46,"SPARC_DISP64");
4976 mapResult.insert(47,"SPARC_PLT64");
4977 mapResult.insert(48,"SPARC_HIX22");
4978 mapResult.insert(49,"SPARC_LOX10");
4979 mapResult.insert(50,"SPARC_H44");
4980 mapResult.insert(51,"SPARC_M44");
4981 mapResult.insert(52,"SPARC_L44");
4982 mapResult.insert(53,"SPARC_REGISTER");
4983 mapResult.insert(54,"SPARC_UA64");
4984 mapResult.insert(55,"SPARC_UA16");
4985 mapResult.insert(80,"SPARC_GOTDATA_HIX22");
4986 mapResult.insert(81,"SPARC_GOTDATA_LOX10");
4987 mapResult.insert(82,"SPARC_GOTDATA_OP_HIX22");
4988 mapResult.insert(83,"SPARC_GOTDATA_OP_LOX10");
4989 mapResult.insert(84,"SPARC_GOTDATA_OP");
4990 mapResult.insert(85,"SPARC_SIZE32"); // mb TODO https://docs.oracle.com/cd/E19120-01/open.solaris/819-0690/6n33n7fct/index.html
4991 mapResult.insert(87,"SPARC_SIZE64");
4992
4993 return mapResult;
4994 }
4995
getStBinds()4996 QMap<quint64, QString> XELF::getStBinds()
4997 {
4998 QMap<quint64, QString> mapResult;
4999
5000 mapResult.insert(0,"STB_LOCAL");
5001 mapResult.insert(1,"STB_GLOBAL");
5002 mapResult.insert(2,"STB_WEAK");
5003 mapResult.insert(10,"STB_LOOS");
5004 mapResult.insert(12,"STB_HIOS");
5005 mapResult.insert(13,"STB_LOPROC");
5006 mapResult.insert(15,"STB_HIPROC");
5007
5008 return mapResult;
5009 }
5010
getStBindsS()5011 QMap<quint64, QString> XELF::getStBindsS()
5012 {
5013 QMap<quint64, QString> mapResult;
5014
5015 mapResult.insert(0,"LOCAL");
5016 mapResult.insert(1,"GLOBAL");
5017 mapResult.insert(2,"WEAK");
5018 mapResult.insert(10,"LOOS");
5019 mapResult.insert(12,"HIOS");
5020 mapResult.insert(13,"LOPROC");
5021 mapResult.insert(15,"HIPROC");
5022
5023 return mapResult;
5024 }
5025
getStTypes()5026 QMap<quint64, QString> XELF::getStTypes()
5027 {
5028 QMap<quint64, QString> mapResult;
5029
5030 mapResult.insert(0,"STT_NOTYPE");
5031 mapResult.insert(1,"STT_OBJECT");
5032 mapResult.insert(2,"STT_FUNC");
5033 mapResult.insert(3,"STT_SECTION");
5034 mapResult.insert(4,"STT_FILE");
5035 mapResult.insert(5,"STT_COMMON");
5036 mapResult.insert(10,"STT_LOOS");
5037 mapResult.insert(12,"STT_HIOS");
5038 mapResult.insert(13,"STT_LOPROC"); // STT_SPARC_REGISTER
5039 mapResult.insert(15,"STT_HIPROC");
5040
5041 return mapResult;
5042 }
5043
getStTypesS()5044 QMap<quint64, QString> XELF::getStTypesS()
5045 {
5046 QMap<quint64, QString> mapResult;
5047
5048 mapResult.insert(0,"NOTYPE");
5049 mapResult.insert(1,"OBJECT");
5050 mapResult.insert(2,"FUNC");
5051 mapResult.insert(3,"SECTION");
5052 mapResult.insert(4,"FILE");
5053 mapResult.insert(5,"COMMON");
5054 mapResult.insert(10,"LOOS");
5055 mapResult.insert(12,"HIOS");
5056 mapResult.insert(13,"LOPROC"); // SPARC_REGISTER
5057 mapResult.insert(15,"HIPROC");
5058
5059 return mapResult;
5060 }
5061