Print this page
Cstyle cleanup
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/sgs/dump/common/dump.c
+++ new/usr/src/cmd/sgs/dump/common/dump.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 1988 AT&T
24 24 * All Rights Reserved
25 25 *
26 26 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
27 + * Copyright 2018, Joyent, Inc.
27 28 */
28 29
29 30 /* Get definitions for the relocation types supported. */
30 31 #define ELF_TARGET_ALL
31 32
32 33 #include <stdio.h>
33 34 #include <stdlib.h>
34 35 #include <locale.h>
35 36 #include <unistd.h>
36 37 #include <libelf.h>
37 38 #include <sys/link.h>
38 39 #include <sys/elf.h>
39 40 #include <sys/machelf.h>
40 41 #include <fcntl.h>
41 42 #include <sys/stat.h>
42 43 #include <errno.h>
43 44 #include <string.h>
44 45 #include "sgs.h"
45 46 #include "conv.h"
46 47 #include "dump.h"
47 48
48 49
49 50 #define OPTSTR "agcd:fhn:oprstvCLT:V?" /* option string for getopt() */
50 51
51 52 const char *UNKNOWN = "<unknown>";
52 53
53 54 static SCNTAB *p_symtab, *p_head_scns, *p_dynsym;
54 55
55 56 static int
56 57 x_flag = 0, /* option requires section header table */
57 58 z_flag = 0, /* process files within an archive */
58 59 rn_flag = 0; /* dump named relocation information */
59 60
60 61 static int
61 62 /* flags: ?_flag corresponds to ? option */
62 63 a_flag = 0, /* dump archive header of each member of archive */
63 64 g_flag = 0, /* dump archive symbol table */
64 65 c_flag = 0, /* dump the string table */
65 66 d_flag = 0, /* dump range of sections */
66 67 f_flag = 0, /* dump each file header */
67 68 h_flag = 0, /* dump section headers */
68 69 n_flag = 0, /* dump named section */
69 70 o_flag = 0, /* dump each program execution header */
70 71 r_flag = 0, /* dump relocation information */
71 72 s_flag = 0, /* dump section contents */
72 73 t_flag = 0, /* dump symbol table entries */
73 74 C_flag = 0, /* dump decoded C++ symbol names */
74 75 L_flag = 0, /* dump dynamic linking information */
75 76 T_flag = 0, /* dump symbol table range */
76 77 V_flag = 0; /* dump version information */
77 78
78 79 int p_flag = 0, /* suppress printing of headings */
79 80 v_flag = 0; /* print information in verbose form */
80 81
81 82 static int
82 83 d_low = 0, /* range for use with -d */
83 84 d_hi = 0,
84 85 d_num = 0;
85 86
86 87 static int
87 88 T_low = 0, /* range for use with -T */
88 89 T_hi = 0,
89 90 T_num = 0;
90 91
91 92 static char *name = NULL; /* for use with -n option */
92 93 char *prog_name;
93 94 static int errflag = 0;
94 95
95 96 static struct stab_list_s {
96 97 struct stab_list_s *next;
97 98 char *strings;
98 99 size_t size;
99 100 } *StringTableList = (void *)0;
100 101
101 102 extern void ar_sym_read();
102 103 extern void dump_exec_header();
103 104
104 105
105 106 /*
106 107 * Get the section descriptor and set the size of the
107 108 * data returned. Data is byte-order converted.
108 109 */
109 110 void *
110 111 get_scndata(Elf_Scn *fd_scn, size_t *size)
111 112 {
112 113 Elf_Data *p_data;
113 114
114 115 p_data = 0;
115 116 if ((p_data = elf_getdata(fd_scn, p_data)) == 0 ||
116 117 p_data->d_size == 0) {
117 118 return (NULL);
118 119 }
119 120 *size = p_data->d_size;
120 121 return (p_data->d_buf);
121 122 }
122 123
123 124 /*
124 125 * Get the section descriptor and set the size of the
125 126 * data returned. Data is raw (i.e., not byte-order converted).
126 127 */
127 128 static void *
128 129 get_rawscn(Elf_Scn *fd_scn, size_t *size)
129 130 {
130 131 Elf_Data *p_data;
131 132
132 133 p_data = 0;
133 134 if ((p_data = elf_rawdata(fd_scn, p_data)) == 0 ||
134 135 p_data->d_size == 0) {
135 136 return (NULL);
136 137 }
137 138
138 139 *size = p_data->d_size;
139 140 return (p_data->d_buf);
140 141 }
141 142
142 143 /*
143 144 * Print out a usage message in short form when program is invoked
144 145 * with insufficient or no arguments, and in long form when given
145 146 * either a ? or an invalid option.
146 147 */
147 148 static void
148 149 usage()
149 150 {
150 151 (void) fprintf(stderr,
151 152 "Usage: %s [-%s] file(s) ...\n", prog_name, OPTSTR);
152 153 if (errflag) {
153 154 (void) fprintf(stderr,
154 155 "\t\t[-a dump archive header of each member of archive]\n\
155 156 [-g dump archive global symbol table]\n\
156 157 [-c dump the string table]\n\
157 158 [-d dump range of sections]\n\
158 159 [-f dump each file header]\n\
159 160 [-h dump section headers]\n\
160 161 [-n dump named section]\n\
161 162 [-o dump each program execution header]\n\
162 163 [-p suppress printing of headings]\n\
163 164 [-r dump relocation information]\n\
164 165 [-s dump section contents]\n\
165 166 [-t dump symbol table entries]\n\
166 167 [-v print information in verbose form]\n\
167 168 [-C dump decoded C++ symbol names]\n\
168 169 [-L dump the .dynamic structure]\n\
169 170 [-T dump symbol table range]\n\
170 171 [-V dump version information]\n");
171 172 }
172 173 }
173 174
174 175 /*
175 176 * Set a range. Input is a character string, a lower
176 177 * bound and an upper bound. This function converts
177 178 * a character string into its correct integer values,
178 179 * setting the first value as the lower bound, and
179 180 * the second value as the upper bound. If more values
180 181 * are given they are ignored with a warning.
181 182 */
182 183 static void
183 184 set_range(char *s, int *low, int *high)
184 185 {
185 186 char *w;
186 187 char *lasts;
187 188
188 189 while ((w = strtok_r(s, ",", &lasts)) != NULL) {
189 190 if (!(*low))
190 191 /* LINTED */
191 192 *low = (int)atol(w);
192 193 else
193 194 if (!(*high))
194 195 /* LINTED */
195 196 *high = (int)atol(w);
196 197 else {
197 198 (void) fprintf(stderr,
198 199 "%s: too many arguments - %s ignored\n",
199 200 prog_name, w);
200 201 return;
201 202 }
202 203 s = NULL;
203 204 } /* end while */
204 205 }
205 206
206 207
207 208 /*
208 209 * Print static shared library information.
209 210 */
210 211 static void
211 212 print_static(SCNTAB *l_scns, char *filename)
212 213 {
213 214 size_t section_size;
214 215 unsigned char *strtab;
215 216 unsigned char *path, buf[1024];
216 217 unsigned long *temp;
217 218 unsigned long total, topath;
218 219
219 220 (void) printf("\n **** STATIC SHARED LIBRARY INFORMATION ****\n");
220 221 (void) printf("\n%s:\n", filename);
221 222 (void) printf("\t");
222 223 section_size = 0;
223 224 if ((strtab = (unsigned char *)
224 225 get_scndata(l_scns->p_sd, §ion_size)) == NULL) {
225 226 return;
226 227 }
227 228
228 229 while (section_size != 0) {
229 230 /* LINTED */
230 231 temp = (unsigned long *)strtab;
231 232 total = temp[0];
232 233 topath = temp[1];
233 234 path = strtab + (topath*sizeof (long));
234 235 (void) strncpy((char *)buf, (char *)path,
235 236 (total - topath)*sizeof (long));
236 237 (void) fprintf(stdout, "%s\n", buf);
237 238 strtab += total*sizeof (long);
238 239 section_size -= (total*sizeof (long));
239 240 }
240 241 }
241 242
242 243 /*
243 244 * Print raw data in hexidecimal. Input is the section data to
244 245 * be printed out and the size of the data. Output is relative
245 246 * to a table lookup in dumpmap.h.
246 247 */
247 248 static void
248 249 print_rawdata(unsigned char *p_sec, size_t size)
249 250 {
250 251 size_t j;
251 252 size_t count;
252 253
253 254 count = 1;
254 255
255 256 (void) printf("\t");
256 257 for (j = size/sizeof (short); j != 0; --j, ++count) {
257 258 (void) printf("%.2x %.2x ", p_sec[0], p_sec[1]);
258 259 p_sec += 2;
259 260 if (count == 12) {
260 261 (void) printf("\n\t");
261 262 count = 0;
262 263 }
263 264 }
264 265
265 266 /*
266 267 * take care of last byte if odd byte section
267 268 */
268 269 if ((size & 0x1L) == 1L)
269 270 (void) printf("%.2x", *p_sec);
270 271 (void) printf("\n");
271 272 }
272 273
273 274
274 275
275 276 /*
276 277 * Print relocation data of type SHT_RELA
277 278 * If d_flag, print data corresponding only to
278 279 * the section or range of sections specified.
279 280 * If n_flag, print data corresponding only to
280 281 * the named section.
281 282 */
282 283 static void
283 284 print_rela(Elf *elf_file, SCNTAB *p_scns, Elf_Data *rdata, Elf_Data *sym_data,
284 285 GElf_Ehdr * p_ehdr, size_t reloc_size, size_t sym_size, char *filename,
285 286 SCNTAB *reloc_symtab)
286 287 {
287 288 GElf_Rela rela;
288 289 GElf_Sym sym;
289 290 size_t no_entries;
290 291 size_t rel_entsize;
291 292 size_t no_syms;
292 293 int type, symid;
293 294 static int n_title = 0;
294 295 int ndx = 0;
295 296 char *sym_name;
296 297 int adj = 0;
297 298
298 299 if (gelf_getclass(elf_file) == ELFCLASS64)
299 300 adj = 8;
300 301
301 302 rel_entsize = p_scns->p_shdr.sh_entsize;
302 303 if ((rel_entsize == 0) ||
303 304 (rel_entsize > p_scns->p_shdr.sh_size)) {
304 305 rel_entsize = gelf_fsize(elf_file, ELF_T_RELA, 1,
305 306 EV_CURRENT);
306 307 }
307 308 no_entries = reloc_size / rel_entsize;
308 309
309 310 no_syms = sym_size / gelf_fsize(elf_file, ELF_T_SYM, 1, EV_CURRENT);
310 311 while (no_entries--) {
311 312 (void) gelf_getrela(rdata, ndx, &rela);
312 313 /* LINTED */
313 314 type = (int)GELF_R_TYPE(rela.r_info);
314 315 /* LINTED */
315 316 symid = (int)GELF_R_SYM(rela.r_info);
316 317 /* LINTED */
317 318 if ((symid > (no_syms - 1)) || (symid < 0)) {
318 319 (void) fprintf(stderr, "%s: %s: invalid symbol table "
319 320 "offset - %d - in %s\n", prog_name, filename,
320 321 symid, p_scns->scn_name);
321 322 ndx++;
322 323 continue;
323 324 }
324 325 (void) gelf_getsym(sym_data, symid, &sym);
325 326 sym_name = (char *)elf_strptr(elf_file,
326 327 reloc_symtab->p_shdr.sh_link, sym.st_name);
327 328 if (sym_name == NULL)
328 329 sym_name = (char *)UNKNOWN;
329 330 if (r_flag && rn_flag) {
330 331 if (strcmp(name, p_scns->scn_name) != 0) {
331 332 ndx++;
332 333 continue;
333 334 }
334 335 if (!n_title) {
335 336 (void) printf("\n%s:\n", p_scns->scn_name);
336 337 (void) printf("%-*s%-*s%-*s%s\n\n",
337 338 12 + adj, "Offset", 22, "Symndx",
338 339 16, "Type", "Addend");
339 340 n_title = 1;
340 341 }
341 342 }
342 343 if (d_flag) {
343 344 if (!d_hi)
344 345 d_hi = d_low;
345 346 if ((symid < d_low) || (symid > d_hi)) {
346 347 ndx++;
347 348 continue;
348 349 }
349 350 }
350 351
351 352 (void) printf("%-#*llx", 12 + adj, EC_XWORD(rela.r_offset));
352 353 if (!v_flag) {
353 354 (void) printf("%-22d%-18d", symid, type);
354 355 } else {
355 356 Conv_inv_buf_t inv_buf;
356 357
357 358 if (strlen(sym_name)) {
358 359 size_t len = strlen(sym_name) + 1;
359 360 char tmpstr[10];
360 361 if (len > 22) {
361 362 (void) sprintf(tmpstr, "%%-%ds",
362 363 /* LINTED */
363 364 (int)len);
364 365 /*LINTED: E_SEC_PRINTF_VAR_FMT*/
365 366 (void) printf(tmpstr, sym_name);
366 367 } else
367 368 (void) printf("%-22s", sym_name);
368 369 } else {
369 370 (void) printf("%-22d", symid);
370 371 }
371 372 (void) printf("%-20s",
372 373 conv_reloc_type(p_ehdr->e_machine,
373 374 type, DUMP_CONVFMT, &inv_buf));
374 375 }
375 376 (void) printf("%lld\n", EC_SXWORD(rela.r_addend));
376 377 ndx++;
377 378 }
378 379 }
379 380
380 381 /*
381 382 * Print relocation data of type SHT_REL.
382 383 * If d_flag, print data corresponding only to
383 384 * the section or range of sections specified.
384 385 * If n_flag, print data corresponding only to
385 386 * the named section.
386 387 */
387 388 static void
388 389 print_rel(Elf *elf_file, SCNTAB *p_scns, Elf_Data *rdata, Elf_Data *sym_data,
389 390 GElf_Ehdr *p_ehdr, size_t reloc_size, size_t sym_size, char *filename,
390 391 SCNTAB *reloc_symtab)
391 392 {
392 393 GElf_Rel rel;
393 394 GElf_Sym sym;
394 395 size_t no_entries;
395 396 size_t rel_entsize;
396 397 int type, symid;
397 398 size_t no_syms;
398 399 static int n_title = 0;
399 400 int ndx = 0;
400 401 char *sym_name;
401 402 int adj = 0;
402 403
403 404 if (gelf_getclass(elf_file) == ELFCLASS64)
404 405 adj = 8;
405 406
406 407 rel_entsize = p_scns->p_shdr.sh_entsize;
407 408 if ((rel_entsize == 0) ||
408 409 (rel_entsize > p_scns->p_shdr.sh_size)) {
409 410 rel_entsize = gelf_fsize(elf_file, ELF_T_REL, 1,
410 411 EV_CURRENT);
411 412 }
412 413 no_entries = reloc_size / rel_entsize;
413 414
414 415 no_syms = sym_size / gelf_fsize(elf_file, ELF_T_SYM, 1, EV_CURRENT);
415 416 while (no_entries--) {
416 417 (void) gelf_getrel(rdata, ndx, &rel);
417 418 /* LINTED */
418 419 type = (int)GELF_R_TYPE(rel.r_info);
419 420 /* LINTED */
420 421 symid = (int)GELF_R_SYM(rel.r_info);
421 422 /* LINTED */
422 423 if ((symid > (no_syms - 1)) || (symid < 0)) {
423 424 (void) fprintf(stderr, "%s: %s: invalid symbol table "
424 425 "offset - %d - in %s\n", prog_name, filename,
425 426 symid, p_scns->scn_name);
426 427 ndx++;
427 428 continue;
428 429 }
429 430 (void) gelf_getsym(sym_data, symid, &sym);
430 431 sym_name = (char *)elf_strptr(elf_file,
431 432 reloc_symtab->p_shdr.sh_link, sym.st_name);
432 433 if (sym_name == NULL)
433 434 sym_name = (char *)UNKNOWN;
434 435 if (r_flag && rn_flag) {
435 436 if (strcmp(name, p_scns->scn_name) != 0) {
436 437 ndx++;
437 438 continue;
438 439 }
439 440 if (!n_title) {
440 441 (void) printf("\n%s:\n", p_scns->scn_name);
441 442 (void) printf("%-*s%-*s%s\n\n",
442 443 12 + adj, "Offset", 20, "Symndx", "Type");
443 444 n_title = 1;
444 445 }
445 446 }
446 447 if (d_flag) {
447 448 if (!d_hi)
448 449 d_hi = d_low;
449 450 if ((symid < d_low) || (symid > d_hi)) {
450 451 ndx++;
451 452 continue;
452 453 }
453 454 }
454 455
455 456 (void) printf("%-#*llx", 12 + adj, EC_ADDR(rel.r_offset));
456 457 if (!v_flag) {
457 458 (void) printf("%-20d%-18d", symid, type);
458 459 } else {
459 460 Conv_inv_buf_t inv_buf;
460 461
461 462 if (strlen(sym_name))
462 463 (void) printf("%-20s", sym_name);
463 464 else {
464 465 (void) printf("%-20d", sym.st_name);
465 466 }
466 467 (void) printf("%-20s",
467 468 conv_reloc_type(p_ehdr->e_machine,
468 469 type, DUMP_CONVFMT, &inv_buf));
469 470 }
470 471 (void) printf("\n");
471 472 ndx++;
472 473 }
473 474 }
474 475
475 476 /* demangle C++ names */
476 477 static char *
477 478 demangled_name(char *s)
478 479 {
479 480 static char *buf = NULL;
480 481 size_t buflen = 0;
481 482 char *dn;
482 483 size_t len;
483 484
484 485 dn = (char *)conv_demangle_name(s);
485 486
486 487 /*
487 488 * If not demangled, just return the symbol name
488 489 */
489 490 if (dn == s)
490 491 return (s);
491 492
492 493 len = strlen(dn) + strlen(s) + 4;
493 494
494 495 if (buflen < len) {
495 496 free(buf);
496 497 if ((buf = malloc(len)) == NULL)
497 498 return (s);
498 499 buflen = len;
499 500 }
500 501
501 502 /*
502 503 * Demangled. Format it
503 504 */
504 505 (void) snprintf(buf, buflen, "%s\t[%s]", dn, s);
505 506 free(dn);
506 507 return (buf);
507 508 }
508 509
509 510 /*
510 511 * Print the symbol table. Input is an ELF file descriptor, a
511 512 * pointer to the symbol table SCNTAB structure,
512 513 * the number of symbols, a range of symbols to print,
513 514 * an index which is the number of the
514 515 * section in the file, and the filename. The number of sections,
515 516 * the range, and the index are set in
516 517 * dump_symbol_table, depending on whether -n or -T were set.
517 518 */
518 519 static void
519 520 print_symtab(Elf *elf_file, SCNTAB *p_symtab, Elf_Data *sym_data,
520 521 long range, int index)
521 522 {
522 523 GElf_Sym sym;
523 524 int adj = 0; /* field adjustment for elf64 */
524 525 Elf32_Word *symshndx = 0;
525 526 unsigned int nosymshndx = 0;
526 527 Conv_inv_buf_t inv_buf;
527 528
528 529
529 530 if (gelf_getclass(elf_file) == ELFCLASS64)
530 531 adj = 8;
531 532
532 533 while (range > 0) {
533 534 char *sym_name = NULL;
534 535 int type, bind;
535 536 int specsec;
536 537 unsigned int shndx;
537 538
538 539 (void) gelf_getsym(sym_data, index, &sym);
539 540 type = (int)GELF_ST_TYPE(sym.st_info);
540 541 bind = (int)GELF_ST_BIND(sym.st_info);
541 542
542 543 if ((sym.st_shndx == SHN_XINDEX) &&
543 544 (symshndx == 0) && (nosymshndx == 0)) {
544 545 Elf_Scn *_scn;
545 546 GElf_Shdr _shdr;
546 547 size_t symscnndx;
547 548
548 549 symscnndx = elf_ndxscn(p_symtab->p_sd);
549 550 _scn = 0;
550 551 while ((_scn = elf_nextscn(elf_file, _scn)) != 0) {
551 552 if (gelf_getshdr(_scn, &_shdr) == 0)
552 553 break;
553 554 if ((_shdr.sh_type == SHT_SYMTAB_SHNDX) &&
554 555 /* LINTED */
555 556 (_shdr.sh_link == (GElf_Word)symscnndx)) {
556 557 Elf_Data *_data;
557 558
558 559 if ((_data = elf_getdata(_scn, 0)) == 0)
559 560 continue;
560 561
561 562 symshndx = (Elf32_Word *)_data->d_buf;
562 563 nosymshndx = 0;
563 564 break;
564 565 }
565 566 }
566 567 nosymshndx = 1;
567 568 }
568 569
569 570 if ((symshndx) && (sym.st_shndx == SHN_XINDEX)) {
570 571 shndx = symshndx[index];
571 572 specsec = 0;
572 573 } else {
573 574 shndx = sym.st_shndx;
574 575 if ((sym.st_shndx == SHN_UNDEF) ||
575 576 (sym.st_shndx >= SHN_LORESERVE))
576 577 specsec = 1;
577 578 else
578 579 specsec = 0;
579 580 }
580 581
581 582
582 583 (void) printf("[%d]\t ", index++);
583 584
584 585 if (v_flag && (type == STT_SPARC_REGISTER)) {
585 586 /*
586 587 * The strings "REG_G1" through "REG_G7" are intended
587 588 * to be consistent with output from elfdump(1).
588 589 */
589 590 (void) printf("%-*s", 12 + adj,
590 591 conv_sym_SPARC_value(sym.st_value,
591 592 DUMP_CONVFMT, &inv_buf));
592 593 } else {
593 594 (void) printf("0x%-*llx", 10 + adj,
594 595 EC_ADDR(sym.st_value));
595 596 }
596 597
597 598 (void) printf("%-*lld", 9 + adj, EC_XWORD(sym.st_size));
598 599
599 600 if (!v_flag) {
600 601 (void) printf("%d\t\t%d\t%d\t%#x\t",
601 602 type, bind, (int)sym.st_other, (int)shndx);
602 603 } else {
603 604 GElf_Ehdr p_ehdr;
604 605 (void) gelf_getehdr(elf_file, &p_ehdr);
605 606 (void) printf("%s\t",
606 607 conv_sym_info_type(p_ehdr.e_machine, type,
607 608 DUMP_CONVFMT, &inv_buf));
608 609 (void) printf("%s",
609 610 conv_sym_info_bind(bind, DUMP_CONVFMT, &inv_buf));
610 611 (void) printf("\t %d\t", EC_WORD(sym.st_other));
611 612
612 613 if (specsec)
613 614 (void) printf("%s",
614 615 conv_sym_shndx(p_ehdr.e_ident[EI_OSABI],
615 616 p_ehdr.e_machine, shndx,
616 617 CONV_FMT_DECIMAL, &inv_buf));
617 618 else
618 619 (void) printf("%d", EC_WORD(shndx));
619 620 (void) printf("\t");
620 621 }
621 622
622 623 /* support machines where NULL-deref causes core dump */
623 624 if (sym.st_name == 0)
624 625 sym_name = (char *)UNKNOWN;
625 626 else
626 627 if (C_flag)
627 628 sym_name = demangled_name(
628 629 (char *)elf_strptr(elf_file,
629 630 p_symtab->p_shdr.sh_link,
630 631 sym.st_name));
631 632 else
632 633 sym_name = (char *)elf_strptr(elf_file,
633 634 p_symtab->p_shdr.sh_link, sym.st_name);
634 635 if (sym_name == NULL)
635 636 sym_name = (char *)UNKNOWN;
636 637 (void) printf("%s\n", sym_name);
637 638
638 639 range--;
639 640 } /* end while */
640 641 }
641 642
642 643 /*
643 644 * Print the section header table. Input is the SCNTAB structure,
644 645 * the number of sections, an index which is the number of the
645 646 * section in the file, and the filename. The values of the SCNTAB
646 647 * structure, the number of sections, and the index are set in
647 648 * dump_shdr depending on whether the -n or -d modifiers were set.
648 649 */
649 650 static void
650 651 print_shdr(Elf *elf_file, SCNTAB *s, int num_scns, int index)
651 652 {
652 653 SCNTAB *p;
653 654 int num;
654 655 int field;
655 656 GElf_Ehdr p_ehdr;
656 657
657 658 if (gelf_getclass(elf_file) == ELFCLASS64)
658 659 field = 21;
659 660 else
660 661 field = 13;
661 662
662 663 p = s;
663 664 (void) gelf_getehdr(elf_file, &p_ehdr);
664 665
665 666 for (num = 0; num < num_scns; num++, p++) {
666 667 (void) printf("[%d]\t", index++);
667 668 if (!v_flag) {
668 669 (void) printf("%u\t%llu\t",
669 670 EC_WORD(p->p_shdr.sh_type),
670 671 EC_XWORD(p->p_shdr.sh_flags));
671 672 } else {
672 673 Conv_inv_buf_t inv_buf;
673 674
674 675 /*LINTED: E_SEC_PRINTF_VAR_FMT*/
675 676 (void) printf(conv_sec_type(
676 677 p_ehdr.e_ident[EI_OSABI], p_ehdr.e_machine,
677 678 p->p_shdr.sh_type, DUMP_CONVFMT, &inv_buf));
678 679 (void) printf(" ");
679 680
680 681 if (p->p_shdr.sh_flags & SHF_WRITE)
681 682 (void) printf("W");
682 683 else
683 684 (void) printf("-");
684 685 if (p->p_shdr.sh_flags & SHF_ALLOC)
685 686 (void) printf("A");
686 687 else
687 688 (void) printf("-");
688 689 if (p->p_shdr.sh_flags & SHF_EXECINSTR)
689 690 (void) printf("I");
690 691 else
691 692 (void) printf("-");
692 693
693 694 if (p->p_shdr.sh_flags & SHF_ORDERED)
694 695 (void) printf("O");
695 696 if (p->p_shdr.sh_flags & SHF_EXCLUDE)
696 697 (void) printf("E");
697 698
698 699 (void) printf("\t");
699 700
700 701 }
701 702 (void) printf("%-#*llx%-#*llx%-#*llx%s%s\n",
702 703 field, EC_ADDR(p->p_shdr.sh_addr),
703 704 field, EC_OFF(p->p_shdr.sh_offset),
704 705 field, EC_XWORD(p->p_shdr.sh_size),
705 706 /* compatibility: tab for elf32 */
706 707 (field == 13) ? "\t" : " ", p->scn_name);
707 708
708 709 (void) printf("\t%u\t%u\t%-#*llx%-#*llx\n\n",
709 710 EC_WORD(p->p_shdr.sh_link),
710 711 EC_WORD(p->p_shdr.sh_info),
711 712 field, EC_XWORD(p->p_shdr.sh_addralign),
712 713 field, EC_XWORD(p->p_shdr.sh_entsize));
713 714 }
714 715 }
715 716
716 717 /*
717 718 * Check that a range of numbers is valid. Input is
718 719 * a lower bound, an upper bound, a boundary condition,
719 720 * and the filename. Negative numbers and numbers greater
720 721 * than the bound are invalid. low must be smaller than hi.
721 722 * The returned integer is the number of items in the
722 723 * range if it is valid and -1 otherwise.
723 724 */
724 725 static int
725 726 check_range(int low, int hi, size_t bound, char *filename)
726 727 {
727 728 if (((size_t)low > bound) || (low <= 0)) {
728 729 (void) fprintf(stderr,
729 730 "%s: %s: number out of range, %d\n",
730 731 prog_name, filename, low);
731 732 return (-1);
732 733 }
733 734 if (((size_t)hi > bound) || (hi < 0)) {
734 735 (void) fprintf(stderr,
735 736 "%s: %s: number out of range, %d\n",
736 737 prog_name, filename, hi);
737 738 return (-1);
738 739 }
739 740
740 741 if (hi && (low > hi)) {
741 742 (void) fprintf(stderr,
742 743 "%s: %s: invalid range, %d,%d\n",
743 744 prog_name, filename, low, hi);
744 745 return (-1);
745 746 }
746 747 if (hi)
747 748 return (hi - low + 1);
748 749 else
749 750 return (1);
750 751 }
751 752
752 753 /*
753 754 * Print relocation information. Since this information is
754 755 * machine dependent, new sections must be added for each machine
755 756 * that is supported. Input is an ELF file descriptor, the ELF header,
756 757 * the SCNTAB structure, the number of sections, and a filename.
757 758 * Set up necessary information to print relocation information
758 759 * and call the appropriate print function depending on the
759 760 * type of relocation information. If the symbol table is
760 761 * absent, no relocation data is processed. Input is an
761 762 * ELF file descriptor, the ELF header, the SCNTAB structure,
762 763 * and the filename. Set range of d_flag and name if n_flag.
763 764 */
764 765 static void
765 766 dump_reloc_table(Elf *elf_file, GElf_Ehdr *p_ehdr,
766 767 SCNTAB *p_scns, int num_scns, char *filename)
767 768 {
768 769 Elf_Data *rel_data;
769 770 Elf_Data *sym_data;
770 771 size_t sym_size;
771 772 size_t reloc_size;
772 773 SCNTAB *reloc_symtab;
773 774 SCNTAB *head_scns;
774 775 int r_title = 0;
775 776 int adj = 0;
776 777 size_t shnum;
777 778
778 779 if (gelf_getclass(elf_file) == ELFCLASS64)
779 780 adj = 8;
780 781
781 782 if ((!p_flag) && (!r_title)) {
782 783 (void) printf("\n **** RELOCATION INFORMATION ****\n");
783 784 r_title = 1;
784 785 }
785 786
786 787 while (num_scns-- > 0) {
787 788 if ((p_scns->p_shdr.sh_type != SHT_RELA) &&
788 789 (p_scns->p_shdr.sh_type != SHT_REL)) {
789 790 p_scns++;
790 791 continue;
791 792 }
792 793
793 794 head_scns = p_head_scns;
794 795
795 796 if (elf_getshdrnum(elf_file, &shnum) == -1) {
796 797 (void) fprintf(stderr,
797 798 "%s: %s: elf_getshdrnum failed: %s\n",
798 799 prog_name, filename, elf_errmsg(-1));
799 800 return;
800 801 }
801 802
802 803 if ((p_scns->p_shdr.sh_link == 0) ||
803 804 /* LINTED */
804 805 (p_scns->p_shdr.sh_link >= (GElf_Word)shnum)) {
805 806 (void) fprintf(stderr, "%s: %s: invalid sh_link field: "
806 807 "section #: %d sh_link: %d\n",
807 808 /* LINTED */
808 809 prog_name, filename, (int)elf_ndxscn(p_scns->p_sd),
809 810 (int)p_scns->p_shdr.sh_link);
810 811 return;
811 812 }
812 813 head_scns += (p_scns->p_shdr.sh_link -1);
813 814
814 815 if (head_scns->p_shdr.sh_type == SHT_SYMTAB) {
815 816 reloc_symtab = p_symtab;
816 817 } else if (head_scns->p_shdr.sh_type == SHT_DYNSYM) {
817 818 reloc_symtab = p_dynsym;
818 819 } else {
819 820 (void) fprintf(stderr,
820 821 "%s: %s: could not get symbol table\n", prog_name, filename);
821 822 return;
822 823 }
823 824
824 825 sym_data = NULL;
825 826 sym_size = 0;
826 827 reloc_size = 0;
827 828
828 829 if ((sym_data = elf_getdata(reloc_symtab->p_sd, NULL)) == NULL) {
829 830 (void) fprintf(stderr,
830 831 "%s: %s: no symbol table data\n", prog_name, filename);
831 832 return;
832 833 }
833 834 sym_size = sym_data->d_size;
834 835
835 836 if (p_scns == NULL) {
836 837 (void) fprintf(stderr,
837 838 "%s: %s: no section table data\n", prog_name, filename);
838 839 return;
839 840 }
840 841
841 842 if (p_scns->p_shdr.sh_type == SHT_RELA) {
842 843 if (!n_flag && r_flag)
843 844 (void) printf("\n%s:\n", p_scns->scn_name);
844 845 if (!p_flag && (!n_flag && r_flag))
845 846 (void) printf("%-*s%-*s%-*s%s\n\n",
846 847 12 + adj, "Offset", 22, "Symndx",
847 848 18, "Type", "Addend");
848 849 if ((rel_data = elf_getdata(p_scns->p_sd, NULL)) == NULL) {
849 850 (void) fprintf(stderr,
850 851 "%s: %s: no relocation information\n", prog_name, filename);
851 852 return;
852 853 }
853 854 reloc_size = rel_data->d_size;
854 855
855 856 if (n_flag) {
856 857 rn_flag = 1;
857 858 print_rela(elf_file, p_scns, rel_data, sym_data, p_ehdr,
858 859 reloc_size, sym_size, filename, reloc_symtab);
859 860 }
860 861 if (d_flag) {
861 862 rn_flag = 0;
862 863 print_rela(elf_file, p_scns, rel_data, sym_data, p_ehdr,
863 864 reloc_size, sym_size, filename, reloc_symtab);
864 865 }
865 866 if (!n_flag && !d_flag)
866 867 print_rela(elf_file, p_scns, rel_data, sym_data, p_ehdr,
867 868 reloc_size, sym_size, filename, reloc_symtab);
868 869 } else {
869 870 if (p_scns->p_shdr.sh_type == SHT_REL) {
870 871 if (!n_flag && r_flag)
871 872 (void) printf("\n%s:\n", p_scns->scn_name);
872 873 if (!p_flag && (!n_flag && r_flag)) {
873 874 (void) printf("%-*s%-*s%s\n\n",
874 875 12 + adj, "Offset", 20, "Symndx", "Type");
875 876 }
876 877 if ((rel_data = elf_getdata(p_scns->p_sd, NULL))
877 878 == NULL) {
878 879 (void) fprintf(stderr,
879 880 "%s: %s: no relocation information\n", prog_name, filename);
880 881 return;
881 882 }
882 883 reloc_size = rel_data->d_size;
883 884 if (n_flag) {
884 885 rn_flag = 1;
885 886 print_rel(elf_file, p_scns, rel_data, sym_data,
886 887 p_ehdr, reloc_size, sym_size,
887 888 filename, reloc_symtab);
888 889 }
889 890 if (d_flag) {
890 891 rn_flag = 0;
891 892 print_rel(elf_file, p_scns, rel_data, sym_data,
892 893 p_ehdr, reloc_size, sym_size,
893 894 filename, reloc_symtab);
894 895 }
895 896 if (!n_flag && !d_flag)
896 897 print_rel(elf_file, p_scns, rel_data, sym_data,
897 898 p_ehdr, reloc_size, sym_size,
898 899 filename, reloc_symtab);
899 900 }
900 901 }
901 902 p_scns++;
902 903 }
903 904 }
904 905
905 906 /*
906 907 * Print out the string tables. Input is an opened ELF file,
907 908 * the SCNTAB structure, the number of sections, and the filename.
908 909 * Since there can be more than one string table, all sections are
909 910 * examined and any with the correct type are printed out.
910 911 */
911 912 static void
912 913 dump_string_table(SCNTAB *s, int num_scns)
913 914 {
914 915 size_t section_size;
915 916 unsigned char *strtab;
916 917 int beg_of_string;
917 918 int counter = 0;
918 919 int str_off;
919 920 int i;
920 921
921 922 if (!p_flag) {
922 923 (void) printf("\n **** STRING TABLE INFORMATION ****\n");
923 924 }
924 925
925 926 for (i = 0; i < num_scns; i++, s++) {
926 927 if (s->p_shdr.sh_type != SHT_STRTAB)
927 928 continue;
928 929
929 930 str_off = 0;
930 931
931 932 if (!p_flag) {
932 933 (void) printf("\n%s:\n", s->scn_name);
933 934 (void) printf(" <offset> \tName\n");
934 935 }
935 936 section_size = 0;
936 937 if ((strtab = (unsigned char *)
937 938 get_scndata(s->p_sd, §ion_size)) == NULL) {
938 939 continue;
939 940 }
940 941
941 942 if (section_size != 0) {
942 943 (void) printf(" <%d> \t", str_off);
943 944 beg_of_string = 0;
944 945 while (section_size--) {
945 946 unsigned char c = *strtab++;
946 947
947 948 if (beg_of_string) {
948 949 (void) printf(" <%d> \t", str_off);
949 950 counter++;
950 951 beg_of_string = 0;
951 952 }
952 953 str_off++;
953 954 switch (c) {
954 955 case '\0':
955 956 (void) printf("\n");
956 957 beg_of_string = 1;
957 958 break;
958 959 default:
959 960 (void) putchar(c);
960 961 }
961 962 }
962 963 }
963 964 }
964 965 (void) printf("\n");
965 966 }
966 967
967 968 /*
968 969 * Print the symbol table. This function does not print the contents
969 970 * of the symbol table but sets up the parameters and then calls
970 971 * print_symtab to print the symbols. Calling another function to print
971 972 * the symbols allows both -T and -n to work correctly
972 973 * simultaneously. Input is an opened ELF file, a pointer to the
973 974 * symbol table SCNTAB structure, and the filename.
974 975 * Set the range of symbols to print if T_flag, and set
975 976 * name of symbol to print if n_flag.
976 977 */
977 978 static void
978 979 dump_symbol_table(Elf *elf_file, SCNTAB *p_symtab, char *filename)
979 980 {
980 981 Elf_Data *sym_data;
981 982 GElf_Sym T_range, n_range; /* for use with -T and -n */
982 983 size_t count = 0;
983 984 size_t sym_size;
984 985 int index = 1;
985 986 int found_it = 0;
986 987 int i;
987 988 int adj = 0; /* field adjustment for elf64 */
988 989
989 990 if (gelf_getclass(elf_file) == ELFCLASS64)
990 991 adj = 8;
991 992
992 993 if (p_symtab == NULL) {
993 994 (void) fprintf(stderr,
994 995 "%s: %s: could not get symbol table\n", prog_name, filename);
995 996 return;
996 997 }
997 998
998 999 /* get symbol table data */
999 1000 sym_data = NULL;
1000 1001 sym_size = 0;
1001 1002 if ((sym_data =
1002 1003 elf_getdata(p_symtab->p_sd, NULL)) == NULL) {
1003 1004 (void) printf("\n%s:\n", p_symtab->scn_name);
1004 1005 (void) printf("No symbol table data\n");
1005 1006 return;
1006 1007 }
1007 1008 sym_size = sym_data->d_size;
1008 1009
1009 1010 count = sym_size / p_symtab->p_shdr.sh_entsize;
1010 1011
1011 1012 if (n_flag && t_flag && !T_flag) {
1012 1013 /* LINTED */
1013 1014 for (i = 1; i < count; i++) {
1014 1015 (void) gelf_getsym(sym_data, i, &n_range);
1015 1016 if (strcmp(name, (char *)
1016 1017 elf_strptr(elf_file,
1017 1018 p_symtab->p_shdr.sh_link,
1018 1019 n_range.st_name)) != 0) {
1019 1020 continue;
1020 1021 } else {
1021 1022 found_it = 1;
1022 1023 if (!p_flag) {
1023 1024 (void) printf(
1024 1025 "\n ***** SYMBOL TABLE INFORMATION *****\n");
1025 1026 (void) printf(
1026 1027 "[Index] %-*s%-*sType\tBind\tOther\tShndx\tName",
1027 1028 12 + adj, "Value", 9 + adj, "Size");
1028 1029 }
1029 1030 (void) printf("\n%s:\n", p_symtab->scn_name);
1030 1031 print_symtab(elf_file, p_symtab, sym_data,
1031 1032 1, i);
1032 1033 }
1033 1034 } /* end for */
1034 1035 if (!found_it) {
1035 1036 (void) fprintf(stderr, "%s: %s: %s not found\n",
1036 1037 prog_name, filename, name);
1037 1038 }
1038 1039 } else if (T_flag) {
1039 1040 T_num = check_range(T_low, T_hi, count, filename);
1040 1041 if (T_num < 0)
1041 1042 return;
1042 1043
1043 1044 (void) gelf_getsym(sym_data, T_low-1, &T_range);
1044 1045 index = T_low;
1045 1046
1046 1047 if (!p_flag) {
1047 1048 (void) printf(
1048 1049 "\n ***** SYMBOL TABLE INFORMATION *****\n");
1049 1050 (void) printf(
1050 1051 "[Index] %-*s%-*sType\tBind\tOther\tShndx\tName",
1051 1052 12 + adj, "Value", 9 + adj, "Size");
1052 1053 }
1053 1054 (void) printf("\n%s:\n", p_symtab->scn_name);
1054 1055 print_symtab(elf_file, p_symtab, sym_data, T_num, index);
1055 1056 } else {
1056 1057 if (!p_flag) {
1057 1058 (void) printf(
1058 1059 "\n ***** SYMBOL TABLE INFORMATION *****\n");
1059 1060 (void) printf(
1060 1061 "[Index] %-*s%-*sType\tBind\tOther\tShndx\tName",
1061 1062 12 + adj, "Value", 9 + adj, "Size");
1062 1063 }
1063 1064 (void) printf("\n%s:\n", p_symtab->scn_name);
1064 1065 print_symtab(elf_file, p_symtab, sym_data, count-1, 1);
1065 1066 }
1066 1067 }
1067 1068
1068 1069
1069 1070 /*
1070 1071 * Print dynamic linking information. Input is an ELF
1071 1072 * file descriptor, the SCNTAB structure, the number of
1072 1073 * sections, and the filename.
1073 1074 */
1074 1075 static void
1075 1076 dump_dynamic(Elf *elf_file, SCNTAB *p_scns, int num_scns, char *filename)
1076 1077 {
1077 1078 #define pdyn_Fmtptr "%#llx"
1078 1079
1079 1080 Elf_Data *dyn_data;
1080 1081 GElf_Dyn p_dyn;
1081 1082 GElf_Phdr p_phdr;
1082 1083 GElf_Ehdr p_ehdr;
1083 1084 int index = 1;
1084 1085 int lib_scns = num_scns;
1085 1086 SCNTAB *l_scns = p_scns;
1086 1087 int header_num = 0;
1087 1088 const char *str;
1088 1089
1089 1090 (void) gelf_getehdr(elf_file, &p_ehdr);
1090 1091
1091 1092 if (!p_flag)
1092 1093 (void) printf("\n **** DYNAMIC SECTION INFORMATION ****\n");
1093 1094
1094 1095 for (; num_scns > 0; num_scns--, p_scns++) {
1095 1096 GElf_Word link;
1096 1097 int ii;
1097 1098
1098 1099
1099 1100 if (p_scns->p_shdr.sh_type != SHT_DYNAMIC)
1100 1101 continue;
1101 1102
1102 1103 if (!p_flag) {
1103 1104 (void) printf("%s:\n", p_scns->scn_name);
1104 1105 (void) printf("[INDEX]\tTag Value\n");
1105 1106 }
1106 1107
1107 1108 if ((dyn_data = elf_getdata(p_scns->p_sd, NULL)) == 0) {
1108 1109 (void) fprintf(stderr, "%s: %s: no data in "
1109 1110 "%s section\n", prog_name, filename,
1110 1111 p_scns->scn_name);
1111 1112 return;
1112 1113 }
1113 1114
1114 1115 link = p_scns->p_shdr.sh_link;
1115 1116 ii = 0;
1116 1117
1117 1118 (void) gelf_getdyn(dyn_data, ii++, &p_dyn);
1118 1119 while (p_dyn.d_tag != DT_NULL) {
1119 1120 union {
1120 1121 Conv_inv_buf_t inv;
1121 1122 Conv_dyn_flag_buf_t dyn_flag;
1122 1123 Conv_dyn_flag1_buf_t dyn_flag1;
1123 1124 Conv_dyn_feature1_buf_t dyn_feature1;
1124 1125 Conv_dyn_posflag1_buf_t dyn_posflag1;
1125 1126 } conv_buf;
1126 1127
1127 1128 (void) printf("[%d]\t%-15.15s ", index++,
1128 1129 conv_dyn_tag(p_dyn.d_tag,
1129 1130 p_ehdr.e_ident[EI_OSABI], p_ehdr.e_machine,
1130 1131 DUMP_CONVFMT, &conv_buf.inv));
1131 1132
1132 1133 /*
1133 1134 * It would be nice to use a table driven loop
1134 1135 * here, but the address space is too sparse
1135 1136 * and irregular. A switch is simple and robust.
1136 1137 */
1137 1138 switch (p_dyn.d_tag) {
1138 1139 /*
1139 1140 * Items with an address value
1140 1141 */
1141 1142 case DT_PLTGOT:
1142 1143 case DT_HASH:
1143 1144 case DT_STRTAB:
1144 1145 case DT_RELA:
1145 1146 case DT_SYMTAB:
1146 1147 case DT_INIT:
1147 1148 case DT_FINI:
1148 1149 case DT_REL:
1149 1150 case DT_DEBUG:
1150 1151 case DT_TEXTREL:
1151 1152 case DT_JMPREL:
1152 1153 case DT_INIT_ARRAY:
1153 1154 case DT_FINI_ARRAY:
1154 1155 case DT_INIT_ARRAYSZ:
1155 1156 case DT_FINI_ARRAYSZ:
1156 1157 case DT_PREINIT_ARRAY:
1157 1158 case DT_PREINIT_ARRAYSZ:
1158 1159 case DT_SUNW_RTLDINF:
1159 1160 case DT_SUNW_CAP:
1160 1161 case DT_SUNW_CAPINFO:
1161 1162 case DT_SUNW_CAPCHAIN:
1162 1163 case DT_SUNW_SYMTAB:
1163 1164 case DT_SUNW_SYMSORT:
1164 1165 case DT_SUNW_TLSSORT:
1165 1166 case DT_PLTPAD:
1166 1167 case DT_MOVETAB:
1167 1168 case DT_SYMINFO:
1168 1169 case DT_RELACOUNT:
1169 1170 case DT_RELCOUNT:
1170 1171 case DT_VERSYM:
1171 1172 case DT_VERDEF:
1172 1173 case DT_VERDEFNUM:
1173 1174 case DT_VERNEED:
1174 1175 (void) printf(pdyn_Fmtptr,
1175 1176 EC_ADDR(p_dyn.d_un.d_ptr));
1176 1177 break;
1177 1178
1178 1179 /*
1179 1180 * Items with a string value
1180 1181 */
1181 1182 case DT_NEEDED:
1182 1183 case DT_SONAME:
1183 1184 case DT_RPATH:
1184 1185 case DT_RUNPATH:
1185 1186 case DT_SUNW_AUXILIARY:
1186 1187 case DT_SUNW_FILTER:
1187 1188 case DT_CONFIG:
1188 1189 case DT_DEPAUDIT:
1189 1190 case DT_AUDIT:
1190 1191 case DT_AUXILIARY:
1191 1192 case DT_USED:
1192 1193 case DT_FILTER:
1193 1194 if (v_flag) { /* Look up the string */
1194 1195 str = (char *)elf_strptr(elf_file, link,
1195 1196 p_dyn.d_un.d_ptr);
1196 1197 if (!(str && *str))
1197 1198 str = (char *)UNKNOWN;
1198 1199 (void) printf("%s", str);
1199 1200 } else { /* Show the address */
1200 1201 (void) printf(pdyn_Fmtptr,
1201 1202 EC_ADDR(p_dyn.d_un.d_ptr));
1202 1203 }
1203 1204 break;
1204 1205
1205 1206 /*
1206 1207 * Items with a literal value
1207 1208 */
1208 1209 case DT_PLTRELSZ:
1209 1210 case DT_RELASZ:
1210 1211 case DT_RELAENT:
1211 1212 case DT_STRSZ:
1212 1213 case DT_SYMENT:
1213 1214 case DT_RELSZ:
1214 1215 case DT_RELENT:
1215 1216 case DT_PLTREL:
1216 1217 case DT_BIND_NOW:
1217 1218 case DT_CHECKSUM:
1218 1219 case DT_PLTPADSZ:
1219 1220 case DT_MOVEENT:
1220 1221 case DT_MOVESZ:
1221 1222 case DT_SYMINSZ:
1222 1223 case DT_SYMINENT:
1223 1224 case DT_VERNEEDNUM:
1224 1225 case DT_SPARC_REGISTER:
1225 1226 case DT_SUNW_SYMSZ:
1226 1227 case DT_SUNW_SORTENT:
1227 1228 case DT_SUNW_SYMSORTSZ:
1228 1229 case DT_SUNW_TLSSORTSZ:
1229 1230 case DT_SUNW_STRPAD:
1230 1231 case DT_SUNW_CAPCHAINENT:
1231 1232 case DT_SUNW_CAPCHAINSZ:
1232 1233 case DT_SUNW_ASLR:
1233 1234 (void) printf(pdyn_Fmtptr,
1234 1235 EC_XWORD(p_dyn.d_un.d_val));
1235 1236 break;
1236 1237
1237 1238 /*
1238 1239 * Integer items that are bitmasks, or which
1239 1240 * can be otherwise formatted in symbolic form.
1240 1241 */
1241 1242 case DT_FLAGS:
1242 1243 case DT_FEATURE_1:
1243 1244 case DT_POSFLAG_1:
1244 1245 case DT_FLAGS_1:
1245 1246 case DT_SUNW_LDMACH:
1246 1247 str = NULL;
1247 1248 if (v_flag) {
1248 1249 switch (p_dyn.d_tag) {
1249 1250 case DT_FLAGS:
1250 1251 str = conv_dyn_flag(
1251 1252 p_dyn.d_un.d_val,
1252 1253 DUMP_CONVFMT,
1253 1254 &conv_buf.dyn_flag);
1254 1255 break;
1255 1256 case DT_FEATURE_1:
1256 1257 str = conv_dyn_feature1(
1257 1258 p_dyn.d_un.d_val,
1258 1259 DUMP_CONVFMT,
1259 1260 &conv_buf.dyn_feature1);
1260 1261 break;
1261 1262 case DT_POSFLAG_1:
1262 1263 str = conv_dyn_posflag1(
1263 1264 p_dyn.d_un.d_val,
1264 1265 DUMP_CONVFMT,
1265 1266 &conv_buf.dyn_posflag1);
1266 1267 break;
1267 1268 case DT_FLAGS_1:
1268 1269 str = conv_dyn_flag1(
1269 1270 p_dyn.d_un.d_val, 0,
1270 1271 &conv_buf.dyn_flag1);
1271 1272 break;
1272 1273 case DT_SUNW_LDMACH:
1273 1274 str = conv_ehdr_mach(
1274 1275 p_dyn.d_un.d_val, 0,
1275 1276 &conv_buf.inv);
1276 1277 break;
1277 1278 }
1278 1279 }
1279 1280 if (str) { /* Show as string */
1280 1281 (void) printf("%s", str);
1281 1282 } else { /* Numeric form */
1282 1283 (void) printf(pdyn_Fmtptr,
1283 1284 EC_ADDR(p_dyn.d_un.d_ptr));
1284 1285 }
1285 1286 break;
1286 1287
1287 1288 /*
1288 1289 * Depreciated items with a literal value
1289 1290 */
1290 1291 case DT_DEPRECATED_SPARC_REGISTER:
1291 1292 (void) printf(pdyn_Fmtptr
1292 1293 " (deprecated value)",
1293 1294 EC_XWORD(p_dyn.d_un.d_val));
1294 1295 break;
1295 1296
1296 1297 /* Ignored items */
1297 1298 case DT_SYMBOLIC:
1298 1299 (void) printf("(ignored)");
1299 1300 break;
1300 1301 }
1301 1302 (void) printf("\n");
1302 1303 (void) gelf_getdyn(dyn_data, ii++, &p_dyn);
1303 1304 }
1304 1305 }
1305 1306
1306 1307 /*
1307 1308 * Check for existence of static shared library information.
1308 1309 */
1309 1310 while (header_num < p_ehdr.e_phnum) {
1310 1311 (void) gelf_getphdr(elf_file, header_num, &p_phdr);
1311 1312 if (p_phdr.p_type == PT_SHLIB) {
1312 1313 while (--lib_scns > 0) {
1313 1314 if (strcmp(l_scns->scn_name, ".lib") == 0) {
1314 1315 print_static(l_scns, filename);
1315 1316 }
1316 1317 l_scns++;
1317 1318 }
1318 1319 }
1319 1320 header_num++;
1320 1321 }
1321 1322 #undef pdyn_Fmtptr
1322 1323 }
1323 1324
1324 1325 /*
1325 1326 * Print the ELF header. Input is an ELF file descriptor
1326 1327 * and the filename. If f_flag is set, the ELF header is
1327 1328 * printed to stdout, otherwise the function returns after
1328 1329 * setting the pointer to the ELF header. Any values which
1329 1330 * are not known are printed in decimal. Fields must be updated
1330 1331 * as new values are added.
1331 1332 */
1332 1333 static GElf_Ehdr *
1333 1334 dump_elf_header(Elf *elf_file, char *filename, GElf_Ehdr * elf_head_p)
1334 1335 {
1335 1336 int class;
1336 1337 int field;
1337 1338
1338 1339 if (gelf_getehdr(elf_file, elf_head_p) == NULL) {
1339 1340 (void) fprintf(stderr, "%s: %s: %s\n", prog_name, filename,
1340 1341 elf_errmsg(-1));
1341 1342 return (NULL);
1342 1343 }
1343 1344
1344 1345 class = (int)elf_head_p->e_ident[4];
1345 1346
1346 1347 if (class == ELFCLASS64)
1347 1348 field = 21;
1348 1349 else
1349 1350 field = 13;
1350 1351
1351 1352 if (!f_flag)
1352 1353 return (elf_head_p);
1353 1354
1354 1355 if (!p_flag) {
1355 1356 (void) printf("\n **** ELF HEADER ****\n");
1356 1357 (void) printf("%-*s%-11s%-*sMachine Version\n",
1357 1358 field, "Class", "Data", field, "Type");
1358 1359 (void) printf("%-*s%-11s%-*sFlags Ehsize\n",
1359 1360 field, "Entry", "Phoff", field, "Shoff");
1360 1361 (void) printf("%-*s%-11s%-*sShnum Shstrndx\n\n",
1361 1362 field, "Phentsize", "Phnum", field, "Shentsz");
1362 1363 }
1363 1364
1364 1365 if (!v_flag) {
1365 1366 (void) printf("%-*d%-11d%-*d%-12d%d\n",
1366 1367 field, elf_head_p->e_ident[4], elf_head_p->e_ident[5],
1367 1368 field, (int)elf_head_p->e_type, (int)elf_head_p->e_machine,
1368 1369 elf_head_p->e_version);
1369 1370 } else {
1370 1371 Conv_inv_buf_t inv_buf;
1371 1372
1372 1373 (void) printf("%-*s", field,
1373 1374 conv_ehdr_class(class, DUMP_CONVFMT, &inv_buf));
1374 1375 (void) printf("%-11s",
1375 1376 conv_ehdr_data(elf_head_p->e_ident[5], DUMP_CONVFMT,
1376 1377 &inv_buf));
1377 1378 (void) printf("%-*s", field,
1378 1379 conv_ehdr_type(elf_head_p->e_ident[EI_OSABI],
1379 1380 elf_head_p->e_type, DUMP_CONVFMT, &inv_buf));
1380 1381 (void) printf("%-12s",
1381 1382 conv_ehdr_mach(elf_head_p->e_machine, DUMP_CONVFMT,
1382 1383 &inv_buf));
1383 1384 (void) printf("%s\n",
1384 1385 conv_ehdr_vers(elf_head_p->e_version, DUMP_CONVFMT,
1385 1386 &inv_buf));
1386 1387 }
1387 1388 (void) printf("%-#*llx%-#11llx%-#*llx%-#12x%#x\n",
1388 1389 field, EC_ADDR(elf_head_p->e_entry), EC_OFF(elf_head_p->e_phoff),
1389 1390 field, EC_OFF(elf_head_p->e_shoff), EC_WORD(elf_head_p->e_flags),
1390 1391 EC_WORD(elf_head_p->e_ehsize));
1391 1392 if (!v_flag || (elf_head_p->e_shstrndx != SHN_XINDEX)) {
1392 1393 (void) printf("%-#*x%-11u%-#*x%-12u%u\n",
1393 1394 field, EC_WORD(elf_head_p->e_phentsize),
1394 1395 EC_WORD(elf_head_p->e_phnum),
1395 1396 field, EC_WORD(elf_head_p->e_shentsize),
1396 1397 EC_WORD(elf_head_p->e_shnum),
1397 1398 EC_WORD(elf_head_p->e_shstrndx));
1398 1399 } else {
1399 1400 (void) printf("%-#*x%-11u%-#*x%-12uXINDEX\n",
1400 1401 field, EC_WORD(elf_head_p->e_phentsize),
1401 1402 EC_WORD(elf_head_p->e_phnum),
1402 1403 field, EC_WORD(elf_head_p->e_shentsize),
1403 1404 EC_WORD(elf_head_p->e_shnum));
1404 1405 }
1405 1406 if ((elf_head_p->e_shnum == 0) && (elf_head_p->e_shoff > 0)) {
1406 1407 Elf_Scn *scn;
1407 1408 GElf_Shdr shdr0;
1408 1409 int field;
1409 1410
1410 1411 if (gelf_getclass(elf_file) == ELFCLASS64)
1411 1412 field = 21;
1412 1413 else
1413 1414 field = 13;
1414 1415 if (!p_flag) {
1415 1416 (void) printf("\n **** SECTION HEADER[0] "
1416 1417 "{Elf Extensions} ****\n");
1417 1418 (void) printf(
1418 1419 "[No]\tType\tFlags\t%-*s %-*s%-*s%sName\n",
1419 1420 field, "Addr", field, "Offset", field,
1420 1421 "Size(shnum)",
1421 1422 /* compatibility: tab for elf32 */
1422 1423 (field == 13) ? "\t" : " ");
1423 1424 (void) printf("\tLn(strndx) Info\t%-*s Entsize\n",
1424 1425 field, "Adralgn");
1425 1426 }
1426 1427 if ((scn = elf_getscn(elf_file, 0)) == NULL) {
1427 1428 (void) fprintf(stderr,
1428 1429 "%s: %s: elf_getscn failed: %s\n",
1429 1430 prog_name, filename, elf_errmsg(-1));
1430 1431 return (NULL);
1431 1432 }
1432 1433 if (gelf_getshdr(scn, &shdr0) == 0) {
1433 1434 (void) fprintf(stderr,
1434 1435 "%s: %s: gelf_getshdr: %s\n",
1435 1436 prog_name, filename, elf_errmsg(-1));
1436 1437 return (NULL);
1437 1438 }
1438 1439 (void) printf("[0]\t%u\t%llu\t", EC_WORD(shdr0.sh_type),
1439 1440 EC_XWORD(shdr0.sh_flags));
1440 1441
1441 1442 (void) printf("%-#*llx %-#*llx%-*llu%s%-*u\n",
1442 1443 field, EC_ADDR(shdr0.sh_addr),
1443 1444 field, EC_OFF(shdr0.sh_offset),
1444 1445 field, EC_XWORD(shdr0.sh_size),
1445 1446 /* compatibility: tab for elf32 */
1446 1447 ((field == 13) ? "\t" : " "),
1447 1448 field, EC_WORD(shdr0.sh_name));
1448 1449
1449 1450 (void) printf("\t%u\t%u\t%-#*llx %-#*llx\n",
1450 1451 EC_WORD(shdr0.sh_link),
1451 1452 EC_WORD(shdr0.sh_info),
1452 1453 field, EC_XWORD(shdr0.sh_addralign),
1453 1454 field, EC_XWORD(shdr0.sh_entsize));
1454 1455 }
1455 1456 (void) printf("\n");
1456 1457
1457 1458 return (elf_head_p);
1458 1459 }
1459 1460
1460 1461 /*
1461 1462 * Print section contents. Input is an ELF file descriptor,
1462 1463 * the ELF header, the SCNTAB structure,
1463 1464 * the number of symbols, and the filename.
1464 1465 * The number of sections,
1465 1466 * and the offset into the SCNTAB structure will be
1466 1467 * set in dump_section if d_flag or n_flag are set.
1467 1468 * If v_flag is set, sections which can be interpreted will
1468 1469 * be interpreted, otherwise raw data will be output in hexidecimal.
1469 1470 */
1470 1471 static void
1471 1472 print_section(Elf *elf_file,
1472 1473 GElf_Ehdr *p_ehdr, SCNTAB *p, int num_scns, char *filename)
1473 1474 {
1474 1475 unsigned char *p_sec;
1475 1476 int i;
1476 1477 size_t size;
1477 1478
1478 1479 for (i = 0; i < num_scns; i++, p++) {
1479 1480 GElf_Shdr shdr;
1480 1481
1481 1482 size = 0;
1482 1483 if (s_flag && !v_flag)
1483 1484 p_sec = (unsigned char *)get_rawscn(p->p_sd, &size);
1484 1485 else
1485 1486 p_sec = (unsigned char *)get_scndata(p->p_sd, &size);
1486 1487
1487 1488 if ((gelf_getshdr(p->p_sd, &shdr) != NULL) &&
1488 1489 (shdr.sh_type == SHT_NOBITS)) {
1489 1490 continue;
1490 1491 }
1491 1492 if (s_flag && !v_flag) {
1492 1493 (void) printf("\n%s:\n", p->scn_name);
1493 1494 print_rawdata(p_sec, size);
1494 1495 continue;
1495 1496 }
1496 1497 if (shdr.sh_type == SHT_SYMTAB) {
1497 1498 dump_symbol_table(elf_file, p, filename);
1498 1499 continue;
1499 1500 }
1500 1501 if (shdr.sh_type == SHT_DYNSYM) {
1501 1502 dump_symbol_table(elf_file, p, filename);
1502 1503 continue;
1503 1504 }
1504 1505 if (shdr.sh_type == SHT_STRTAB) {
1505 1506 dump_string_table(p, 1);
1506 1507 continue;
1507 1508 }
1508 1509 if (shdr.sh_type == SHT_RELA) {
1509 1510 dump_reloc_table(elf_file, p_ehdr, p, 1, filename);
1510 1511 continue;
1511 1512 }
1512 1513 if (shdr.sh_type == SHT_REL) {
1513 1514 dump_reloc_table(elf_file, p_ehdr, p, 1, filename);
1514 1515 continue;
1515 1516 }
1516 1517 if (shdr.sh_type == SHT_DYNAMIC) {
1517 1518 dump_dynamic(elf_file, p, 1, filename);
1518 1519 continue;
1519 1520 }
1520 1521
1521 1522 (void) printf("\n%s:\n", p->scn_name);
1522 1523 print_rawdata(p_sec, size);
1523 1524 }
1524 1525 (void) printf("\n");
1525 1526 }
1526 1527
1527 1528 /*
1528 1529 * Print section contents. This function does not print the contents
1529 1530 * of the sections but sets up the parameters and then calls
1530 1531 * print_section to print the contents. Calling another function to print
1531 1532 * the contents allows both -d and -n to work correctly
1532 1533 * simultaneously. Input is an ELF file descriptor, the ELF header,
1533 1534 * the SCNTAB structure, the number of sections, and the filename.
1534 1535 * Set the range of sections if d_flag, and set section name if
1535 1536 * n_flag.
1536 1537 */
1537 1538 static void
1538 1539 dump_section(Elf *elf_file,
1539 1540 GElf_Ehdr *p_ehdr, SCNTAB *s, int num_scns, char *filename)
1540 1541 {
1541 1542 SCNTAB *n_range, *d_range; /* for use with -n and -d modifiers */
1542 1543 int i;
1543 1544 int found_it = 0; /* for use with -n section_name */
1544 1545
1545 1546 if (n_flag) {
1546 1547 n_range = s;
1547 1548
1548 1549 for (i = 0; i < num_scns; i++, n_range++) {
1549 1550 if ((strcmp(name, n_range->scn_name)) != 0)
1550 1551 continue;
1551 1552 else {
1552 1553 found_it = 1;
1553 1554 print_section(elf_file, p_ehdr,
1554 1555 n_range, 1, filename);
1555 1556 }
1556 1557 }
1557 1558
1558 1559 if (!found_it) {
1559 1560 (void) fprintf(stderr, "%s: %s: %s not found\n",
1560 1561 prog_name, filename, name);
1561 1562 }
1562 1563 } /* end n_flag */
1563 1564
1564 1565 if (d_flag) {
1565 1566 d_range = s;
1566 1567 d_num = check_range(d_low, d_hi, num_scns, filename);
1567 1568 if (d_num < 0)
1568 1569 return;
1569 1570 d_range += d_low - 1;
1570 1571
1571 1572 print_section(elf_file, p_ehdr, d_range, d_num, filename);
1572 1573 } /* end d_flag */
1573 1574
1574 1575 if (!n_flag && !d_flag)
1575 1576 print_section(elf_file, p_ehdr, s, num_scns, filename);
1576 1577 }
1577 1578
1578 1579 /*
1579 1580 * Print the section header table. This function does not print the contents
1580 1581 * of the section headers but sets up the parameters and then calls
1581 1582 * print_shdr to print the contents. Calling another function to print
1582 1583 * the contents allows both -d and -n to work correctly
1583 1584 * simultaneously. Input is the SCNTAB structure,
1584 1585 * the number of sections from the ELF header, and the filename.
1585 1586 * Set the range of section headers to print if d_flag, and set
1586 1587 * name of section header to print if n_flag.
1587 1588 */
1588 1589 static void
1589 1590 dump_shdr(Elf *elf_file, SCNTAB *s, int num_scns, char *filename)
1590 1591 {
1591 1592
1592 1593 SCNTAB *n_range, *d_range; /* for use with -n and -d modifiers */
1593 1594 int field;
1594 1595 int i;
1595 1596 int found_it = 0; /* for use with -n section_name */
1596 1597
1597 1598 if (gelf_getclass(elf_file) == ELFCLASS64)
1598 1599 field = 21;
1599 1600 else
1600 1601 field = 13;
1601 1602
1602 1603 if (!p_flag) {
1603 1604 (void) printf("\n **** SECTION HEADER TABLE ****\n");
1604 1605 (void) printf("[No]\tType\tFlags\t%-*s %-*s %-*s%sName\n",
1605 1606 field, "Addr", field, "Offset", field, "Size",
1606 1607 /* compatibility: tab for elf32 */
1607 1608 (field == 13) ? "\t" : " ");
1608 1609 (void) printf("\tLink\tInfo\t%-*s Entsize\n\n",
1609 1610 field, "Adralgn");
1610 1611 }
1611 1612
1612 1613 if (n_flag) {
1613 1614 n_range = s;
1614 1615
1615 1616 for (i = 1; i <= num_scns; i++, n_range++) {
1616 1617 if ((strcmp(name, n_range->scn_name)) != 0)
1617 1618 continue;
1618 1619 else {
1619 1620 found_it = 1;
1620 1621 print_shdr(elf_file, n_range, 1, i);
1621 1622 }
1622 1623 }
1623 1624
1624 1625 if (!found_it) {
1625 1626 (void) fprintf(stderr, "%s: %s: %s not found\n",
1626 1627 prog_name, filename, name);
1627 1628 }
1628 1629 } /* end n_flag */
1629 1630
1630 1631 if (d_flag) {
1631 1632 d_range = s;
1632 1633 d_num = check_range(d_low, d_hi, num_scns, filename);
1633 1634 if (d_num < 0)
1634 1635 return;
1635 1636 d_range += d_low - 1;
1636 1637
1637 1638 print_shdr(elf_file, d_range, d_num, d_low);
1638 1639 } /* end d_flag */
1639 1640
1640 1641 if (!n_flag && !d_flag)
1641 1642 print_shdr(elf_file, s, num_scns, 1);
1642 1643 }
1643 1644
1644 1645 /*
1645 1646 * Process all of the command line options (except
1646 1647 * for -a, -g, -f, and -o). All of the options processed
1647 1648 * by this function require the presence of the section
1648 1649 * header table and will not be processed if it is not present.
1649 1650 * Set up a buffer containing section name, section header,
1650 1651 * and section descriptor for each section in the file. This
1651 1652 * structure is used to avoid duplicate calls to libelf functions.
1652 1653 * Structure members for the symbol table, the debugging information,
1653 1654 * and the line number information are global. All of the
1654 1655 * rest are local.
1655 1656 */
1656 1657 static void
1657 1658 dump_section_table(Elf *elf_file, GElf_Ehdr *elf_head_p, char *filename)
1658 1659 {
1659 1660
1660 1661 static SCNTAB *buffer, *p_scns;
1661 1662 Elf_Scn *scn = 0;
1662 1663 char *s_name = NULL;
1663 1664 int found = 0;
1664 1665 unsigned int num_scns;
1665 1666 size_t shstrndx;
1666 1667 size_t shnum;
1667 1668
1668 1669
1669 1670 if (elf_getshdrnum(elf_file, &shnum) == -1) {
1670 1671 (void) fprintf(stderr,
1671 1672 "%s: %s: elf_getshdrnum failed: %s\n",
1672 1673 prog_name, filename, elf_errmsg(-1));
1673 1674 return;
1674 1675 }
1675 1676 if (elf_getshdrstrndx(elf_file, &shstrndx) == -1) {
1676 1677 (void) fprintf(stderr,
1677 1678 "%s: %s: elf_getshdrstrndx failed: %s\n",
1678 1679 prog_name, filename, elf_errmsg(-1));
1679 1680 return;
1680 1681 }
1681 1682
1682 1683 if ((buffer = calloc(shnum, sizeof (SCNTAB))) == NULL) {
1683 1684 (void) fprintf(stderr, "%s: %s: cannot calloc space\n",
1684 1685 prog_name, filename);
1685 1686 return;
1686 1687 }
1687 1688 /* LINTED */
1688 1689 num_scns = (int)shnum - 1;
1689 1690
1690 1691 p_symtab = (SCNTAB *)0;
1691 1692 p_dynsym = (SCNTAB *)0;
1692 1693 p_scns = buffer;
1693 1694 p_head_scns = buffer;
1694 1695
1695 1696 while ((scn = elf_nextscn(elf_file, scn)) != 0) {
1696 1697 if ((gelf_getshdr(scn, &buffer->p_shdr)) == 0) {
1697 1698 (void) fprintf(stderr,
1698 1699 "%s: %s: %s\n", prog_name, filename,
1699 1700 elf_errmsg(-1));
1700 1701 return;
1701 1702 }
1702 1703 s_name = (char *)
1703 1704 elf_strptr(elf_file, shstrndx, buffer->p_shdr.sh_name);
1704 1705 buffer->scn_name = s_name ? s_name : (char *)UNKNOWN;
1705 1706 buffer->p_sd = scn;
1706 1707
1707 1708 if (buffer->p_shdr.sh_type == SHT_SYMTAB) {
1708 1709 found += 1;
1709 1710 p_symtab = buffer;
1710 1711 }
1711 1712 if (buffer->p_shdr.sh_type == SHT_DYNSYM)
1712 1713 p_dynsym = buffer;
1713 1714 buffer++;
1714 1715 }
1715 1716
1716 1717 /*
1717 1718 * These functions depend upon the presence of the section header table
1718 1719 * and will not be invoked in its absence
1719 1720 */
1720 1721 if (h_flag) {
1721 1722 dump_shdr(elf_file, p_scns, num_scns, filename);
1722 1723 }
1723 1724 if (p_symtab && (t_flag || T_flag)) {
1724 1725 dump_symbol_table(elf_file, p_symtab, filename);
1725 1726 }
1726 1727 if (c_flag) {
1727 1728 dump_string_table(p_scns, num_scns);
1728 1729 }
1729 1730 if (r_flag) {
1730 1731 dump_reloc_table(elf_file, elf_head_p,
1731 1732 p_scns, num_scns, filename);
1732 1733 }
1733 1734 if (L_flag) {
1734 1735 dump_dynamic(elf_file, p_scns, num_scns, filename);
1735 1736 }
1736 1737 if (s_flag) {
1737 1738 dump_section(elf_file, elf_head_p, p_scns,
1738 1739 num_scns, filename);
1739 1740 }
1740 1741 }
1741 1742
1742 1743 /*
1743 1744 * Load the archive string table(s) (for extended-length strings)
1744 1745 * into an in-core table/list
1745 1746 */
1746 1747 static struct stab_list_s *
1747 1748 load_arstring_table(struct stab_list_s *STabList,
1748 1749 int fd, Elf *elf_file, Elf_Arhdr *p_ar, char *filename)
1749 1750 {
1750 1751 off_t here;
1751 1752 struct stab_list_s *STL_entry, *STL_next;
1752 1753
1753 1754 if (p_ar) {
1754 1755 STL_entry = malloc(sizeof (struct stab_list_s));
1755 1756 STL_entry->next = 0;
1756 1757 STL_entry->strings = 0;
1757 1758 STL_entry->size = 0;
1758 1759
1759 1760 if (!STabList)
1760 1761 STabList = STL_entry;
1761 1762 else {
1762 1763 STL_next = STabList;
1763 1764 while (STL_next->next != (void *)0)
1764 1765 STL_next = STL_next->next;
1765 1766 STL_next->next = STL_entry;
1766 1767 }
1767 1768
1768 1769 STL_entry->size = p_ar->ar_size;
1769 1770 STL_entry->strings = malloc(p_ar->ar_size);
1770 1771 here = elf_getbase(elf_file);
1771 1772 if ((lseek(fd, here, 0)) != here) {
1772 1773 (void) fprintf(stderr,
1773 1774 "%s: %s: could not lseek\n", prog_name, filename);
1774 1775 }
1775 1776
1776 1777 if ((read(fd, STL_entry->strings, p_ar->ar_size)) == -1) {
1777 1778 (void) fprintf(stderr,
1778 1779 "%s: %s: could not read\n", prog_name, filename);
1779 1780 }
1780 1781 }
1781 1782 return (STabList);
1782 1783 }
1783 1784
1784 1785 /*
1785 1786 * Print the archive header for each member of an archive.
1786 1787 * Also call ar_sym_read to print the symbols in the
1787 1788 * archive symbol table if g_flag. Input is a file descriptor,
1788 1789 * an ELF file descriptor, and the filename. Putting the call
1789 1790 * to dump the archive symbol table in this function is more
1790 1791 * efficient since it is necessary to examine the archive member
1791 1792 * name in the archive header to determine which member is the
1792 1793 * symbol table.
1793 1794 */
1794 1795 static void
1795 1796 dump_ar_hdr(int fd, Elf *elf_file, char *filename)
1796 1797 {
1797 1798 extern int v_flag, g_flag, a_flag, p_flag;
1798 1799 Elf_Arhdr *p_ar;
1799 1800 Elf *arf;
1800 1801 Elf_Cmd cmd;
1801 1802 int title = 0;
1802 1803 int err = 0;
1803 1804
1804 1805 char buf[DATESIZE];
1805 1806
1806 1807 cmd = ELF_C_READ;
1807 1808 while ((arf = elf_begin(fd, cmd, elf_file)) != 0) {
1808 1809 p_ar = elf_getarhdr(arf);
1809 1810 if (p_ar == NULL) {
1810 1811 (void) fprintf(stderr,
1811 1812 "%s: %s: %s\n", prog_name, filename,
1812 1813 elf_errmsg(-1));
1813 1814 continue;
1814 1815 }
1815 1816 if ((strcmp(p_ar->ar_name, "/") == 0) ||
1816 1817 (strcmp(p_ar->ar_name, "/SYM64/") == 0)) {
1817 1818 if (g_flag)
1818 1819 ar_sym_read(elf_file, filename);
1819 1820 } else if (strcmp(p_ar->ar_name, "//") == 0) {
1820 1821 StringTableList = load_arstring_table(
1821 1822 StringTableList, fd, arf, p_ar, filename);
1822 1823 cmd = elf_next(arf);
1823 1824 (void) elf_end(arf);
1824 1825 continue;
1825 1826 } else {
1826 1827 if (a_flag) {
1827 1828 (void) printf("%s[%s]:\n", filename,
1828 1829 p_ar->ar_name);
1829 1830 if (!p_flag && title == 0) {
1830 1831 if (!v_flag)
1831 1832 (void) printf(
1832 1833 "\n\n\t\t\t***ARCHIVE HEADER***"
1833 1834 "\n Date Uid Gid Mode Size Member Name\n\n");
1834 1835 else
1835 1836 (void) printf(
1836 1837 "\n\n\t\t\t***ARCHIVE HEADER***"
1837 1838 "\n Date Uid Gid Mode Size Member Name\n\n");
1838 1839 title = 1;
1839 1840 }
1840 1841 if (!v_flag) {
1841 1842 (void) printf(
1842 1843 "\t0x%.8lx %6d %6d 0%.6ho 0x%.8lx %-s\n\n",
1843 1844 p_ar->ar_date, (int)p_ar->ar_uid,
1844 1845 (int)p_ar->ar_gid,
1845 1846 (int)p_ar->ar_mode,
1846 1847 p_ar->ar_size, p_ar->ar_name);
1847 1848 } else {
1848 1849 if ((strftime(buf, DATESIZE,
1849 1850 "%b %d %H:%M:%S %Y",
1850 1851 localtime(
1851 1852 &(p_ar->ar_date)))) == 0) {
1852 1853 (void) fprintf(stderr,
1853 1854 "%s: %s: don't have enough space to store the date\n", prog_name, filename);
1854 1855 exit(1);
1855 1856 }
1856 1857 (void) printf(
1857 1858 "\t%s %6d %6d 0%.6ho 0x%.8lx %-s\n\n",
1858 1859 buf, (int)p_ar->ar_uid,
1859 1860 (int)p_ar->ar_gid,
1860 1861 (int)p_ar->ar_mode,
1861 1862 p_ar->ar_size, p_ar->ar_name);
1862 1863 }
1863 1864 }
1864 1865 }
1865 1866 cmd = elf_next(arf);
1866 1867 (void) elf_end(arf);
1867 1868 } /* end while */
1868 1869
1869 1870 err = elf_errno();
1870 1871 if (err != 0) {
1871 1872 (void) fprintf(stderr,
1872 1873 "%s: %s: %s\n", prog_name, filename, elf_errmsg(err));
1873 1874 }
1874 1875 }
1875 1876
1876 1877 /*
1877 1878 * Process member files of an archive. This function provides
1878 1879 * a loop through an archive equivalent the processing of
1879 1880 * each_file for individual object files.
1880 1881 */
1881 1882 static void
1882 1883 dump_ar_files(int fd, Elf *elf_file, char *filename)
1883 1884 {
1884 1885 Elf_Arhdr *p_ar;
1885 1886 Elf *arf;
1886 1887 Elf_Cmd cmd;
1887 1888 Elf_Kind file_type;
1888 1889 GElf_Ehdr elf_head;
1889 1890 char *fullname;
1890 1891
1891 1892 cmd = ELF_C_READ;
1892 1893 while ((arf = elf_begin(fd, cmd, elf_file)) != 0) {
1893 1894 size_t len;
1894 1895
1895 1896 p_ar = elf_getarhdr(arf);
1896 1897 if (p_ar == NULL) {
1897 1898 (void) fprintf(stderr, "%s: %s: %s\n",
1898 1899 prog_name, filename, elf_errmsg(-1));
1899 1900 return;
1900 1901 }
1901 1902 if (p_ar->ar_name[0] == '/') {
1902 1903 cmd = elf_next(arf);
1903 1904 (void) elf_end(arf);
1904 1905 continue;
1905 1906 }
1906 1907
1907 1908 len = strlen(filename) + strlen(p_ar->ar_name) + 3;
1908 1909 if ((fullname = malloc(len)) == NULL)
1909 1910 return;
1910 1911 (void) snprintf(fullname, len, "%s[%s]", filename,
1911 1912 p_ar->ar_name);
1912 1913 (void) printf("\n%s:\n", fullname);
1913 1914 file_type = elf_kind(arf);
1914 1915 if (file_type == ELF_K_ELF) {
1915 1916 if (dump_elf_header(arf, fullname, &elf_head) == NULL)
1916 1917 return;
1917 1918 if (o_flag)
1918 1919 dump_exec_header(arf,
1919 1920 (unsigned)elf_head.e_phnum, fullname);
1920 1921 if (x_flag)
1921 1922 dump_section_table(arf, &elf_head, fullname);
1922 1923 } else {
1923 1924 (void) fprintf(stderr, "%s: %s: invalid file type\n",
1924 1925 prog_name, fullname);
1925 1926 cmd = elf_next(arf);
1926 1927 (void) elf_end(arf);
1927 1928 continue;
1928 1929 }
1929 1930
1930 1931 cmd = elf_next(arf);
1931 1932 (void) elf_end(arf);
1932 1933 } /* end while */
1933 1934 }
1934 1935
1935 1936 /*
1936 1937 * Takes a filename as input. Test first for a valid version
1937 1938 * of libelf.a and exit on error. Process each valid file
1938 1939 * or archive given as input on the command line. Check
1939 1940 * for file type. If it is an archive, process the archive-
1940 1941 * specific options first, then files within the archive.
1941 1942 * If it is an ELF object file, process it; otherwise
1942 1943 * warn that it is an invalid file type.
1943 1944 * All options except the archive-specific and program
1944 1945 * execution header are processed in the function, dump_section_table.
1945 1946 */
1946 1947 static void
1947 1948 each_file(char *filename)
1948 1949 {
1949 1950 Elf *elf_file;
1950 1951 GElf_Ehdr elf_head;
1951 1952 int fd;
1952 1953 Elf_Kind file_type;
1953 1954
1954 1955 struct stat buf;
1955 1956
1956 1957 Elf_Cmd cmd;
1957 1958 errno = 0;
1958 1959
1959 1960 if (stat(filename, &buf) == -1) {
1960 1961 int err = errno;
1961 1962 (void) fprintf(stderr, "%s: %s: %s", prog_name, filename,
1962 1963 strerror(err));
1963 1964 return;
1964 1965 }
1965 1966
1966 1967 if ((fd = open((filename), O_RDONLY)) == -1) {
1967 1968 (void) fprintf(stderr, "%s: %s: cannot read\n", prog_name,
1968 1969 filename);
1969 1970 return;
1970 1971 }
1971 1972 cmd = ELF_C_READ;
1972 1973 if ((elf_file = elf_begin(fd, cmd, (Elf *)0)) == NULL) {
1973 1974 (void) fprintf(stderr, "%s: %s: %s\n", prog_name, filename,
1974 1975 elf_errmsg(-1));
1975 1976 return;
1976 1977 }
1977 1978
1978 1979 file_type = elf_kind(elf_file);
1979 1980 if (file_type == ELF_K_AR) {
1980 1981 if (a_flag || g_flag) {
1981 1982 dump_ar_hdr(fd, elf_file, filename);
1982 1983 elf_file = elf_begin(fd, cmd, (Elf *)0);
1983 1984 }
1984 1985 if (z_flag)
1985 1986 dump_ar_files(fd, elf_file, filename);
1986 1987 } else {
1987 1988 if (file_type == ELF_K_ELF) {
1988 1989 (void) printf("\n%s:\n", filename);
1989 1990 if (dump_elf_header(elf_file, filename, &elf_head)) {
1990 1991 if (o_flag)
1991 1992 dump_exec_header(elf_file,
1992 1993 (unsigned)elf_head.e_phnum,
1993 1994 filename);
1994 1995 if (x_flag)
1995 1996 dump_section_table(elf_file,
1996 1997 &elf_head, filename);
1997 1998 }
1998 1999 } else {
1999 2000 (void) fprintf(stderr, "%s: %s: invalid file type\n",
2000 2001 prog_name, filename);
2001 2002 }
2002 2003 }
2003 2004 (void) elf_end(elf_file);
2004 2005 (void) close(fd);
2005 2006 }
2006 2007
2007 2008 /*
2008 2009 * Sets up flags for command line options given and then
2009 2010 * calls each_file() to process each file.
2010 2011 */
2011 2012 int
2012 2013 main(int argc, char *argv[], char *envp[])
2013 2014 {
2014 2015 char *optstr = OPTSTR; /* option string used by getopt() */
2015 2016 int optchar;
2016 2017
2017 2018 /*
2018 2019 * Check for a binary that better fits this architecture.
2019 2020 */
2020 2021 (void) conv_check_native(argv, envp);
2021 2022
2022 2023 prog_name = argv[0];
2023 2024
2024 2025 (void) setlocale(LC_ALL, "");
2025 2026 while ((optchar = getopt(argc, argv, optstr)) != -1) {
2026 2027 switch (optchar) {
2027 2028 case 'a':
2028 2029 a_flag = 1;
2029 2030 x_flag = 1;
2030 2031 break;
2031 2032 case 'g':
2032 2033 g_flag = 1;
2033 2034 x_flag = 1;
2034 2035 break;
2035 2036 case 'v':
2036 2037 v_flag = 1;
2037 2038 break;
2038 2039 case 'p':
2039 2040 p_flag = 1;
2040 2041 break;
2041 2042 case 'f':
2042 2043 f_flag = 1;
2043 2044 z_flag = 1;
2044 2045 break;
2045 2046 case 'o':
2046 2047 o_flag = 1;
2047 2048 z_flag = 1;
2048 2049 break;
2049 2050 case 'h':
2050 2051 h_flag = 1;
2051 2052 x_flag = 1;
2052 2053 z_flag = 1;
2053 2054 break;
2054 2055 case 's':
2055 2056 s_flag = 1;
2056 2057 x_flag = 1;
2057 2058 z_flag = 1;
2058 2059 break;
2059 2060 case 'd':
2060 2061 d_flag = 1;
2061 2062 x_flag = 1;
2062 2063 z_flag = 1;
2063 2064 set_range(optarg, &d_low, &d_hi);
2064 2065 break;
2065 2066 case 'n':
2066 2067 n_flag++;
2067 2068 x_flag = 1;
2068 2069 z_flag = 1;
2069 2070 name = optarg;
2070 2071 break;
2071 2072 case 'r':
2072 2073 r_flag = 1;
2073 2074 x_flag = 1;
2074 2075 z_flag = 1;
2075 2076 break;
2076 2077 case 't':
2077 2078 t_flag = 1;
2078 2079 x_flag = 1;
2079 2080 z_flag = 1;
2080 2081 break;
2081 2082 case 'C':
2082 2083 C_flag = 1;
2083 2084 t_flag = 1;
2084 2085 x_flag = 1;
2085 2086 z_flag = 1;
2086 2087 break;
2087 2088 case 'T':
2088 2089 T_flag = 1;
2089 2090 x_flag = 1;
2090 2091 z_flag = 1;
2091 2092 set_range(optarg, &T_low, &T_hi);
2092 2093 break;
2093 2094 case 'c':
2094 2095 c_flag = 1;
2095 2096 x_flag = 1;
2096 2097 z_flag = 1;
2097 2098 break;
2098 2099 case 'L':
2099 2100 L_flag = 1;
2100 2101 x_flag = 1;
2101 2102 z_flag = 1;
2102 2103 break;
2103 2104 case 'V':
2104 2105 V_flag = 1;
2105 2106 (void) fprintf(stderr, "dump: %s %s\n",
2106 2107 (const char *)SGU_PKG,
2107 2108 (const char *)SGU_REL);
2108 2109 break;
2109 2110 case '?':
2110 2111 errflag += 1;
2111 2112 break;
2112 2113 default:
2113 2114 break;
2114 2115 }
2115 2116 }
2116 2117
2117 2118 if (errflag || (optind >= argc) || (!z_flag && !x_flag)) {
2118 2119 if (!(V_flag && (argc == 2))) {
2119 2120 usage();
2120 2121 exit(269);
2121 2122 }
2122 2123 }
2123 2124
2124 2125 if (elf_version(EV_CURRENT) == EV_NONE) {
2125 2126 (void) fprintf(stderr, "%s: libelf is out of date\n",
2126 2127 prog_name);
2127 2128 exit(101);
2128 2129 }
2129 2130
2130 2131 while (optind < argc) {
2131 2132 each_file(argv[optind]);
2132 2133 optind++;
2133 2134 }
2134 2135 return (0);
2135 2136 }
|
↓ open down ↓ |
2099 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX