1/* 2 * Copyright (C) 1996-1997 John D. Polstra. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY JOHN D. POLSTRA AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL JOHN D. POLSTRA OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26#include <sys/cdefs.h> 27__FBSDID("$FreeBSD$"); 28 29#include <sys/types.h> 30#include <sys/mman.h> 31#include <sys/stat.h> 32 33#include <machine/elf.h> 34 35#include <arpa/inet.h> 36 37#include <a.out.h> 38#include <assert.h> 39#include <ctype.h> 40#include <err.h> 41#include <fcntl.h> 42#include <sys/link_aout.h> 43#include <stab.h> 44#include <stdio.h> 45#include <stdlib.h> 46#include <string.h> 47#include <unistd.h> 48 49#include "extern.h" 50 51#define PAGE_SIZE 4096 /* i386 specific */ 52 53#ifndef N_SETA 54#define N_SETA 0x14 /* Absolute set element symbol */ 55#endif /* This is input to LD, in a .o file. */ 56 57#ifndef N_SETT 58#define N_SETT 0x16 /* Text set element symbol */ 59#endif /* This is input to LD, in a .o file. */ 60 61#ifndef N_SETD 62#define N_SETD 0x18 /* Data set element symbol */ 63#endif /* This is input to LD, in a .o file. */ 64 65#ifndef N_SETB 66#define N_SETB 0x1A /* Bss set element symbol */ 67#endif /* This is input to LD, in a .o file. */ 68 69#ifndef N_SETV 70#define N_SETV 0x1C /* Pointer to set vector in data area. */ 71#endif /* This is output from LD. */ 72 73#ifdef STANDALONE 74static 75#endif 76 77static void dump_rels(const char *, const struct relocation_info *, 78 unsigned long, const char *(*)(unsigned long), unsigned char *); 79static void dump_segs(void); 80static void dump_sods(void); 81static void dump_sym(const struct nlist *); 82static void dump_syms(void); 83 84static void dump_rtsyms(void); 85 86static const char *rtsym_name(unsigned long); 87static const char *sym_name(unsigned long); 88 89#ifdef STANDALONE 90static 91#endif 92int error_count; 93 94/* 95 * Variables ending in _base are pointers to things in our address space, 96 * i.e., in the file itself. 97 * 98 * Variables ending in _addr are adjusted according to where things would 99 * actually appear in memory if the file were loaded. 100 */ 101static const char *file_base; 102static const char *text_base; 103static const char *data_base; 104static const struct relocation_info *rel_base; 105static const struct nlist *sym_base; 106static const char *str_base; 107 108static const struct relocation_info *rtrel_base; 109static const struct nzlist *rtsym_base; 110static const char *rtstr_base; 111 112static const struct exec *ex; 113static const struct _dynamic *dyn; 114static const struct section_dispatch_table *sdt; 115 116static const char *text_addr; 117static const char *data_addr; 118 119static unsigned long rel_count; 120static unsigned long sym_count; 121 122static unsigned long rtrel_count; 123static unsigned long rtsym_count; 124 125/* Dynamically allocated flags, 1 byte per symbol, to record whether each 126 symbol was referenced by a relocation entry. */ 127static unsigned char *sym_used; 128static unsigned char *rtsym_used; 129 130static unsigned long origin; /* What values are relocated relative to */ 131 132#ifdef STANDALONE 133int 134main(int argc, char *argv[]) 135{ 136 int i; 137 138 for (i = 1; i < argc; ++i) 139 dump_file(argv[i]); 140 141 return error_count == 0 ? EXIT_SUCCESS : EXIT_FAILURE; 142} 143#endif 144 145static inline const void *align_struct(const void *expr) 146{ 147 assert(!(((int)expr) & 3)); 148 return expr; 149} 150 151static inline const void *align_long(const void *expr) 152{ 153 assert(!(((int)expr) & 3)); 154 return expr; 155} 156 157static inline const void *align_short(const void *expr) 158{ 159 assert(!(((int)expr) & 1)); 160 return expr; 161} 162 163#ifdef STANDALONE 164static 165#endif 166void 167dump_file(const char *fname) 168{ 169 int fd; 170 struct stat sb; 171 caddr_t objbase; 172 173 if (stat(fname, &sb) == -1) { 174 warnx("cannot stat \"%s\"", fname); 175 ++error_count; 176 return; 177 } 178 179 if ((sb.st_mode & S_IFMT) != S_IFREG) { 180 warnx("\"%s\" is not a regular file", fname); 181 ++error_count; 182 return; 183 } 184 185 if ((fd = open(fname, O_RDONLY, 0)) == -1) { 186 warnx("cannot open \"%s\"", fname); 187 ++error_count; 188 return; 189 } 190 191 objbase = mmap(0, sb.st_size, PROT_READ, MAP_SHARED, fd, 0); 192 if (objbase == (caddr_t) -1) { 193 warnx("cannot mmap \"%s\"", fname); 194 ++error_count; 195 close(fd); 196 return; 197 } 198 199 close(fd); 200 201 file_base = (const char *) objbase; /* Makes address arithmetic easier */ 202 203 if (IS_ELF(*(const Elf32_Ehdr*) align_struct(file_base))) { 204 warnx("%s: this is an ELF program; use objdump to examine", fname); 205 ++error_count; 206 munmap(objbase, sb.st_size); 207 close(fd); 208 return; 209 } 210 211 ex = (const struct exec *) align_struct(file_base); 212 213 printf("%s: a_midmag = 0x%lx\n", fname, (long)ex->a_midmag); 214 printf(" magic = 0x%lx = 0%lo, netmagic = 0x%lx = 0%lo\n", 215 (long)N_GETMAGIC(*ex), (long)N_GETMAGIC(*ex), 216 (long)N_GETMAGIC_NET(*ex), (long)N_GETMAGIC_NET(*ex)); 217 218 if (N_BADMAG(*ex)) { 219 warnx("%s: bad magic number", fname); 220 ++error_count; 221 munmap(objbase, sb.st_size); 222 return; 223 } 224 225 printf(" a_text = 0x%lx\n", (long)ex->a_text); 226 printf(" a_data = 0x%lx\n", (long)ex->a_data); 227 printf(" a_bss = 0x%lx\n", (long)ex->a_bss); 228 printf(" a_syms = 0x%lx\n", (long)ex->a_syms); 229 printf(" a_entry = 0x%lx\n", (long)ex->a_entry); 230 printf(" a_trsize = 0x%lx\n", (long)ex->a_trsize); 231 printf(" a_drsize = 0x%lx\n", (long)ex->a_drsize); 232 233 text_base = file_base + N_TXTOFF(*ex); 234 data_base = file_base + N_DATOFF(*ex); 235 rel_base = (const struct relocation_info *) 236 align_struct(file_base + N_RELOFF(*ex)); 237 sym_base = (const struct nlist *) align_struct(file_base + N_SYMOFF(*ex)); 238 str_base = file_base + N_STROFF(*ex); 239 240 rel_count = (ex->a_trsize + ex->a_drsize) / sizeof rel_base[0]; 241 assert(rel_count * sizeof rel_base[0] == ex->a_trsize + ex->a_drsize); 242 sym_count = ex->a_syms / sizeof sym_base[0]; 243 assert(sym_count * sizeof sym_base[0] == ex->a_syms); 244 245 if (sym_count != 0) { 246 sym_used = (unsigned char *) calloc(sym_count, sizeof(unsigned char)); 247 assert(sym_used != NULL); 248 } 249 250 printf(" Entry = 0x%lx\n", (long)ex->a_entry); 251 printf(" Text offset = %x, address = %lx\n", N_TXTOFF(*ex), 252 (long)N_TXTADDR(*ex)); 253 printf(" Data offset = %lx, address = %lx\n", (long)N_DATOFF(*ex), 254 (long)N_DATADDR(*ex)); 255 256 /* 257 * In an executable program file, everything is relocated relative to 258 * the assumed run-time load address, i.e., N_TXTADDR(*ex), i.e., 0x1000. 259 * 260 * In a shared library file, everything is relocated relative to the 261 * start of the file, i.e., N_TXTOFF(*ex), i.e., 0. 262 * 263 * The way to tell the difference is by looking at ex->a_entry. If it 264 * is >= 0x1000, then we have an executable program. Otherwise, we 265 * have a shared library. 266 * 267 * When a program is executed, the entire file is mapped into memory, 268 * including the a.out header and so forth. But it is not mapped at 269 * address 0; rather it is mapped at address 0x1000. The first page 270 * of the user's address space is left unmapped in order to catch null 271 * pointer dereferences. 272 * 273 * In this program, when we map in an executable program, we have to 274 * simulate the empty page by decrementing our assumed base address by 275 * a pagesize. 276 */ 277 278 text_addr = text_base; 279 data_addr = data_base; 280 origin = 0; 281 282 if (ex->a_entry >= PAGE_SIZE) { /* Executable, not a shared library */ 283 /* 284 * The fields in the object have already been relocated on the 285 * assumption that the object will be loaded at N_TXTADDR(*ex). 286 * We have to compensate for that. 287 */ 288 text_addr -= PAGE_SIZE; 289 data_addr -= PAGE_SIZE; 290 origin = PAGE_SIZE; 291 printf(" Program, origin = %lx\n", origin); 292 } else if (N_GETFLAG(*ex) & EX_DYNAMIC) 293 printf(" Shared library, origin = %lx\n", origin); 294 else 295 printf(" Object file, origin = %lx\n", origin); 296 297 if (N_GETFLAG(*ex) & EX_DYNAMIC) { 298 dyn = (const struct _dynamic *) align_struct(data_base); 299 printf(" Dynamic version = %d\n", dyn->d_version); 300 301 sdt = (const struct section_dispatch_table *) 302 align_struct(text_addr + (unsigned long) dyn->d_un.d_sdt); 303 304 rtrel_base = (const struct relocation_info *) 305 align_struct(text_addr + sdt->sdt_rel); 306 rtrel_count = (sdt->sdt_hash - sdt->sdt_rel) / sizeof rtrel_base[0]; 307 assert(rtrel_count * sizeof rtrel_base[0] == 308 (size_t)(sdt->sdt_hash - sdt->sdt_rel)); 309 310 rtsym_base = (const struct nzlist *) 311 align_struct(text_addr + sdt->sdt_nzlist); 312 rtsym_count = (sdt->sdt_strings - sdt->sdt_nzlist) / 313 sizeof rtsym_base[0]; 314 assert(rtsym_count * sizeof rtsym_base[0] == 315 (size_t)(sdt->sdt_strings - sdt->sdt_nzlist)); 316 317 if (rtsym_count != 0) { 318 rtsym_used = (unsigned char *) calloc(rtsym_count, 319 sizeof(unsigned char)); 320 assert(rtsym_used != NULL); 321 } 322 323 rtstr_base = text_addr + sdt->sdt_strings; 324 } 325 326 dump_segs(); 327 dump_sods(); 328 dump_rels("Relocations", rel_base, rel_count, sym_name, sym_used); 329 dump_syms(); 330 331 dump_rels("Run-time relocations", rtrel_base, rtrel_count, rtsym_name, 332 rtsym_used); 333 dump_rtsyms(); 334 335 if (rtsym_used != NULL) { 336 free(rtsym_used); 337 rtsym_used = NULL; 338 } 339 if (sym_used != NULL) { 340 free(sym_used); 341 sym_used = NULL; 342 } 343 munmap(objbase, sb.st_size); 344} 345 346static void 347dump_rels(const char *label, const struct relocation_info *base, 348 unsigned long count, const char *(*name)(unsigned long), 349 unsigned char *sym_used_flags) 350{ 351 unsigned long i; 352 353 printf(" %s:\n", label); 354 for (i = 0; i < count; ++i) { 355 const struct relocation_info *r = &base[i]; 356 unsigned int size; 357 char contents[16]; 358 359 size = 1u << r->r_length; 360 361 if (origin <= (unsigned long)r->r_address 362 && (unsigned long)r->r_address < origin + ex->a_text + ex->a_data 363 && 1 <= size && size <= 4) { 364 /* 365 * XXX - This can cause unaligned accesses. OK for the 366 * i386, not so for other architectures. 367 */ 368 switch (size) { 369 case 1: 370 snprintf(contents, sizeof contents, " [%02x]", 371 *(unsigned const char *)(text_addr + r->r_address)); 372 break; 373 case 2: 374 snprintf(contents, sizeof contents, " [%04x]", 375 *(unsigned const short *) 376 align_short(text_addr + r->r_address)); 377 break; 378 case 4: 379 snprintf(contents, sizeof contents, "[%08lx]", 380 *(unsigned const long *) 381 align_long(text_addr + r->r_address)); 382 break; 383 } 384 } else 385 snprintf(contents, sizeof contents, " "); 386 387 printf(" %6lu %8x/%u %s %c%c%c%c%c%c", i, 388 r->r_address, size, 389 contents, 390 r->r_extern ? 'e' : '-', 391 r->r_jmptable ? 'j' : '-', 392 r->r_relative ? 'r' : '-', 393 r->r_baserel ? 'b' : '-', 394 r->r_pcrel ? 'p' : '-', 395 r->r_copy ? 'c' : '-'); 396 397 if (r->r_extern || r->r_baserel || r->r_jmptable || r->r_copy) { 398 printf(" %4u %s", r->r_symbolnum, name(r->r_symbolnum)); 399 sym_used_flags[r->r_symbolnum] = 1; 400 } 401 402 printf("\n"); 403 } 404} 405 406static void 407dump_rtsyms(void) 408{ 409 unsigned long i; 410 411 printf(" Run-time symbols:\n"); 412 for (i = 0; i < rtsym_count; ++i) { 413 printf(" %6lu%c ", i, rtsym_used[i] ? '*' : ' '); 414 dump_sym(&rtsym_base[i].nlist); 415 printf("/%-5ld %s\n", rtsym_base[i].nz_size, rtsym_name(i)); 416 } 417} 418 419static void 420dump_segs(void) 421{ 422 printf(" Text segment starts at address %lx\n", origin + N_TXTOFF(*ex)); 423 if (N_GETFLAG(*ex) & EX_DYNAMIC) { 424 printf(" rel starts at %lx\n", sdt->sdt_rel); 425 printf(" hash starts at %lx\n", sdt->sdt_hash); 426 printf(" nzlist starts at %lx\n", sdt->sdt_nzlist); 427 printf(" strings starts at %lx\n", sdt->sdt_strings); 428 } 429 430 printf(" Data segment starts at address %lx\n", origin + N_DATOFF(*ex)); 431 if (N_GETFLAG(*ex) & EX_DYNAMIC) { 432 printf(" _dynamic starts at %lx\n", origin + N_DATOFF(*ex)); 433 printf(" so_debug starts at %lx\n", (unsigned long) dyn->d_debug); 434 printf(" sdt starts at %lx\n", (unsigned long) dyn->d_un.d_sdt); 435 printf(" got starts at %lx\n", sdt->sdt_got); 436 printf(" plt starts at %lx\n", sdt->sdt_plt); 437 printf(" rest of stuff starts at %lx\n", 438 sdt->sdt_plt + sdt->sdt_plt_sz); 439 } 440} 441 442static void 443dump_sods(void) 444{ 445 long sod_offset; 446 long paths_offset; 447 448 if (dyn == NULL) /* Not a shared object */ 449 return; 450 451 sod_offset = sdt->sdt_sods; 452 printf(" Shared object dependencies:\n"); 453 while (sod_offset != 0) { 454 const struct sod *sodp = (const struct sod *) align_struct((text_addr + sod_offset)); 455 const char *name = (const char *) (text_addr + sodp->sod_name); 456 457 if (sodp->sod_library) 458 printf(" -l%-16s version %d.%d\n", name, sodp->sod_major, 459 sodp->sod_minor); 460 else 461 printf(" %s\n", name); 462 sod_offset = sodp->sod_next; 463 } 464 paths_offset = sdt->sdt_paths; 465 printf(" Shared object additional paths:\n"); 466 if (paths_offset != 0) { 467 printf(" %s\n", (const char *)(text_addr + paths_offset)); 468 } else { 469 printf(" (none)\n"); 470 } 471} 472 473static void 474dump_sym(const struct nlist *np) 475{ 476 char type[8]; 477 char aux[8]; 478 char weak; 479 char *p; 480 481 switch (np->n_type & ~N_EXT) { 482 case N_UNDF: strcpy(type, "undf"); break; 483 case N_ABS: strcpy(type, "abs"); break; 484 case N_TEXT: strcpy(type, "text"); break; 485 case N_DATA: strcpy(type, "data"); break; 486 case N_BSS: strcpy(type, "bss"); break; 487 case N_INDR: strcpy(type, "indr"); break; 488 case N_SIZE: strcpy(type, "size"); break; 489 case N_COMM: strcpy(type, "comm"); break; 490 case N_SETA: strcpy(type, "seta"); break; 491 case N_SETT: strcpy(type, "sett"); break; 492 case N_SETD: strcpy(type, "setd"); break; 493 case N_SETB: strcpy(type, "setb"); break; 494 case N_SETV: strcpy(type, "setv"); break; 495 case N_FN: strcpy(type, np->n_type&N_EXT ? "fn" : "warn"); break; 496 case N_GSYM: strcpy(type, "gsym"); break; 497 case N_FNAME: strcpy(type, "fname"); break; 498 case N_FUN: strcpy(type, "fun"); break; 499 case N_STSYM: strcpy(type, "stsym"); break; 500 case N_LCSYM: strcpy(type, "lcsym"); break; 501 case N_MAIN: strcpy(type, "main"); break; 502 case N_PC: strcpy(type, "pc"); break; 503 case N_RSYM: strcpy(type, "rsym"); break; 504 case N_SLINE: strcpy(type, "sline"); break; 505 case N_DSLINE: strcpy(type, "dsline"); break; 506 case N_BSLINE: strcpy(type, "bsline"); break; 507 case N_SSYM: strcpy(type, "ssym"); break; 508 case N_SO: strcpy(type, "so"); break; 509 case N_LSYM: strcpy(type, "lsym"); break; 510 case N_BINCL: strcpy(type, "bincl"); break; 511 case N_SOL: strcpy(type, "sol"); break; 512 case N_PSYM: strcpy(type, "psym"); break; 513 case N_EINCL: strcpy(type, "eincl"); break; 514 case N_ENTRY: strcpy(type, "entry"); break; 515 case N_LBRAC: strcpy(type, "lbrac"); break; 516 case N_EXCL: strcpy(type, "excl"); break; 517 case N_RBRAC: strcpy(type, "rbrac"); break; 518 case N_BCOMM: strcpy(type, "bcomm"); break; 519 case N_ECOMM: strcpy(type, "ecomm"); break; 520 case N_ECOML: strcpy(type, "ecoml"); break; 521 case N_LENG: strcpy(type, "leng"); break; 522 default: 523 snprintf(type, sizeof type, "%#02x", np->n_type); 524 break; 525 } 526 527 if (np->n_type & N_EXT && type[0] != '0') 528 for (p = type; *p != '\0'; ++p) 529 *p = toupper(*p); 530 531 switch (N_AUX(np)) { 532 case 0: strcpy(aux, ""); break; 533 case AUX_OBJECT: strcpy(aux, "objt"); break; 534 case AUX_FUNC: strcpy(aux, "func"); break; 535 default: snprintf(aux, sizeof aux, "%#01x", N_AUX(np)); break; 536 } 537 538 weak = N_BIND(np) == BIND_WEAK ? 'w' : ' '; 539 540 printf("%c%-6s %-4s %8lx", weak, type, aux, np->n_value); 541} 542 543static void 544dump_syms(void) 545{ 546 unsigned long i; 547 548 printf(" Symbols:\n"); 549 for (i = 0; i < sym_count; ++i) { 550 printf(" %6lu%c ", i, sym_used[i] ? '*' : ' '); 551 dump_sym(&sym_base[i]); 552 printf(" %s\n", sym_name(i)); 553 } 554} 555 556static const char * 557rtsym_name(unsigned long n) 558{ 559 assert(n < rtsym_count); 560 if (rtsym_base[n].nz_strx == 0) 561 return ""; 562 return rtstr_base + rtsym_base[n].nz_strx; 563} 564 565static const char * 566sym_name(unsigned long n) 567{ 568 assert(n < sym_count); 569 if (sym_base[n].n_un.n_strx == 0) 570 return ""; 571 return str_base + sym_base[n].n_un.n_strx; 572} 573