obj_int_extract.c 25.4 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,
Tao Bai's avatar
Tao Bai committed
24
  OUTPUT_FMT_C_HEADER,
John Koleszar's avatar
John Koleszar committed
25 26
} output_fmt_t;

John Koleszar's avatar
John Koleszar committed
27 28 29 30 31 32 33
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
34 35 36
}

#if defined(__GNUC__) && __GNUC__
Tao Bai's avatar
Tao Bai committed
37 38 39 40 41 42 43 44 45 46 47 48

#if defined(FORCE_PARSE_ELF)

#if defined(__MACH__)
#undef __MACH__
#endif

#if !defined(__ELF__)
#define __ELF__
#endif
#endif

John Koleszar's avatar
John Koleszar committed
49 50 51 52 53
#if defined(__MACH__)

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

54 55 56 57 58
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;
Johann's avatar
Johann committed
59
    case OUTPUT_FMT_GAS:
60 61
      printf(".set %-40s, %5d\n", name, val);
      return 0;
Johann's avatar
Johann committed
62
    case OUTPUT_FMT_C_HEADER:
Tao Bai's avatar
Tao Bai committed
63 64
      printf("#define %-40s %5d\n", name, val);
      return 0;
65 66 67 68 69 70 71
    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
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
  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
94
    }
John Koleszar's avatar
John Koleszar committed
95 96 97 98 99 100 101
  } 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
102
    }
John Koleszar's avatar
John Koleszar committed
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
  } 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
136
        goto bail;
John Koleszar's avatar
John Koleszar committed
137 138 139 140 141 142 143 144 145 146 147
      }

      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
148

John Koleszar's avatar
John Koleszar committed
149 150 151
      /* Explanation in LG_SEGMENT */
      if (seg_c.nsects < 1) {
        log_msg("Not enough sections\n");
John Koleszar's avatar
John Koleszar committed
152
        goto bail;
John Koleszar's avatar
John Koleszar committed
153
      }
John Koleszar's avatar
John Koleszar committed
154

John Koleszar's avatar
John Koleszar committed
155 156 157 158 159 160 161
      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
162

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

John Koleszar's avatar
John Koleszar committed
165 166 167
        if (sc.cmdsize != sizeof(struct symtab_command)) {
          log_msg("Can't find symbol table!\n");
          goto bail;
John Koleszar's avatar
John Koleszar committed
168 169
        }

John Koleszar's avatar
John Koleszar committed
170 171 172 173 174 175 176
        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.
177
           * The target value is defined as an int in *_asm_*_offsets.c,
John Koleszar's avatar
John Koleszar committed
178 179 180 181 182 183 184 185 186 187 188
           * 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));
189
            print_macho_equ(mode, str_buf + nl.n_un.n_strx + 1, val);
John Koleszar's avatar
John Koleszar committed
190 191 192 193 194 195 196 197 198
          } 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));
199
            print_macho_equ(mode, str_buf + nl.n_un.n_strx + 1, val);
John Koleszar's avatar
John Koleszar committed
200 201 202
          }
        }
      }
John Koleszar's avatar
John Koleszar committed
203 204
    }

John Koleszar's avatar
John Koleszar committed
205 206 207 208
    buf += lc.cmdsize;
  }

  return 0;
John Koleszar's avatar
John Koleszar committed
209
bail:
John Koleszar's avatar
John Koleszar committed
210
  return 1;
John Koleszar's avatar
John Koleszar committed
211 212 213

}

Johann's avatar
Johann committed
214
#elif defined(__ELF__)
John Koleszar's avatar
John Koleszar committed
215 216 217
#include "elf.h"

#define COPY_STRUCT(dst, buf, ofst, sz) do {\
John Koleszar's avatar
John Koleszar committed
218 219 220
    if(ofst + sizeof((*(dst))) > sz) goto bail;\
    memcpy(dst, buf+ofst, sizeof((*(dst))));\
  } while(0)
John Koleszar's avatar
John Koleszar committed
221 222

#define ENDIAN_ASSIGN(val, memb) do {\
John Koleszar's avatar
John Koleszar committed
223 224 225
    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
226 227

#define ENDIAN_ASSIGN_IN_PLACE(memb) do {\
John Koleszar's avatar
John Koleszar committed
228 229 230 231 232 233 234 235 236 237 238
    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
239 240
} elf_obj_t;

John Koleszar's avatar
John Koleszar committed
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 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
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
295
bail:
John Koleszar's avatar
John Koleszar committed
296 297
  log_msg("Failed to parse ELF file header");
  return 1;
John Koleszar's avatar
John Koleszar committed
298 299
}

John Koleszar's avatar
John Koleszar committed
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
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
320

John Koleszar's avatar
John Koleszar committed
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
    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
336
bail:
John Koleszar's avatar
John Koleszar committed
337
  return 1;
John Koleszar's avatar
John Koleszar committed
338 339
}

340
const char *parse_elf_string_table(elf_obj_t *elf, int s_idx, int idx) {
John Koleszar's avatar
John Koleszar committed
341 342
  if (elf->bits == 32) {
    Elf32_Shdr shdr;
Johann's avatar
Johann committed
343

John Koleszar's avatar
John Koleszar committed
344 345 346 347
    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
348 349
    }

John Koleszar's avatar
John Koleszar committed
350 351 352 353 354 355 356 357
    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
358
    }
John Koleszar's avatar
John Koleszar committed
359 360 361

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

John Koleszar's avatar
John Koleszar committed
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
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
383
bail:
John Koleszar's avatar
John Koleszar committed
384
  return 1;
John Koleszar's avatar
John Koleszar committed
385 386
}

John Koleszar's avatar
John Koleszar committed
387 388 389 390 391 392
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
393

John Koleszar's avatar
John Koleszar committed
394 395 396
  memset(&elf, 0, sizeof(elf));
  elf.buf = buf;
  elf.sz = sz;
John Koleszar's avatar
John Koleszar committed
397

John Koleszar's avatar
John Koleszar committed
398 399 400
  /* Parse Header */
  if (parse_elf_header(&elf))
    goto bail;
John Koleszar's avatar
John Koleszar committed
401

John Koleszar's avatar
John Koleszar committed
402 403 404 405 406 407 408 409 410 411 412 413 414 415
  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
416
        }
John Koleszar's avatar
John Koleszar committed
417
      }
John Koleszar's avatar
John Koleszar committed
418
    }
John Koleszar's avatar
John Koleszar committed
419 420 421 422 423 424 425 426 427 428 429 430 431 432
  } 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
433
        }
John Koleszar's avatar
John Koleszar committed
434
      }
Johann's avatar
Johann committed
435
    }
John Koleszar's avatar
John Koleszar committed
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 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
  }

  /* 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
477
                 * *_asm_*_offsets.c, which is 4 bytes on all
John Koleszar's avatar
John Koleszar committed
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
                 * 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
494

John Koleszar's avatar
John Koleszar committed
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
            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;
Tao Bai's avatar
Tao Bai committed
510 511 512 513 514 515 516
              case OUTPUT_FMT_C_HEADER:
                printf("#define %-40s %5d\n",
                       parse_elf_string_table(&elf,
                                              shdr.sh_link,
                                              sym.st_name),
                       val);
                break;
John Koleszar's avatar
John Koleszar committed
517 518 519 520 521 522
              default:
                printf("%s = %d\n",
                       parse_elf_string_table(&elf,
                                              shdr.sh_link,
                                              sym.st_name),
                       val);
Johann's avatar
Johann committed
523
            }
John Koleszar's avatar
John Koleszar committed
524
          }
Johann's avatar
Johann committed
525
        }
John Koleszar's avatar
John Koleszar committed
526
      }
Johann's avatar
Johann committed
527
    }
John Koleszar's avatar
John Koleszar committed
528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
  } 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
566
                 * *_asm_*_offsets.c, which is 4 bytes on all
John Koleszar's avatar
John Koleszar committed
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
                 * 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
605
            }
John Koleszar's avatar
John Koleszar committed
606
          }
John Koleszar's avatar
John Koleszar committed
607
        }
John Koleszar's avatar
John Koleszar committed
608
      }
John Koleszar's avatar
John Koleszar committed
609
    }
John Koleszar's avatar
John Koleszar committed
610
  }
John Koleszar's avatar
John Koleszar committed
611

John Koleszar's avatar
John Koleszar committed
612 613
  if (mode == OUTPUT_FMT_RVDS)
    printf("    END\n");
John Koleszar's avatar
John Koleszar committed
614

John Koleszar's avatar
John Koleszar committed
615
  return 0;
John Koleszar's avatar
John Koleszar committed
616
bail:
John Koleszar's avatar
John Koleszar committed
617 618
  log_msg("Parse error: File does not appear to be valid ELF32 or ELF64\n");
  return 1;
John Koleszar's avatar
John Koleszar committed
619 620 621
}

#endif
Johann's avatar
Johann committed
622
#endif /* defined(__GNUC__) && __GNUC__ */
John Koleszar's avatar
John Koleszar committed
623 624


Johann's avatar
Johann committed
625
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__)
John Koleszar's avatar
John Koleszar committed
626 627 628 629 630 631
/*  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
632 633 634 635 636 637
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
638

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

John Koleszar's avatar
John Koleszar committed
642 643 644 645
  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
646

John Koleszar's avatar
John Koleszar committed
647 648 649 650
  if (nsections > 96) {
    log_msg("Too many sections\n");
    return 1;
  }
John Koleszar's avatar
John Koleszar committed
651

John Koleszar's avatar
John Koleszar committed
652
  sectionlist = malloc(nsections * sizeof(sectionlist));
John Koleszar's avatar
John Koleszar committed
653

John Koleszar's avatar
John Koleszar committed
654 655 656 657
  if (sectionlist == NULL) {
    log_msg("Allocating first level of section list failed\n");
    return 1;
  }
John Koleszar's avatar
John Koleszar committed
658

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

John Koleszar's avatar
John Koleszar committed
661 662 663 664
  /*
  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
665

John Koleszar's avatar
John Koleszar committed
666
  ptr = buf + 20;     // section header
John Koleszar's avatar
John Koleszar committed
667

John Koleszar's avatar
John Koleszar committed
668 669 670 671
  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
672

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

John Koleszar's avatar
John Koleszar committed
675 676 677 678 679 680
    if (sectionlist[i] == NULL) {
      log_msg("Allocating storage for %s failed\n", sectionname);
      goto bail;
    }
    strcpy(sectionlist[i], sectionname);

681 682 683 684 685
    // check if it's .rdata and is not a COMDAT section.
    if (!strcmp(sectionname, ".rdata") &&
        (get_le32(ptr + 36) & 0x1000) == 0) {
      sectionrawdata_ptr = get_le32(ptr + 20);
    }
John Koleszar's avatar
John Koleszar committed
686 687 688 689 690

    ptr += 40;
  }

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

John Koleszar's avatar
John Koleszar committed
693
  /*  The compiler puts the data with non-zero offset in .rdata section, but puts the data with
John Koleszar's avatar
John Koleszar committed
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
      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
739

John Koleszar's avatar
John Koleszar committed
740 741 742 743 744
      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
745

John Koleszar's avatar
John Koleszar committed
746 747 748 749
      // 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
750

John Koleszar's avatar
John Koleszar committed
751
      printf("%5d\n", symoffset);
John Koleszar's avatar
John Koleszar committed
752 753
    }

John Koleszar's avatar
John Koleszar committed
754 755
    ptr += 18;
  }
John Koleszar's avatar
John Koleszar committed
756

John Koleszar's avatar
John Koleszar committed
757 758 759 760 761
  printf("    END\n");

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

John Koleszar's avatar
John Koleszar committed
763
  free(sectionlist);
John Koleszar's avatar
John Koleszar committed
764

John Koleszar's avatar
John Koleszar committed
765
  return 0;
John Koleszar's avatar
John Koleszar committed
766 767
bail:

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

John Koleszar's avatar
John Koleszar committed
772
  free(sectionlist);
John Koleszar's avatar
John Koleszar committed
773

John Koleszar's avatar
John Koleszar committed
774
  return 1;
John Koleszar's avatar
John Koleszar committed
775
}
Johann's avatar
Johann committed
776
#endif /* defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__) */
John Koleszar's avatar
John Koleszar committed
777

John Koleszar's avatar
John Koleszar committed
778 779 780 781 782 783 784 785 786 787 788 789 790 791
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");
Tao Bai's avatar
Tao Bai committed
792
    fprintf(stderr, "  cheader - c/c++ header file\n");
John Koleszar's avatar
John Koleszar committed
793 794 795 796 797 798 799 800 801
    goto bail;
  }

  f = argv[2];

  if (!strcmp(argv[1], "rvds"))
    mode = OUTPUT_FMT_RVDS;
  else if (!strcmp(argv[1], "gas"))
    mode = OUTPUT_FMT_GAS;
Tao Bai's avatar
Tao Bai committed
802 803
  else if (!strcmp(argv[1], "cheader"))
    mode = OUTPUT_FMT_C_HEADER;
John Koleszar's avatar
John Koleszar committed
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
  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
838

Johann's avatar
Johann committed
839 840
#if defined(__GNUC__) && __GNUC__
#if defined(__MACH__)
841
  res = parse_macho(file_buf, file_size, mode);
Johann's avatar
Johann committed
842
#elif defined(__ELF__)
John Koleszar's avatar
John Koleszar committed
843
  res = parse_elf(file_buf, file_size, mode);
Johann's avatar
Johann committed
844 845 846
#endif
#endif
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__)
John Koleszar's avatar
John Koleszar committed
847
  res = parse_coff(file_buf, file_size);
Johann's avatar
Johann committed
848
#endif
John Koleszar's avatar
John Koleszar committed
849

John Koleszar's avatar
John Koleszar committed
850
  free(file_buf);
John Koleszar's avatar
John Koleszar committed
851

John Koleszar's avatar
John Koleszar committed
852 853
  if (!res)
    return EXIT_SUCCESS;
John Koleszar's avatar
John Koleszar committed
854 855

bail:
John Koleszar's avatar
John Koleszar committed
856
  return EXIT_FAILURE;
John Koleszar's avatar
John Koleszar committed
857
}