The Tor Browser / file comparison

comparison: media/libvpx/build/make/obj_int_extract.c

media/libvpx/build/make/obj_int_extract.c

branch
TOR_BUG_9701
changeset 10
ac0c01689b40
equal deleted inserted replaced
-1:000000000000 0:0e71f28b6e83
1 /*
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11
12 #include <stdarg.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16
17 #include "vpx_config.h"
18 #include "vpx/vpx_integer.h"
19
20 typedef enum {
21 OUTPUT_FMT_PLAIN,
22 OUTPUT_FMT_RVDS,
23 OUTPUT_FMT_GAS,
24 } output_fmt_t;
25
26 int log_msg(const char *fmt, ...) {
27 int res;
28 va_list ap;
29 va_start(ap, fmt);
30 res = vfprintf(stderr, fmt, ap);
31 va_end(ap);
32 return res;
33 }
34
35 #if defined(__GNUC__) && __GNUC__
36 #if defined(__MACH__)
37
38 #include <mach-o/loader.h>
39 #include <mach-o/nlist.h>
40
41 int print_macho_equ(output_fmt_t mode, uint8_t* name, int val) {
42 switch (mode) {
43 case OUTPUT_FMT_RVDS:
44 printf("%-40s EQU %5d\n", name, val);
45 return 0;
46 case OUTPUT_FMT_GAS:
47 printf(".set %-40s, %5d\n", name, val);
48 return 0;
49 default:
50 log_msg("Unsupported mode: %d", mode);
51 return 1;
52 }
53 }
54
55 int parse_macho(uint8_t *base_buf, size_t sz, output_fmt_t mode) {
56 int i, j;
57 struct mach_header header;
58 uint8_t *buf = base_buf;
59 int base_data_section = 0;
60 int bits = 0;
61
62 /* We can read in mach_header for 32 and 64 bit architectures
63 * because it's identical to mach_header_64 except for the last
64 * element (uint32_t reserved), which we don't use. Then, when
65 * we know which architecture we're looking at, increment buf
66 * appropriately.
67 */
68 memcpy(&header, buf, sizeof(struct mach_header));
69
70 if (header.magic == MH_MAGIC) {
71 if (header.cputype == CPU_TYPE_ARM
72 || header.cputype == CPU_TYPE_X86) {
73 bits = 32;
74 buf += sizeof(struct mach_header);
75 } else {
76 log_msg("Bad cputype for object file. Currently only tested for CPU_TYPE_[ARM|X86].\n");
77 goto bail;
78 }
79 } else if (header.magic == MH_MAGIC_64) {
80 if (header.cputype == CPU_TYPE_X86_64) {
81 bits = 64;
82 buf += sizeof(struct mach_header_64);
83 } else {
84 log_msg("Bad cputype for object file. Currently only tested for CPU_TYPE_X86_64.\n");
85 goto bail;
86 }
87 } else {
88 log_msg("Bad magic number for object file. 0x%x or 0x%x expected, 0x%x found.\n",
89 MH_MAGIC, MH_MAGIC_64, header.magic);
90 goto bail;
91 }
92
93 if (header.filetype != MH_OBJECT) {
94 log_msg("Bad filetype for object file. Currently only tested for MH_OBJECT.\n");
95 goto bail;
96 }
97
98 for (i = 0; i < header.ncmds; i++) {
99 struct load_command lc;
100
101 memcpy(&lc, buf, sizeof(struct load_command));
102
103 if (lc.cmd == LC_SEGMENT) {
104 uint8_t *seg_buf = buf;
105 struct section s;
106 struct segment_command seg_c;
107
108 memcpy(&seg_c, seg_buf, sizeof(struct segment_command));
109 seg_buf += sizeof(struct segment_command);
110
111 /* Although each section is given it's own offset, nlist.n_value
112 * references the offset of the first section. This isn't
113 * apparent without debug information because the offset of the
114 * data section is the same as the first section. However, with
115 * debug sections mixed in, the offset of the debug section
116 * increases but n_value still references the first section.
117 */
118 if (seg_c.nsects < 1) {
119 log_msg("Not enough sections\n");
120 goto bail;
121 }
122
123 memcpy(&s, seg_buf, sizeof(struct section));
124 base_data_section = s.offset;
125 } else if (lc.cmd == LC_SEGMENT_64) {
126 uint8_t *seg_buf = buf;
127 struct section_64 s;
128 struct segment_command_64 seg_c;
129
130 memcpy(&seg_c, seg_buf, sizeof(struct segment_command_64));
131 seg_buf += sizeof(struct segment_command_64);
132
133 /* Explanation in LG_SEGMENT */
134 if (seg_c.nsects < 1) {
135 log_msg("Not enough sections\n");
136 goto bail;
137 }
138
139 memcpy(&s, seg_buf, sizeof(struct section_64));
140 base_data_section = s.offset;
141 } else if (lc.cmd == LC_SYMTAB) {
142 if (base_data_section != 0) {
143 struct symtab_command sc;
144 uint8_t *sym_buf = base_buf;
145 uint8_t *str_buf = base_buf;
146
147 memcpy(&sc, buf, sizeof(struct symtab_command));
148
149 if (sc.cmdsize != sizeof(struct symtab_command)) {
150 log_msg("Can't find symbol table!\n");
151 goto bail;
152 }
153
154 sym_buf += sc.symoff;
155 str_buf += sc.stroff;
156
157 for (j = 0; j < sc.nsyms; j++) {
158 /* Location of string is cacluated each time from the
159 * start of the string buffer. On darwin the symbols
160 * are prefixed by "_", so we bump the pointer by 1.
161 * The target value is defined as an int in *_asm_*_offsets.c,
162 * which is 4 bytes on all targets we currently use.
163 */
164 if (bits == 32) {
165 struct nlist nl;
166 int val;
167
168 memcpy(&nl, sym_buf, sizeof(struct nlist));
169 sym_buf += sizeof(struct nlist);
170
171 memcpy(&val, base_buf + base_data_section + nl.n_value,
172 sizeof(val));
173 print_macho_equ(mode, str_buf + nl.n_un.n_strx + 1, val);
174 } else { /* if (bits == 64) */
175 struct nlist_64 nl;
176 int val;
177
178 memcpy(&nl, sym_buf, sizeof(struct nlist_64));
179 sym_buf += sizeof(struct nlist_64);
180
181 memcpy(&val, base_buf + base_data_section + nl.n_value,
182 sizeof(val));
183 print_macho_equ(mode, str_buf + nl.n_un.n_strx + 1, val);
184 }
185 }
186 }
187 }
188
189 buf += lc.cmdsize;
190 }
191
192 return 0;
193 bail:
194 return 1;
195
196 }
197
198 #elif defined(__ELF__)
199 #include "elf.h"
200
201 #define COPY_STRUCT(dst, buf, ofst, sz) do {\
202 if(ofst + sizeof((*(dst))) > sz) goto bail;\
203 memcpy(dst, buf+ofst, sizeof((*(dst))));\
204 } while(0)
205
206 #define ENDIAN_ASSIGN(val, memb) do {\
207 if(!elf->le_data) {log_msg("Big Endian data not supported yet!\n");goto bail;}\
208 (val) = (memb);\
209 } while(0)
210
211 #define ENDIAN_ASSIGN_IN_PLACE(memb) do {\
212 ENDIAN_ASSIGN(memb, memb);\
213 } while(0)
214
215 typedef struct {
216 uint8_t *buf; /* Buffer containing ELF data */
217 size_t sz; /* Buffer size */
218 int le_data; /* Data is little-endian */
219 unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
220 int bits; /* 32 or 64 */
221 Elf32_Ehdr hdr32;
222 Elf64_Ehdr hdr64;
223 } elf_obj_t;
224
225 int parse_elf_header(elf_obj_t *elf) {
226 int res;
227 /* Verify ELF Magic numbers */
228 COPY_STRUCT(&elf->e_ident, elf->buf, 0, elf->sz);
229 res = elf->e_ident[EI_MAG0] == ELFMAG0;
230 res &= elf->e_ident[EI_MAG1] == ELFMAG1;
231 res &= elf->e_ident[EI_MAG2] == ELFMAG2;
232 res &= elf->e_ident[EI_MAG3] == ELFMAG3;
233 res &= elf->e_ident[EI_CLASS] == ELFCLASS32
234 || elf->e_ident[EI_CLASS] == ELFCLASS64;
235 res &= elf->e_ident[EI_DATA] == ELFDATA2LSB;
236
237 if (!res) goto bail;
238
239 elf->le_data = elf->e_ident[EI_DATA] == ELFDATA2LSB;
240
241 /* Read in relevant values */
242 if (elf->e_ident[EI_CLASS] == ELFCLASS32) {
243 elf->bits = 32;
244 COPY_STRUCT(&elf->hdr32, elf->buf, 0, elf->sz);
245
246 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_type);
247 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_machine);
248 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_version);
249 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_entry);
250 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_phoff);
251 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_shoff);
252 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_flags);
253 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_ehsize);
254 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_phentsize);
255 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_phnum);
256 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_shentsize);
257 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_shnum);
258 ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_shstrndx);
259 } else { /* if (elf->e_ident[EI_CLASS] == ELFCLASS64) */
260 elf->bits = 64;
261 COPY_STRUCT(&elf->hdr64, elf->buf, 0, elf->sz);
262
263 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_type);
264 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_machine);
265 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_version);
266 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_entry);
267 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_phoff);
268 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_shoff);
269 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_flags);
270 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_ehsize);
271 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_phentsize);
272 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_phnum);
273 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_shentsize);
274 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_shnum);
275 ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_shstrndx);
276 }
277
278 return 0;
279 bail:
280 log_msg("Failed to parse ELF file header");
281 return 1;
282 }
283
284 int parse_elf_section(elf_obj_t *elf, int idx, Elf32_Shdr *hdr32, Elf64_Shdr *hdr64) {
285 if (hdr32) {
286 if (idx >= elf->hdr32.e_shnum)
287 goto bail;
288
289 COPY_STRUCT(hdr32, elf->buf, elf->hdr32.e_shoff + idx * elf->hdr32.e_shentsize,
290 elf->sz);
291 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_name);
292 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_type);
293 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_flags);
294 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_addr);
295 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_offset);
296 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_size);
297 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_link);
298 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_info);
299 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_addralign);
300 ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_entsize);
301 } else { /* if (hdr64) */
302 if (idx >= elf->hdr64.e_shnum)
303 goto bail;
304
305 COPY_STRUCT(hdr64, elf->buf, elf->hdr64.e_shoff + idx * elf->hdr64.e_shentsize,
306 elf->sz);
307 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_name);
308 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_type);
309 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_flags);
310 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_addr);
311 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_offset);
312 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_size);
313 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_link);
314 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_info);
315 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_addralign);
316 ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_entsize);
317 }
318
319 return 0;
320 bail:
321 return 1;
322 }
323
324 char *parse_elf_string_table(elf_obj_t *elf, int s_idx, int idx) {
325 if (elf->bits == 32) {
326 Elf32_Shdr shdr;
327
328 if (parse_elf_section(elf, s_idx, &shdr, NULL)) {
329 log_msg("Failed to parse ELF string table: section %d, index %d\n",
330 s_idx, idx);
331 return "";
332 }
333
334 return (char *)(elf->buf + shdr.sh_offset + idx);
335 } else { /* if (elf->bits == 64) */
336 Elf64_Shdr shdr;
337
338 if (parse_elf_section(elf, s_idx, NULL, &shdr)) {
339 log_msg("Failed to parse ELF string table: section %d, index %d\n",
340 s_idx, idx);
341 return "";
342 }
343
344 return (char *)(elf->buf + shdr.sh_offset + idx);
345 }
346 }
347
348 int parse_elf_symbol(elf_obj_t *elf, unsigned int ofst, Elf32_Sym *sym32, Elf64_Sym *sym64) {
349 if (sym32) {
350 COPY_STRUCT(sym32, elf->buf, ofst, elf->sz);
351 ENDIAN_ASSIGN_IN_PLACE(sym32->st_name);
352 ENDIAN_ASSIGN_IN_PLACE(sym32->st_value);
353 ENDIAN_ASSIGN_IN_PLACE(sym32->st_size);
354 ENDIAN_ASSIGN_IN_PLACE(sym32->st_info);
355 ENDIAN_ASSIGN_IN_PLACE(sym32->st_other);
356 ENDIAN_ASSIGN_IN_PLACE(sym32->st_shndx);
357 } else { /* if (sym64) */
358 COPY_STRUCT(sym64, elf->buf, ofst, elf->sz);
359 ENDIAN_ASSIGN_IN_PLACE(sym64->st_name);
360 ENDIAN_ASSIGN_IN_PLACE(sym64->st_value);
361 ENDIAN_ASSIGN_IN_PLACE(sym64->st_size);
362 ENDIAN_ASSIGN_IN_PLACE(sym64->st_info);
363 ENDIAN_ASSIGN_IN_PLACE(sym64->st_other);
364 ENDIAN_ASSIGN_IN_PLACE(sym64->st_shndx);
365 }
366 return 0;
367 bail:
368 return 1;
369 }
370
371 int parse_elf(uint8_t *buf, size_t sz, output_fmt_t mode) {
372 elf_obj_t elf;
373 unsigned int ofst;
374 int i;
375 Elf32_Off strtab_off32;
376 Elf64_Off strtab_off64; /* save String Table offset for later use */
377
378 memset(&elf, 0, sizeof(elf));
379 elf.buf = buf;
380 elf.sz = sz;
381
382 /* Parse Header */
383 if (parse_elf_header(&elf))
384 goto bail;
385
386 if (elf.bits == 32) {
387 Elf32_Shdr shdr;
388 for (i = 0; i < elf.hdr32.e_shnum; i++) {
389 parse_elf_section(&elf, i, &shdr, NULL);
390
391 if (shdr.sh_type == SHT_STRTAB) {
392 char strtsb_name[128];
393
394 strcpy(strtsb_name, (char *)(elf.buf + shdr.sh_offset + shdr.sh_name));
395
396 if (!(strcmp(strtsb_name, ".shstrtab"))) {
397 /* log_msg("found section: %s\n", strtsb_name); */
398 strtab_off32 = shdr.sh_offset;
399 break;
400 }
401 }
402 }
403 } else { /* if (elf.bits == 64) */
404 Elf64_Shdr shdr;
405 for (i = 0; i < elf.hdr64.e_shnum; i++) {
406 parse_elf_section(&elf, i, NULL, &shdr);
407
408 if (shdr.sh_type == SHT_STRTAB) {
409 char strtsb_name[128];
410
411 strcpy(strtsb_name, (char *)(elf.buf + shdr.sh_offset + shdr.sh_name));
412
413 if (!(strcmp(strtsb_name, ".shstrtab"))) {
414 /* log_msg("found section: %s\n", strtsb_name); */
415 strtab_off64 = shdr.sh_offset;
416 break;
417 }
418 }
419 }
420 }
421
422 /* Parse all Symbol Tables */
423 if (elf.bits == 32) {
424 Elf32_Shdr shdr;
425 for (i = 0; i < elf.hdr32.e_shnum; i++) {
426 parse_elf_section(&elf, i, &shdr, NULL);
427
428 if (shdr.sh_type == SHT_SYMTAB) {
429 for (ofst = shdr.sh_offset;
430 ofst < shdr.sh_offset + shdr.sh_size;
431 ofst += shdr.sh_entsize) {
432 Elf32_Sym sym;
433
434 parse_elf_symbol(&elf, ofst, &sym, NULL);
435
436 /* For all OBJECTS (data objects), extract the value from the
437 * proper data segment.
438 */
439 /* if (ELF32_ST_TYPE(sym.st_info) == STT_OBJECT && sym.st_name)
440 log_msg("found data object %s\n",
441 parse_elf_string_table(&elf,
442 shdr.sh_link,
443 sym.st_name));
444 */
445
446 if (ELF32_ST_TYPE(sym.st_info) == STT_OBJECT
447 && sym.st_size == 4) {
448 Elf32_Shdr dhdr;
449 int val = 0;
450 char section_name[128];
451
452 parse_elf_section(&elf, sym.st_shndx, &dhdr, NULL);
453
454 /* For explanition - refer to _MSC_VER version of code */
455 strcpy(section_name, (char *)(elf.buf + strtab_off32 + dhdr.sh_name));
456 /* log_msg("Section_name: %s, Section_type: %d\n", section_name, dhdr.sh_type); */
457
458 if (strcmp(section_name, ".bss")) {
459 if (sizeof(val) != sym.st_size) {
460 /* The target value is declared as an int in
461 * *_asm_*_offsets.c, which is 4 bytes on all
462 * targets we currently use. Complain loudly if
463 * this is not true.
464 */
465 log_msg("Symbol size is wrong\n");
466 goto bail;
467 }
468
469 memcpy(&val,
470 elf.buf + dhdr.sh_offset + sym.st_value,
471 sym.st_size);
472 }
473
474 if (!elf.le_data) {
475 log_msg("Big Endian data not supported yet!\n");
476 goto bail;
477 }
478
479 switch (mode) {
480 case OUTPUT_FMT_RVDS:
481 printf("%-40s EQU %5d\n",
482 parse_elf_string_table(&elf,
483 shdr.sh_link,
484 sym.st_name),
485 val);
486 break;
487 case OUTPUT_FMT_GAS:
488 printf(".equ %-40s, %5d\n",
489 parse_elf_string_table(&elf,
490 shdr.sh_link,
491 sym.st_name),
492 val);
493 break;
494 default:
495 printf("%s = %d\n",
496 parse_elf_string_table(&elf,
497 shdr.sh_link,
498 sym.st_name),
499 val);
500 }
501 }
502 }
503 }
504 }
505 } else { /* if (elf.bits == 64) */
506 Elf64_Shdr shdr;
507 for (i = 0; i < elf.hdr64.e_shnum; i++) {
508 parse_elf_section(&elf, i, NULL, &shdr);
509
510 if (shdr.sh_type == SHT_SYMTAB) {
511 for (ofst = shdr.sh_offset;
512 ofst < shdr.sh_offset + shdr.sh_size;
513 ofst += shdr.sh_entsize) {
514 Elf64_Sym sym;
515
516 parse_elf_symbol(&elf, ofst, NULL, &sym);
517
518 /* For all OBJECTS (data objects), extract the value from the
519 * proper data segment.
520 */
521 /* if (ELF64_ST_TYPE(sym.st_info) == STT_OBJECT && sym.st_name)
522 log_msg("found data object %s\n",
523 parse_elf_string_table(&elf,
524 shdr.sh_link,
525 sym.st_name));
526 */
527
528 if (ELF64_ST_TYPE(sym.st_info) == STT_OBJECT
529 && sym.st_size == 4) {
530 Elf64_Shdr dhdr;
531 int val = 0;
532 char section_name[128];
533
534 parse_elf_section(&elf, sym.st_shndx, NULL, &dhdr);
535
536 /* For explanition - refer to _MSC_VER version of code */
537 strcpy(section_name, (char *)(elf.buf + strtab_off64 + dhdr.sh_name));
538 /* log_msg("Section_name: %s, Section_type: %d\n", section_name, dhdr.sh_type); */
539
540 if ((strcmp(section_name, ".bss"))) {
541 if (sizeof(val) != sym.st_size) {
542 /* The target value is declared as an int in
543 * *_asm_*_offsets.c, which is 4 bytes on all
544 * targets we currently use. Complain loudly if
545 * this is not true.
546 */
547 log_msg("Symbol size is wrong\n");
548 goto bail;
549 }
550
551 memcpy(&val,
552 elf.buf + dhdr.sh_offset + sym.st_value,
553 sym.st_size);
554 }
555
556 if (!elf.le_data) {
557 log_msg("Big Endian data not supported yet!\n");
558 goto bail;
559 }
560
561 switch (mode) {
562 case OUTPUT_FMT_RVDS:
563 printf("%-40s EQU %5d\n",
564 parse_elf_string_table(&elf,
565 shdr.sh_link,
566 sym.st_name),
567 val);
568 break;
569 case OUTPUT_FMT_GAS:
570 printf(".equ %-40s, %5d\n",
571 parse_elf_string_table(&elf,
572 shdr.sh_link,
573 sym.st_name),
574 val);
575 break;
576 default:
577 printf("%s = %d\n",
578 parse_elf_string_table(&elf,
579 shdr.sh_link,
580 sym.st_name),
581 val);
582 }
583 }
584 }
585 }
586 }
587 }
588
589 if (mode == OUTPUT_FMT_RVDS)
590 printf(" END\n");
591
592 return 0;
593 bail:
594 log_msg("Parse error: File does not appear to be valid ELF32 or ELF64\n");
595 return 1;
596 }
597
598 #endif
599 #endif /* defined(__GNUC__) && __GNUC__ */
600
601
602 #if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__)
603 /* See "Microsoft Portable Executable and Common Object File Format Specification"
604 for reference.
605 */
606 #define get_le32(x) ((*(x)) | (*(x+1)) << 8 |(*(x+2)) << 16 | (*(x+3)) << 24 )
607 #define get_le16(x) ((*(x)) | (*(x+1)) << 8)
608
609 int parse_coff(uint8_t *buf, size_t sz) {
610 unsigned int nsections, symtab_ptr, symtab_sz, strtab_ptr;
611 unsigned int sectionrawdata_ptr;
612 unsigned int i;
613 uint8_t *ptr;
614 uint32_t symoffset;
615
616 char **sectionlist; // this array holds all section names in their correct order.
617 // it is used to check if the symbol is in .bss or .rdata section.
618
619 nsections = get_le16(buf + 2);
620 symtab_ptr = get_le32(buf + 8);
621 symtab_sz = get_le32(buf + 12);
622 strtab_ptr = symtab_ptr + symtab_sz * 18;
623
624 if (nsections > 96) {
625 log_msg("Too many sections\n");
626 return 1;
627 }
628
629 sectionlist = malloc(nsections * sizeof(sectionlist));
630
631 if (sectionlist == NULL) {
632 log_msg("Allocating first level of section list failed\n");
633 return 1;
634 }
635
636 // log_msg("COFF: Found %u symbols in %u sections.\n", symtab_sz, nsections);
637
638 /*
639 The size of optional header is always zero for an obj file. So, the section header
640 follows the file header immediately.
641 */
642
643 ptr = buf + 20; // section header
644
645 for (i = 0; i < nsections; i++) {
646 char sectionname[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
647 strncpy(sectionname, ptr, 8);
648 // log_msg("COFF: Parsing section %s\n",sectionname);
649
650 sectionlist[i] = malloc(strlen(sectionname) + 1);
651
652 if (sectionlist[i] == NULL) {
653 log_msg("Allocating storage for %s failed\n", sectionname);
654 goto bail;
655 }
656 strcpy(sectionlist[i], sectionname);
657
658 if (!strcmp(sectionname, ".rdata")) sectionrawdata_ptr = get_le32(ptr + 20);
659
660 ptr += 40;
661 }
662
663 // log_msg("COFF: Symbol table at offset %u\n", symtab_ptr);
664 // log_msg("COFF: raw data pointer ofset for section .rdata is %u\n", sectionrawdata_ptr);
665
666 /* The compiler puts the data with non-zero offset in .rdata section, but puts the data with
667 zero offset in .bss section. So, if the data in in .bss section, set offset=0.
668 Note from Wiki: In an object module compiled from C, the bss section contains
669 the local variables (but not functions) that were declared with the static keyword,
670 except for those with non-zero initial values. (In C, static variables are initialized
671 to zero by default.) It also contains the non-local (both extern and static) variables
672 that are also initialized to zero (either explicitly or by default).
673 */
674 // move to symbol table
675 /* COFF symbol table:
676 offset field
677 0 Name(*)
678 8 Value
679 12 SectionNumber
680 14 Type
681 16 StorageClass
682 17 NumberOfAuxSymbols
683 */
684 ptr = buf + symtab_ptr;
685
686 for (i = 0; i < symtab_sz; i++) {
687 int16_t section = get_le16(ptr + 12); // section number
688
689 if (section > 0 && ptr[16] == 2) {
690 // if(section > 0 && ptr[16] == 3 && get_le32(ptr+8)) {
691
692 if (get_le32(ptr)) {
693 char name[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
694 strncpy(name, ptr, 8);
695 // log_msg("COFF: Parsing symbol %s\n",name);
696 /* The 64bit Windows compiler doesn't prefix with an _.
697 * Check what's there, and bump if necessary
698 */
699 if (name[0] == '_')
700 printf("%-40s EQU ", name + 1);
701 else
702 printf("%-40s EQU ", name);
703 } else {
704 // log_msg("COFF: Parsing symbol %s\n",
705 // buf + strtab_ptr + get_le32(ptr+4));
706 if ((buf + strtab_ptr + get_le32(ptr + 4))[0] == '_')
707 printf("%-40s EQU ",
708 buf + strtab_ptr + get_le32(ptr + 4) + 1);
709 else
710 printf("%-40s EQU ", buf + strtab_ptr + get_le32(ptr + 4));
711 }
712
713 if (!(strcmp(sectionlist[section - 1], ".bss"))) {
714 symoffset = 0;
715 } else {
716 symoffset = get_le32(buf + sectionrawdata_ptr + get_le32(ptr + 8));
717 }
718
719 // log_msg(" Section: %d\n",section);
720 // log_msg(" Class: %d\n",ptr[16]);
721 // log_msg(" Address: %u\n",get_le32(ptr+8));
722 // log_msg(" Offset: %u\n", symoffset);
723
724 printf("%5d\n", symoffset);
725 }
726
727 ptr += 18;
728 }
729
730 printf(" END\n");
731
732 for (i = 0; i < nsections; i++) {
733 free(sectionlist[i]);
734 }
735
736 free(sectionlist);
737
738 return 0;
739 bail:
740
741 for (i = 0; i < nsections; i++) {
742 free(sectionlist[i]);
743 }
744
745 free(sectionlist);
746
747 return 1;
748 }
749 #endif /* defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__) */
750
751 int main(int argc, char **argv) {
752 output_fmt_t mode = OUTPUT_FMT_PLAIN;
753 const char *f;
754 uint8_t *file_buf;
755 int res;
756 FILE *fp;
757 long int file_size;
758
759 if (argc < 2 || argc > 3) {
760 fprintf(stderr, "Usage: %s [output format] <obj file>\n\n", argv[0]);
761 fprintf(stderr, " <obj file>\tobject file to parse\n");
762 fprintf(stderr, "Output Formats:\n");
763 fprintf(stderr, " gas - compatible with GNU assembler\n");
764 fprintf(stderr, " rvds - compatible with armasm\n");
765 goto bail;
766 }
767
768 f = argv[2];
769
770 if (!strcmp(argv[1], "rvds"))
771 mode = OUTPUT_FMT_RVDS;
772 else if (!strcmp(argv[1], "gas"))
773 mode = OUTPUT_FMT_GAS;
774 else
775 f = argv[1];
776
777 fp = fopen(f, "rb");
778
779 if (!fp) {
780 perror("Unable to open file");
781 goto bail;
782 }
783
784 if (fseek(fp, 0, SEEK_END)) {
785 perror("stat");
786 goto bail;
787 }
788
789 file_size = ftell(fp);
790 file_buf = malloc(file_size);
791
792 if (!file_buf) {
793 perror("malloc");
794 goto bail;
795 }
796
797 rewind(fp);
798
799 if (fread(file_buf, sizeof(char), file_size, fp) != file_size) {
800 perror("read");
801 goto bail;
802 }
803
804 if (fclose(fp)) {
805 perror("close");
806 goto bail;
807 }
808
809 #if defined(__GNUC__) && __GNUC__
810 #if defined(__MACH__)
811 res = parse_macho(file_buf, file_size, mode);
812 #elif defined(__ELF__)
813 res = parse_elf(file_buf, file_size, mode);
814 #endif
815 #endif
816 #if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__)
817 res = parse_coff(file_buf, file_size);
818 #endif
819
820 free(file_buf);
821
822 if (!res)
823 return EXIT_SUCCESS;
824
825 bail:
826 return EXIT_FAILURE;
827 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial