obj_int_extract.c 24.6 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9
10
11
 */


Johann's avatar
Johann committed
12
#include <stdarg.h>
John Koleszar's avatar
John Koleszar committed
13
14
#include <stdio.h>
#include <stdlib.h>
Johann's avatar
Johann committed
15
#include <string.h>
John Koleszar's avatar
John Koleszar committed
16
17

#include "vpx_config.h"
18
#include "vpx/vpx_integer.h"
John Koleszar's avatar
John Koleszar committed
19

John Koleszar's avatar
John Koleszar committed
20
21
22
23
typedef enum {
  OUTPUT_FMT_PLAIN,
  OUTPUT_FMT_RVDS,
  OUTPUT_FMT_GAS,
John Koleszar's avatar
John Koleszar committed
24
25
} output_fmt_t;

John Koleszar's avatar
John Koleszar committed
26
27
28
29
30
31
32
int log_msg(const char *fmt, ...) {
  int res;
  va_list ap;
  va_start(ap, fmt);
  res = vfprintf(stderr, fmt, ap);
  va_end(ap);
  return res;
John Koleszar's avatar
John Koleszar committed
33
34
35
36
37
38
39
40
}

#if defined(__GNUC__) && __GNUC__
#if defined(__MACH__)

#include <mach-o/loader.h>
#include <mach-o/nlist.h>

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
int print_macho_equ(output_fmt_t mode, uint8_t* name, int val) {
  switch (mode) {
    case OUTPUT_FMT_RVDS:
      printf("%-40s EQU %5d\n", name, val);
      return 0;
    case  OUTPUT_FMT_GAS:
      printf(".set %-40s, %5d\n", name, val);
      return 0;
    default:
      log_msg("Unsupported mode: %d", mode);
      return 1;
  }
}

int parse_macho(uint8_t *base_buf, size_t sz, output_fmt_t mode) {
John Koleszar's avatar
John Koleszar committed
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
  int i, j;
  struct mach_header header;
  uint8_t *buf = base_buf;
  int base_data_section = 0;
  int bits = 0;

  /* We can read in mach_header for 32 and 64 bit architectures
   * because it's identical to mach_header_64 except for the last
   * element (uint32_t reserved), which we don't use. Then, when
   * we know which architecture we're looking at, increment buf
   * appropriately.
   */
  memcpy(&header, buf, sizeof(struct mach_header));

  if (header.magic == MH_MAGIC) {
    if (header.cputype == CPU_TYPE_ARM
        || header.cputype == CPU_TYPE_X86) {
      bits = 32;
      buf += sizeof(struct mach_header);
    } else {
      log_msg("Bad cputype for object file. Currently only tested for CPU_TYPE_[ARM|X86].\n");
      goto bail;
John Koleszar's avatar
John Koleszar committed
78
    }
John Koleszar's avatar
John Koleszar committed
79
80
81
82
83
84
85
  } else if (header.magic == MH_MAGIC_64) {
    if (header.cputype == CPU_TYPE_X86_64) {
      bits = 64;
      buf += sizeof(struct mach_header_64);
    } else {
      log_msg("Bad cputype for object file. Currently only tested for CPU_TYPE_X86_64.\n");
      goto bail;
Johann's avatar
Johann committed
86
    }
John Koleszar's avatar
John Koleszar committed
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
  } else {
    log_msg("Bad magic number for object file. 0x%x or 0x%x expected, 0x%x found.\n",
            MH_MAGIC, MH_MAGIC_64, header.magic);
    goto bail;
  }

  if (header.filetype != MH_OBJECT) {
    log_msg("Bad filetype for object file. Currently only tested for MH_OBJECT.\n");
    goto bail;
  }

  for (i = 0; i < header.ncmds; i++) {
    struct load_command lc;

    memcpy(&lc, buf, sizeof(struct load_command));

    if (lc.cmd == LC_SEGMENT) {
      uint8_t *seg_buf = buf;
      struct section s;
      struct segment_command seg_c;

      memcpy(&seg_c, seg_buf, sizeof(struct segment_command));
      seg_buf += sizeof(struct segment_command);

      /* Although each section is given it's own offset, nlist.n_value
       * references the offset of the first section. This isn't
       * apparent without debug information because the offset of the
       * data section is the same as the first section. However, with
       * debug sections mixed in, the offset of the debug section
       * increases but n_value still references the first section.
       */
      if (seg_c.nsects < 1) {
        log_msg("Not enough sections\n");
John Koleszar's avatar
John Koleszar committed
120
        goto bail;
John Koleszar's avatar
John Koleszar committed
121
122
123
124
125
126
127
128
129
130
131
      }

      memcpy(&s, seg_buf, sizeof(struct section));
      base_data_section = s.offset;
    } else if (lc.cmd == LC_SEGMENT_64) {
      uint8_t *seg_buf = buf;
      struct section_64 s;
      struct segment_command_64 seg_c;

      memcpy(&seg_c, seg_buf, sizeof(struct segment_command_64));
      seg_buf += sizeof(struct segment_command_64);
John Koleszar's avatar
John Koleszar committed
132

John Koleszar's avatar
John Koleszar committed
133
134
135
      /* Explanation in LG_SEGMENT */
      if (seg_c.nsects < 1) {
        log_msg("Not enough sections\n");
John Koleszar's avatar
John Koleszar committed
136
        goto bail;
John Koleszar's avatar
John Koleszar committed
137
      }
John Koleszar's avatar
John Koleszar committed
138

John Koleszar's avatar
John Koleszar committed
139
140
141
142
143
144
145
      memcpy(&s, seg_buf, sizeof(struct section_64));
      base_data_section = s.offset;
    } else if (lc.cmd == LC_SYMTAB) {
      if (base_data_section != 0) {
        struct symtab_command sc;
        uint8_t *sym_buf = base_buf;
        uint8_t *str_buf = base_buf;
John Koleszar's avatar
John Koleszar committed
146

John Koleszar's avatar
John Koleszar committed
147
        memcpy(&sc, buf, sizeof(struct symtab_command));
Johann's avatar
Johann committed
148

John Koleszar's avatar
John Koleszar committed
149
150
151
        if (sc.cmdsize != sizeof(struct symtab_command)) {
          log_msg("Can't find symbol table!\n");
          goto bail;
John Koleszar's avatar
John Koleszar committed
152
153
        }

John Koleszar's avatar
John Koleszar committed
154
155
156
157
158
159
160
        sym_buf += sc.symoff;
        str_buf += sc.stroff;

        for (j = 0; j < sc.nsyms; j++) {
          /* Location of string is cacluated each time from the
           * start of the string buffer.  On darwin the symbols
           * are prefixed by "_", so we bump the pointer by 1.
161
           * The target value is defined as an int in *_asm_*_offsets.c,
John Koleszar's avatar
John Koleszar committed
162
163
164
165
166
167
168
169
170
171
172
           * which is 4 bytes on all targets we currently use.
           */
          if (bits == 32) {
            struct nlist nl;
            int val;

            memcpy(&nl, sym_buf, sizeof(struct nlist));
            sym_buf += sizeof(struct nlist);

            memcpy(&val, base_buf + base_data_section + nl.n_value,
                   sizeof(val));
173
            print_macho_equ(mode, str_buf + nl.n_un.n_strx + 1, val);
John Koleszar's avatar
John Koleszar committed
174
175
176
177
178
179
180
181
182
          } else { /* if (bits == 64) */
            struct nlist_64 nl;
            int val;

            memcpy(&nl, sym_buf, sizeof(struct nlist_64));
            sym_buf += sizeof(struct nlist_64);

            memcpy(&val, base_buf + base_data_section + nl.n_value,
                   sizeof(val));
183
            print_macho_equ(mode, str_buf + nl.n_un.n_strx + 1, val);
John Koleszar's avatar
John Koleszar committed
184
185
186
          }
        }
      }
John Koleszar's avatar
John Koleszar committed
187
188
    }

John Koleszar's avatar
John Koleszar committed
189
190
191
192
    buf += lc.cmdsize;
  }

  return 0;
John Koleszar's avatar
John Koleszar committed
193
bail:
John Koleszar's avatar
John Koleszar committed
194
  return 1;
John Koleszar's avatar
John Koleszar committed
195
196
197

}

Johann's avatar
Johann committed
198
#elif defined(__ELF__)
John Koleszar's avatar
John Koleszar committed
199
200
201
#include "elf.h"

#define COPY_STRUCT(dst, buf, ofst, sz) do {\
John Koleszar's avatar
John Koleszar committed
202
203
204
    if(ofst + sizeof((*(dst))) > sz) goto bail;\
    memcpy(dst, buf+ofst, sizeof((*(dst))));\
  } while(0)
John Koleszar's avatar
John Koleszar committed
205
206

#define ENDIAN_ASSIGN(val, memb) do {\
John Koleszar's avatar
John Koleszar committed
207
208
209
    if(!elf->le_data) {log_msg("Big Endian data not supported yet!\n");goto bail;}\
    (val) = (memb);\
  } while(0)
John Koleszar's avatar
John Koleszar committed
210
211

#define ENDIAN_ASSIGN_IN_PLACE(memb) do {\
John Koleszar's avatar
John Koleszar committed
212
213
214
215
216
217
218
219
220
221
222
    ENDIAN_ASSIGN(memb, memb);\
  } while(0)

typedef struct {
  uint8_t      *buf; /* Buffer containing ELF data */
  size_t        sz;  /* Buffer size */
  int           le_data; /* Data is little-endian */
  unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
  int           bits; /* 32 or 64 */
  Elf32_Ehdr    hdr32;
  Elf64_Ehdr    hdr64;
John Koleszar's avatar
John Koleszar committed
223
224
} elf_obj_t;

John Koleszar's avatar
John Koleszar committed
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
int parse_elf_header(elf_obj_t *elf) {
  int res;
  /* Verify ELF Magic numbers */
  COPY_STRUCT(&elf->e_ident, elf->buf, 0, elf->sz);
  res = elf->e_ident[EI_MAG0] == ELFMAG0;
  res &= elf->e_ident[EI_MAG1] == ELFMAG1;
  res &= elf->e_ident[EI_MAG2] == ELFMAG2;
  res &= elf->e_ident[EI_MAG3] == ELFMAG3;
  res &= elf->e_ident[EI_CLASS] == ELFCLASS32
         || elf->e_ident[EI_CLASS] == ELFCLASS64;
  res &= elf->e_ident[EI_DATA] == ELFDATA2LSB;

  if (!res) goto bail;

  elf->le_data = elf->e_ident[EI_DATA] == ELFDATA2LSB;

  /* Read in relevant values */
  if (elf->e_ident[EI_CLASS] == ELFCLASS32) {
    elf->bits = 32;
    COPY_STRUCT(&elf->hdr32, elf->buf, 0, elf->sz);

    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_type);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_machine);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_version);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_entry);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_phoff);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_shoff);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_flags);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_ehsize);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_phentsize);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_phnum);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_shentsize);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_shnum);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr32.e_shstrndx);
  } else { /* if (elf->e_ident[EI_CLASS] == ELFCLASS64) */
    elf->bits = 64;
    COPY_STRUCT(&elf->hdr64, elf->buf, 0, elf->sz);

    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_type);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_machine);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_version);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_entry);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_phoff);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_shoff);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_flags);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_ehsize);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_phentsize);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_phnum);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_shentsize);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_shnum);
    ENDIAN_ASSIGN_IN_PLACE(elf->hdr64.e_shstrndx);
  }

  return 0;
John Koleszar's avatar
John Koleszar committed
279
bail:
John Koleszar's avatar
John Koleszar committed
280
281
  log_msg("Failed to parse ELF file header");
  return 1;
John Koleszar's avatar
John Koleszar committed
282
283
}

John Koleszar's avatar
John Koleszar committed
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
int parse_elf_section(elf_obj_t *elf, int idx, Elf32_Shdr *hdr32, Elf64_Shdr *hdr64) {
  if (hdr32) {
    if (idx >= elf->hdr32.e_shnum)
      goto bail;

    COPY_STRUCT(hdr32, elf->buf, elf->hdr32.e_shoff + idx * elf->hdr32.e_shentsize,
                elf->sz);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_name);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_type);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_flags);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_addr);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_offset);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_size);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_link);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_info);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_addralign);
    ENDIAN_ASSIGN_IN_PLACE(hdr32->sh_entsize);
  } else { /* if (hdr64) */
    if (idx >= elf->hdr64.e_shnum)
      goto bail;
John Koleszar's avatar
John Koleszar committed
304

John Koleszar's avatar
John Koleszar committed
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
    COPY_STRUCT(hdr64, elf->buf, elf->hdr64.e_shoff + idx * elf->hdr64.e_shentsize,
                elf->sz);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_name);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_type);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_flags);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_addr);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_offset);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_size);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_link);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_info);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_addralign);
    ENDIAN_ASSIGN_IN_PLACE(hdr64->sh_entsize);
  }

  return 0;
John Koleszar's avatar
John Koleszar committed
320
bail:
John Koleszar's avatar
John Koleszar committed
321
  return 1;
John Koleszar's avatar
John Koleszar committed
322
323
}

John Koleszar's avatar
John Koleszar committed
324
325
326
char *parse_elf_string_table(elf_obj_t *elf, int s_idx, int idx) {
  if (elf->bits == 32) {
    Elf32_Shdr shdr;
Johann's avatar
Johann committed
327

John Koleszar's avatar
John Koleszar committed
328
329
330
331
    if (parse_elf_section(elf, s_idx, &shdr, NULL)) {
      log_msg("Failed to parse ELF string table: section %d, index %d\n",
              s_idx, idx);
      return "";
John Koleszar's avatar
John Koleszar committed
332
333
    }

John Koleszar's avatar
John Koleszar committed
334
335
336
337
338
339
340
341
    return (char *)(elf->buf + shdr.sh_offset + idx);
  } else { /* if (elf->bits == 64) */
    Elf64_Shdr shdr;

    if (parse_elf_section(elf, s_idx, NULL, &shdr)) {
      log_msg("Failed to parse ELF string table: section %d, index %d\n",
              s_idx, idx);
      return "";
Johann's avatar
Johann committed
342
    }
John Koleszar's avatar
John Koleszar committed
343
344
345

    return (char *)(elf->buf + shdr.sh_offset + idx);
  }
John Koleszar's avatar
John Koleszar committed
346
347
}

John Koleszar's avatar
John Koleszar committed
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
int parse_elf_symbol(elf_obj_t *elf, unsigned int ofst, Elf32_Sym *sym32, Elf64_Sym *sym64) {
  if (sym32) {
    COPY_STRUCT(sym32, elf->buf, ofst, elf->sz);
    ENDIAN_ASSIGN_IN_PLACE(sym32->st_name);
    ENDIAN_ASSIGN_IN_PLACE(sym32->st_value);
    ENDIAN_ASSIGN_IN_PLACE(sym32->st_size);
    ENDIAN_ASSIGN_IN_PLACE(sym32->st_info);
    ENDIAN_ASSIGN_IN_PLACE(sym32->st_other);
    ENDIAN_ASSIGN_IN_PLACE(sym32->st_shndx);
  } else { /* if (sym64) */
    COPY_STRUCT(sym64, elf->buf, ofst, elf->sz);
    ENDIAN_ASSIGN_IN_PLACE(sym64->st_name);
    ENDIAN_ASSIGN_IN_PLACE(sym64->st_value);
    ENDIAN_ASSIGN_IN_PLACE(sym64->st_size);
    ENDIAN_ASSIGN_IN_PLACE(sym64->st_info);
    ENDIAN_ASSIGN_IN_PLACE(sym64->st_other);
    ENDIAN_ASSIGN_IN_PLACE(sym64->st_shndx);
  }
  return 0;
John Koleszar's avatar
John Koleszar committed
367
bail:
John Koleszar's avatar
John Koleszar committed
368
  return 1;
John Koleszar's avatar
John Koleszar committed
369
370
}

John Koleszar's avatar
John Koleszar committed
371
372
373
374
375
376
int parse_elf(uint8_t *buf, size_t sz, output_fmt_t mode) {
  elf_obj_t    elf;
  unsigned int ofst;
  int          i;
  Elf32_Off    strtab_off32;
  Elf64_Off    strtab_off64; /* save String Table offset for later use */
John Koleszar's avatar
John Koleszar committed
377

John Koleszar's avatar
John Koleszar committed
378
379
380
  memset(&elf, 0, sizeof(elf));
  elf.buf = buf;
  elf.sz = sz;
John Koleszar's avatar
John Koleszar committed
381

John Koleszar's avatar
John Koleszar committed
382
383
384
  /* Parse Header */
  if (parse_elf_header(&elf))
    goto bail;
John Koleszar's avatar
John Koleszar committed
385

John Koleszar's avatar
John Koleszar committed
386
387
388
389
390
391
392
393
394
395
396
397
398
399
  if (elf.bits == 32) {
    Elf32_Shdr shdr;
    for (i = 0; i < elf.hdr32.e_shnum; i++) {
      parse_elf_section(&elf, i, &shdr, NULL);

      if (shdr.sh_type == SHT_STRTAB) {
        char strtsb_name[128];

        strcpy(strtsb_name, (char *)(elf.buf + shdr.sh_offset + shdr.sh_name));

        if (!(strcmp(strtsb_name, ".shstrtab"))) {
          /* log_msg("found section: %s\n", strtsb_name); */
          strtab_off32 = shdr.sh_offset;
          break;
John Koleszar's avatar
John Koleszar committed
400
        }
John Koleszar's avatar
John Koleszar committed
401
      }
John Koleszar's avatar
John Koleszar committed
402
    }
John Koleszar's avatar
John Koleszar committed
403
404
405
406
407
408
409
410
411
412
413
414
415
416
  } else { /* if (elf.bits == 64) */
    Elf64_Shdr shdr;
    for (i = 0; i < elf.hdr64.e_shnum; i++) {
      parse_elf_section(&elf, i, NULL, &shdr);

      if (shdr.sh_type == SHT_STRTAB) {
        char strtsb_name[128];

        strcpy(strtsb_name, (char *)(elf.buf + shdr.sh_offset + shdr.sh_name));

        if (!(strcmp(strtsb_name, ".shstrtab"))) {
          /* log_msg("found section: %s\n", strtsb_name); */
          strtab_off64 = shdr.sh_offset;
          break;
Johann's avatar
Johann committed
417
        }
John Koleszar's avatar
John Koleszar committed
418
      }
Johann's avatar
Johann committed
419
    }
John Koleszar's avatar
John Koleszar committed
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
  }

  /* Parse all Symbol Tables */
  if (elf.bits == 32) {
    Elf32_Shdr shdr;
    for (i = 0; i < elf.hdr32.e_shnum; i++) {
      parse_elf_section(&elf, i, &shdr, NULL);

      if (shdr.sh_type == SHT_SYMTAB) {
        for (ofst = shdr.sh_offset;
             ofst < shdr.sh_offset + shdr.sh_size;
             ofst += shdr.sh_entsize) {
          Elf32_Sym sym;

          parse_elf_symbol(&elf, ofst, &sym, NULL);

          /* For all OBJECTS (data objects), extract the value from the
           * proper data segment.
           */
          /* if (ELF32_ST_TYPE(sym.st_info) == STT_OBJECT && sym.st_name)
              log_msg("found data object %s\n",
                      parse_elf_string_table(&elf,
                                             shdr.sh_link,
                                             sym.st_name));
           */

          if (ELF32_ST_TYPE(sym.st_info) == STT_OBJECT
              && sym.st_size == 4) {
            Elf32_Shdr dhdr;
            int val = 0;
            char section_name[128];

            parse_elf_section(&elf, sym.st_shndx, &dhdr, NULL);

            /* For explanition - refer to _MSC_VER version of code */
            strcpy(section_name, (char *)(elf.buf + strtab_off32 + dhdr.sh_name));
            /* log_msg("Section_name: %s, Section_type: %d\n", section_name, dhdr.sh_type); */

            if (strcmp(section_name, ".bss")) {
              if (sizeof(val) != sym.st_size) {
                /* The target value is declared as an int in
461
                 * *_asm_*_offsets.c, which is 4 bytes on all
John Koleszar's avatar
John Koleszar committed
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
                 * targets we currently use. Complain loudly if
                 * this is not true.
                 */
                log_msg("Symbol size is wrong\n");
                goto bail;
              }

              memcpy(&val,
                     elf.buf + dhdr.sh_offset + sym.st_value,
                     sym.st_size);
            }

            if (!elf.le_data) {
              log_msg("Big Endian data not supported yet!\n");
              goto bail;
            }
John Koleszar's avatar
John Koleszar committed
478

John Koleszar's avatar
John Koleszar committed
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
            switch (mode) {
              case OUTPUT_FMT_RVDS:
                printf("%-40s EQU %5d\n",
                       parse_elf_string_table(&elf,
                                              shdr.sh_link,
                                              sym.st_name),
                       val);
                break;
              case OUTPUT_FMT_GAS:
                printf(".equ %-40s, %5d\n",
                       parse_elf_string_table(&elf,
                                              shdr.sh_link,
                                              sym.st_name),
                       val);
                break;
              default:
                printf("%s = %d\n",
                       parse_elf_string_table(&elf,
                                              shdr.sh_link,
                                              sym.st_name),
                       val);
Johann's avatar
Johann committed
500
            }
John Koleszar's avatar
John Koleszar committed
501
          }
Johann's avatar
Johann committed
502
        }
John Koleszar's avatar
John Koleszar committed
503
      }
Johann's avatar
Johann committed
504
    }
John Koleszar's avatar
John Koleszar committed
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
  } else { /* if (elf.bits == 64) */
    Elf64_Shdr shdr;
    for (i = 0; i < elf.hdr64.e_shnum; i++) {
      parse_elf_section(&elf, i, NULL, &shdr);

      if (shdr.sh_type == SHT_SYMTAB) {
        for (ofst = shdr.sh_offset;
             ofst < shdr.sh_offset + shdr.sh_size;
             ofst += shdr.sh_entsize) {
          Elf64_Sym sym;

          parse_elf_symbol(&elf, ofst, NULL, &sym);

          /* For all OBJECTS (data objects), extract the value from the
           * proper data segment.
           */
          /* if (ELF64_ST_TYPE(sym.st_info) == STT_OBJECT && sym.st_name)
              log_msg("found data object %s\n",
                      parse_elf_string_table(&elf,
                                             shdr.sh_link,
                                             sym.st_name));
           */

          if (ELF64_ST_TYPE(sym.st_info) == STT_OBJECT
              && sym.st_size == 4) {
            Elf64_Shdr dhdr;
            int val = 0;
            char section_name[128];

            parse_elf_section(&elf, sym.st_shndx, NULL, &dhdr);

            /* For explanition - refer to _MSC_VER version of code */
            strcpy(section_name, (char *)(elf.buf + strtab_off64 + dhdr.sh_name));
            /* log_msg("Section_name: %s, Section_type: %d\n", section_name, dhdr.sh_type); */

            if ((strcmp(section_name, ".bss"))) {
              if (sizeof(val) != sym.st_size) {
                /* The target value is declared as an int in
543
                 * *_asm_*_offsets.c, which is 4 bytes on all
John Koleszar's avatar
John Koleszar committed
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
                 * targets we currently use. Complain loudly if
                 * this is not true.
                 */
                log_msg("Symbol size is wrong\n");
                goto bail;
              }

              memcpy(&val,
                     elf.buf + dhdr.sh_offset + sym.st_value,
                     sym.st_size);
            }

            if (!elf.le_data) {
              log_msg("Big Endian data not supported yet!\n");
              goto bail;
            }

            switch (mode) {
              case OUTPUT_FMT_RVDS:
                printf("%-40s EQU %5d\n",
                       parse_elf_string_table(&elf,
                                              shdr.sh_link,
                                              sym.st_name),
                       val);
                break;
              case OUTPUT_FMT_GAS:
                printf(".equ %-40s, %5d\n",
                       parse_elf_string_table(&elf,
                                              shdr.sh_link,
                                              sym.st_name),
                       val);
                break;
              default:
                printf("%s = %d\n",
                       parse_elf_string_table(&elf,
                                              shdr.sh_link,
                                              sym.st_name),
                       val);
John Koleszar's avatar
John Koleszar committed
582
            }
John Koleszar's avatar
John Koleszar committed
583
          }
John Koleszar's avatar
John Koleszar committed
584
        }
John Koleszar's avatar
John Koleszar committed
585
      }
John Koleszar's avatar
John Koleszar committed
586
    }
John Koleszar's avatar
John Koleszar committed
587
  }
John Koleszar's avatar
John Koleszar committed
588

John Koleszar's avatar
John Koleszar committed
589
590
  if (mode == OUTPUT_FMT_RVDS)
    printf("    END\n");
John Koleszar's avatar
John Koleszar committed
591

John Koleszar's avatar
John Koleszar committed
592
  return 0;
John Koleszar's avatar
John Koleszar committed
593
bail:
John Koleszar's avatar
John Koleszar committed
594
595
  log_msg("Parse error: File does not appear to be valid ELF32 or ELF64\n");
  return 1;
John Koleszar's avatar
John Koleszar committed
596
597
598
}

#endif
Johann's avatar
Johann committed
599
#endif /* defined(__GNUC__) && __GNUC__ */
John Koleszar's avatar
John Koleszar committed
600
601


Johann's avatar
Johann committed
602
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__)
John Koleszar's avatar
John Koleszar committed
603
604
605
606
607
608
/*  See "Microsoft Portable Executable and Common Object File Format Specification"
    for reference.
*/
#define get_le32(x) ((*(x)) | (*(x+1)) << 8 |(*(x+2)) << 16 | (*(x+3)) << 24 )
#define get_le16(x) ((*(x)) | (*(x+1)) << 8)

John Koleszar's avatar
John Koleszar committed
609
610
611
612
613
614
int parse_coff(uint8_t *buf, size_t sz) {
  unsigned int nsections, symtab_ptr, symtab_sz, strtab_ptr;
  unsigned int sectionrawdata_ptr;
  unsigned int i;
  uint8_t *ptr;
  uint32_t symoffset;
John Koleszar's avatar
John Koleszar committed
615

John Koleszar's avatar
John Koleszar committed
616
  char **sectionlist;  // this array holds all section names in their correct order.
John Koleszar's avatar
John Koleszar committed
617
  // it is used to check if the symbol is in .bss or .rdata section.
Johann's avatar
Johann committed
618

John Koleszar's avatar
John Koleszar committed
619
620
621
622
  nsections = get_le16(buf + 2);
  symtab_ptr = get_le32(buf + 8);
  symtab_sz = get_le32(buf + 12);
  strtab_ptr = symtab_ptr + symtab_sz * 18;
John Koleszar's avatar
John Koleszar committed
623

John Koleszar's avatar
John Koleszar committed
624
625
626
627
  if (nsections > 96) {
    log_msg("Too many sections\n");
    return 1;
  }
John Koleszar's avatar
John Koleszar committed
628

John Koleszar's avatar
John Koleszar committed
629
  sectionlist = malloc(nsections * sizeof(sectionlist));
John Koleszar's avatar
John Koleszar committed
630

John Koleszar's avatar
John Koleszar committed
631
632
633
634
  if (sectionlist == NULL) {
    log_msg("Allocating first level of section list failed\n");
    return 1;
  }
John Koleszar's avatar
John Koleszar committed
635

John Koleszar's avatar
John Koleszar committed
636
  // log_msg("COFF: Found %u symbols in %u sections.\n", symtab_sz, nsections);
John Koleszar's avatar
John Koleszar committed
637

John Koleszar's avatar
John Koleszar committed
638
639
640
641
  /*
  The size of optional header is always zero for an obj file. So, the section header
  follows the file header immediately.
  */
Johann's avatar
Johann committed
642

John Koleszar's avatar
John Koleszar committed
643
  ptr = buf + 20;     // section header
John Koleszar's avatar
John Koleszar committed
644

John Koleszar's avatar
John Koleszar committed
645
646
647
648
  for (i = 0; i < nsections; i++) {
    char sectionname[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
    strncpy(sectionname, ptr, 8);
    // log_msg("COFF: Parsing section %s\n",sectionname);
John Koleszar's avatar
John Koleszar committed
649

John Koleszar's avatar
John Koleszar committed
650
    sectionlist[i] = malloc(strlen(sectionname) + 1);
John Koleszar's avatar
John Koleszar committed
651

John Koleszar's avatar
John Koleszar committed
652
653
654
655
656
657
    if (sectionlist[i] == NULL) {
      log_msg("Allocating storage for %s failed\n", sectionname);
      goto bail;
    }
    strcpy(sectionlist[i], sectionname);

John Koleszar's avatar
John Koleszar committed
658
    if (!strcmp(sectionname, ".rdata")) sectionrawdata_ptr = get_le32(ptr + 20);
John Koleszar's avatar
John Koleszar committed
659
660
661
662
663

    ptr += 40;
  }

  // log_msg("COFF: Symbol table at offset %u\n", symtab_ptr);
John Koleszar's avatar
John Koleszar committed
664
  // log_msg("COFF: raw data pointer ofset for section .rdata is %u\n", sectionrawdata_ptr);
John Koleszar's avatar
John Koleszar committed
665

John Koleszar's avatar
John Koleszar committed
666
  /*  The compiler puts the data with non-zero offset in .rdata section, but puts the data with
John Koleszar's avatar
John Koleszar committed
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
      zero offset in .bss section. So, if the data in in .bss section, set offset=0.
      Note from Wiki: In an object module compiled from C, the bss section contains
      the local variables (but not functions) that were declared with the static keyword,
      except for those with non-zero initial values. (In C, static variables are initialized
      to zero by default.) It also contains the non-local (both extern and static) variables
      that are also initialized to zero (either explicitly or by default).
      */
  // move to symbol table
  /* COFF symbol table:
      offset      field
      0           Name(*)
      8           Value
      12          SectionNumber
      14          Type
      16          StorageClass
      17          NumberOfAuxSymbols
      */
  ptr = buf + symtab_ptr;

  for (i = 0; i < symtab_sz; i++) {
    int16_t section = get_le16(ptr + 12); // section number

    if (section > 0 && ptr[16] == 2) {
      // if(section > 0 && ptr[16] == 3 && get_le32(ptr+8)) {

      if (get_le32(ptr)) {
        char name[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
        strncpy(name, ptr, 8);
        // log_msg("COFF: Parsing symbol %s\n",name);
        /* The 64bit Windows compiler doesn't prefix with an _.
         * Check what's there, and bump if necessary
         */
        if (name[0] == '_')
          printf("%-40s EQU ", name + 1);
        else
          printf("%-40s EQU ", name);
      } else {
        // log_msg("COFF: Parsing symbol %s\n",
        //        buf + strtab_ptr + get_le32(ptr+4));
        if ((buf + strtab_ptr + get_le32(ptr + 4))[0] == '_')
          printf("%-40s EQU ",
                 buf + strtab_ptr + get_le32(ptr + 4) + 1);
        else
          printf("%-40s EQU ", buf + strtab_ptr + get_le32(ptr + 4));
      }
John Koleszar's avatar
John Koleszar committed
712

John Koleszar's avatar
John Koleszar committed
713
714
715
716
717
      if (!(strcmp(sectionlist[section - 1], ".bss"))) {
        symoffset = 0;
      } else {
        symoffset = get_le32(buf + sectionrawdata_ptr + get_le32(ptr + 8));
      }
John Koleszar's avatar
John Koleszar committed
718

John Koleszar's avatar
John Koleszar committed
719
720
721
722
      // log_msg("      Section: %d\n",section);
      // log_msg("      Class:   %d\n",ptr[16]);
      // log_msg("      Address: %u\n",get_le32(ptr+8));
      // log_msg("      Offset: %u\n", symoffset);
John Koleszar's avatar
John Koleszar committed
723

John Koleszar's avatar
John Koleszar committed
724
      printf("%5d\n", symoffset);
John Koleszar's avatar
John Koleszar committed
725
726
    }

John Koleszar's avatar
John Koleszar committed
727
728
    ptr += 18;
  }
John Koleszar's avatar
John Koleszar committed
729

John Koleszar's avatar
John Koleszar committed
730
731
732
733
734
  printf("    END\n");

  for (i = 0; i < nsections; i++) {
    free(sectionlist[i]);
  }
John Koleszar's avatar
John Koleszar committed
735

John Koleszar's avatar
John Koleszar committed
736
  free(sectionlist);
John Koleszar's avatar
John Koleszar committed
737

John Koleszar's avatar
John Koleszar committed
738
  return 0;
John Koleszar's avatar
John Koleszar committed
739
740
bail:

John Koleszar's avatar
John Koleszar committed
741
742
743
  for (i = 0; i < nsections; i++) {
    free(sectionlist[i]);
  }
John Koleszar's avatar
John Koleszar committed
744

John Koleszar's avatar
John Koleszar committed
745
  free(sectionlist);
John Koleszar's avatar
John Koleszar committed
746

John Koleszar's avatar
John Koleszar committed
747
  return 1;
John Koleszar's avatar
John Koleszar committed
748
}
Johann's avatar
Johann committed
749
#endif /* defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__) */
John Koleszar's avatar
John Koleszar committed
750

John Koleszar's avatar
John Koleszar committed
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
int main(int argc, char **argv) {
  output_fmt_t mode = OUTPUT_FMT_PLAIN;
  const char *f;
  uint8_t *file_buf;
  int res;
  FILE *fp;
  long int file_size;

  if (argc < 2 || argc > 3) {
    fprintf(stderr, "Usage: %s [output format] <obj file>\n\n", argv[0]);
    fprintf(stderr, "  <obj file>\tobject file to parse\n");
    fprintf(stderr, "Output Formats:\n");
    fprintf(stderr, "  gas  - compatible with GNU assembler\n");
    fprintf(stderr, "  rvds - compatible with armasm\n");
    goto bail;
  }

  f = argv[2];

  if (!strcmp(argv[1], "rvds"))
    mode = OUTPUT_FMT_RVDS;
  else if (!strcmp(argv[1], "gas"))
    mode = OUTPUT_FMT_GAS;
  else
    f = argv[1];

  fp = fopen(f, "rb");

  if (!fp) {
    perror("Unable to open file");
    goto bail;
  }

  if (fseek(fp, 0, SEEK_END)) {
    perror("stat");
    goto bail;
  }

  file_size = ftell(fp);
  file_buf = malloc(file_size);

  if (!file_buf) {
    perror("malloc");
    goto bail;
  }

  rewind(fp);

  if (fread(file_buf, sizeof(char), file_size, fp) != file_size) {
    perror("read");
    goto bail;
  }

  if (fclose(fp)) {
    perror("close");
    goto bail;
  }
John Koleszar's avatar
John Koleszar committed
808

Johann's avatar
Johann committed
809
810
#if defined(__GNUC__) && __GNUC__
#if defined(__MACH__)
811
  res = parse_macho(file_buf, file_size, mode);
Johann's avatar
Johann committed
812
#elif defined(__ELF__)
John Koleszar's avatar
John Koleszar committed
813
  res = parse_elf(file_buf, file_size, mode);
Johann's avatar
Johann committed
814
815
816
#endif
#endif
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__)
John Koleszar's avatar
John Koleszar committed
817
  res = parse_coff(file_buf, file_size);
Johann's avatar
Johann committed
818
#endif
John Koleszar's avatar
John Koleszar committed
819

John Koleszar's avatar
John Koleszar committed
820
  free(file_buf);
John Koleszar's avatar
John Koleszar committed
821

John Koleszar's avatar
John Koleszar committed
822
823
  if (!res)
    return EXIT_SUCCESS;
John Koleszar's avatar
John Koleszar committed
824
825

bail:
John Koleszar's avatar
John Koleszar committed
826
  return EXIT_FAILURE;
John Koleszar's avatar
John Koleszar committed
827
}