1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * Dump an elf file. 30 */ 31 #include <machdep.h> 32 #include <sys/elf_386.h> 33 #include <sys/elf_amd64.h> 34 #include <sys/elf_SPARC.h> 35 #include <dwarf.h> 36 #include <unistd.h> 37 #include <errno.h> 38 #include <strings.h> 39 #include <debug.h> 40 #include <conv.h> 41 #include <msg.h> 42 #include <_elfdump.h> 43 44 45 46 /* 47 * VERSYM_STATE is used to maintain information about the VERSYM section 48 * in the object being analyzed. It is filled in by versions(), and used 49 * by init_symtbl_state() when displaying symbol information. 50 * 51 * max_verndx contains the largest version index that can appear 52 * in a Versym entry. This can never be less than 1: In the case where 53 * there is no verdef/verneed sections, the [0] index is reserved 54 * for local symbols, and the [1] index for globals. If Solaris versioning 55 * rules are in effect and there is a verdef section, then the number 56 * of defined versions provides this number. If GNU versioning is in effect, 57 * then: 58 * - If there is no verneed section, it is the same as for 59 * Solaris versioning. 60 * - If there is a verneed section, the vna_other field of the 61 * Vernaux structs contain versions, and max_verndx is the 62 * largest such index. 63 * 64 * The value of the gnu field is based on the presence of 65 * a DT_VERSYM entry in the dynamic section: GNU ld produces these, and 66 * Solaris ld does not. 67 */ 68 typedef struct { 69 Cache *cache; /* Pointer to cache entry for VERSYM */ 70 Versym *data; /* Pointer to versym array */ 71 int gnu; /* True if object uses GNU versioning rules */ 72 int max_verndx; /* largest versym index value */ 73 } VERSYM_STATE; 74 75 /* 76 * SYMTBL_STATE is used to maintain information about a single symbol 77 * table section, for use by the routines that display symbol information. 78 */ 79 typedef struct { 80 const char *file; /* Name of file */ 81 Ehdr *ehdr; /* ELF header for file */ 82 Cache *cache; /* Cache of all section headers */ 83 Word shnum; /* # of sections in cache */ 84 Cache *seccache; /* Cache of symbol table section hdr */ 85 Word secndx; /* Index of symbol table section hdr */ 86 const char *secname; /* Name of section */ 87 uint_t flags; /* Command line option flags */ 88 struct { /* Extended section index data */ 89 int checked; /* TRUE if already checked for shxndx */ 90 Word *data; /* NULL, or extended section index */ 91 /* used for symbol table entries */ 92 uint_t n; /* # items in shxndx.data */ 93 } shxndx; 94 VERSYM_STATE *versym; /* NULL, or associated VERSYM section */ 95 Sym *sym; /* Array of symbols */ 96 Word symn; /* # of symbols */ 97 } SYMTBL_STATE; 98 99 100 101 /* 102 * Focal point for verifying symbol names. 103 */ 104 static const char * 105 string(Cache *refsec, Word ndx, Cache *strsec, const char *file, Word name) 106 { 107 /* 108 * If an error in this routine is due to a property of the string 109 * section, as opposed to a bad offset into the section (a property of 110 * the referencing section), then we will detect the same error on 111 * every call involving those sections. We use these static variables 112 * to retain the information needed to only issue each such error once. 113 */ 114 static Cache *last_refsec; /* Last referencing section seen */ 115 static int strsec_err; /* True if error issued */ 116 117 const char *strs; 118 Word strn; 119 120 if (strsec->c_data == NULL) 121 return (NULL); 122 123 strs = (char *)strsec->c_data->d_buf; 124 strn = strsec->c_data->d_size; 125 126 /* 127 * We only print a diagnostic regarding a bad string table once per 128 * input section being processed. If the refsec has changed, reset 129 * our retained error state. 130 */ 131 if (last_refsec != refsec) { 132 last_refsec = refsec; 133 strsec_err = 0; 134 } 135 136 /* Verify that strsec really is a string table */ 137 if (strsec->c_shdr->sh_type != SHT_STRTAB) { 138 if (!strsec_err) { 139 (void) fprintf(stderr, MSG_INTL(MSG_ERR_NOTSTRTAB), 140 file, strsec->c_ndx, refsec->c_ndx); 141 strsec_err = 1; 142 } 143 return (MSG_INTL(MSG_STR_UNKNOWN)); 144 } 145 146 /* 147 * Is the string table offset within range of the available strings? 148 */ 149 if (name >= strn) { 150 /* 151 * Do we have a empty string table? 152 */ 153 if (strs == 0) { 154 if (!strsec_err) { 155 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 156 file, strsec->c_name); 157 strsec_err = 1; 158 } 159 } else { 160 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSTOFF), 161 file, refsec->c_name, EC_WORD(ndx), strsec->c_name, 162 EC_WORD(name), EC_WORD(strn - 1)); 163 } 164 165 /* 166 * Return the empty string so that the calling function can 167 * continue it's output diagnostics. 168 */ 169 return (MSG_INTL(MSG_STR_UNKNOWN)); 170 } 171 return (strs + name); 172 } 173 174 /* 175 * Relocations can reference section symbols and standard symbols. If the 176 * former, establish the section name. 177 */ 178 static const char * 179 relsymname(Cache *cache, Cache *csec, Cache *strsec, Word symndx, Word symnum, 180 Word relndx, Sym *syms, char *secstr, size_t secsz, const char *file, 181 uint_t flags) 182 { 183 Sym *sym; 184 185 if (symndx >= symnum) { 186 (void) fprintf(stderr, MSG_INTL(MSG_ERR_RELBADSYMNDX), 187 file, EC_WORD(symndx), EC_WORD(relndx)); 188 return (MSG_INTL(MSG_STR_UNKNOWN)); 189 } 190 191 sym = (Sym *)(syms + symndx); 192 193 /* 194 * If the symbol represents a section offset construct an appropriate 195 * string. 196 */ 197 if ((ELF_ST_TYPE(sym->st_info) == STT_SECTION) && (sym->st_name == 0)) { 198 if (flags & FLG_LONGNAME) 199 (void) snprintf(secstr, secsz, 200 MSG_INTL(MSG_STR_L_SECTION), 201 cache[sym->st_shndx].c_name); 202 else 203 (void) snprintf(secstr, secsz, 204 MSG_INTL(MSG_STR_SECTION), 205 cache[sym->st_shndx].c_name); 206 return ((const char *)secstr); 207 } 208 209 return (string(csec, symndx, strsec, file, sym->st_name)); 210 } 211 212 /* 213 * Focal point for establishing a string table section. Data such as the 214 * dynamic information simply points to a string table. Data such as 215 * relocations, reference a symbol table, which in turn is associated with a 216 * string table. 217 */ 218 static int 219 stringtbl(Cache *cache, int symtab, Word ndx, Word shnum, const char *file, 220 Word *symnum, Cache **symsec, Cache **strsec) 221 { 222 Shdr *shdr = cache[ndx].c_shdr; 223 224 if (symtab) { 225 /* 226 * Validate the symbol table section. 227 */ 228 if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { 229 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), 230 file, cache[ndx].c_name, EC_WORD(shdr->sh_link)); 231 return (0); 232 } 233 if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { 234 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 235 file, cache[ndx].c_name); 236 return (0); 237 } 238 239 /* 240 * Obtain, and verify the symbol table data. 241 */ 242 if ((cache[ndx].c_data == NULL) || 243 (cache[ndx].c_data->d_buf == NULL)) { 244 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 245 file, cache[ndx].c_name); 246 return (0); 247 } 248 249 /* 250 * Establish the string table index. 251 */ 252 ndx = shdr->sh_link; 253 shdr = cache[ndx].c_shdr; 254 255 /* 256 * Return symbol table information. 257 */ 258 if (symnum) 259 *symnum = (shdr->sh_size / shdr->sh_entsize); 260 if (symsec) 261 *symsec = &cache[ndx]; 262 } 263 264 /* 265 * Validate the associated string table section. 266 */ 267 if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { 268 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), 269 file, cache[ndx].c_name, EC_WORD(shdr->sh_link)); 270 return (0); 271 } 272 273 if (strsec) 274 *strsec = &cache[shdr->sh_link]; 275 276 return (1); 277 } 278 279 /* 280 * Lookup a symbol and set Sym accordingly. 281 */ 282 static int 283 symlookup(const char *name, Cache *cache, Word shnum, Sym **sym, 284 Cache *symtab, const char *file) 285 { 286 Shdr *shdr; 287 Word symn, cnt; 288 Sym *syms; 289 290 if (symtab == 0) 291 return (0); 292 293 shdr = symtab->c_shdr; 294 295 /* 296 * Determine the symbol data and number. 297 */ 298 if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { 299 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 300 file, symtab->c_name); 301 return (0); 302 } 303 if (symtab->c_data == NULL) 304 return (0); 305 306 /* LINTED */ 307 symn = (Word)(shdr->sh_size / shdr->sh_entsize); 308 syms = (Sym *)symtab->c_data->d_buf; 309 310 /* 311 * Get the associated string table section. 312 */ 313 if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { 314 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), 315 file, symtab->c_name, EC_WORD(shdr->sh_link)); 316 return (0); 317 } 318 319 /* 320 * Loop through the symbol table to find a match. 321 */ 322 for (cnt = 0; cnt < symn; syms++, cnt++) { 323 const char *symname; 324 325 symname = string(symtab, cnt, &cache[shdr->sh_link], file, 326 syms->st_name); 327 328 if (symname && (strcmp(name, symname) == 0)) { 329 *sym = syms; 330 return (1); 331 } 332 } 333 return (0); 334 } 335 336 /* 337 * Print section headers. 338 */ 339 static void 340 sections(const char *file, Cache *cache, Word shnum, Ehdr *ehdr) 341 { 342 size_t seccnt; 343 344 for (seccnt = 1; seccnt < shnum; seccnt++) { 345 Cache *_cache = &cache[seccnt]; 346 Shdr *shdr = _cache->c_shdr; 347 const char *secname = _cache->c_name; 348 349 /* 350 * Although numerous section header entries can be zero, it's 351 * usually a sign of trouble if the type is zero. 352 */ 353 if (shdr->sh_type == 0) { 354 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHTYPE), 355 file, secname, EC_WORD(shdr->sh_type)); 356 } 357 358 if (!match(0, secname, seccnt)) 359 continue; 360 361 /* 362 * Identify any sections that are suspicious. A .got section 363 * shouldn't exist in a relocatable object. 364 */ 365 if (ehdr->e_type == ET_REL) { 366 if (strncmp(secname, MSG_ORIG(MSG_ELF_GOT), 367 MSG_ELF_GOT_SIZE) == 0) { 368 (void) fprintf(stderr, 369 MSG_INTL(MSG_GOT_UNEXPECTED), file, 370 secname); 371 } 372 } 373 374 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 375 dbg_print(0, MSG_INTL(MSG_ELF_SHDR), EC_WORD(seccnt), secname); 376 Elf_shdr(0, ehdr->e_machine, shdr); 377 } 378 } 379 380 /* 381 * A couple of instances of unwind data are printed as tables of 8 data items 382 * expressed as 0x?? integers. 383 */ 384 #define UNWINDTBLSZ 10 + (8 * 5) + 1 385 386 static void 387 unwindtbl(uint64_t *ndx, uint_t len, uchar_t *data, uint64_t doff, 388 const char *msg, const char *pre, size_t plen) 389 { 390 char buffer[UNWINDTBLSZ]; 391 uint_t boff = plen, cnt = 0; 392 393 dbg_print(0, msg); 394 (void) strncpy(buffer, pre, UNWINDTBLSZ); 395 396 while (*ndx < (len + 4)) { 397 if (cnt == 8) { 398 dbg_print(0, buffer); 399 boff = plen; 400 cnt = 0; 401 } 402 (void) snprintf(&buffer[boff], UNWINDTBLSZ - boff, 403 MSG_ORIG(MSG_UNW_TBLENTRY), data[doff + (*ndx)++]); 404 boff += 5; 405 cnt++; 406 } 407 if (cnt) 408 dbg_print(0, buffer); 409 } 410 411 /* 412 * Obtain a specified Phdr entry. 413 */ 414 static Phdr * 415 getphdr(Word phnum, Word type, const char *file, Elf *elf) 416 { 417 Word cnt; 418 Phdr *phdr; 419 420 if ((phdr = elf_getphdr(elf)) == NULL) { 421 failure(file, MSG_ORIG(MSG_ELF_GETPHDR)); 422 return (0); 423 } 424 425 for (cnt = 0; cnt < phnum; phdr++, cnt++) { 426 if (phdr->p_type == type) 427 return (phdr); 428 } 429 return (0); 430 } 431 432 static void 433 unwind(Cache *cache, Word shnum, Word phnum, Ehdr *ehdr, const char *file, 434 Elf *elf) 435 { 436 Conv_dwarf_ehe_buf_t dwarf_ehe_buf; 437 Word cnt; 438 Phdr *uphdr = 0; 439 440 /* 441 * For the moment - UNWIND is only relevant for a AMD64 object. 442 */ 443 if (ehdr->e_machine != EM_AMD64) 444 return; 445 446 if (phnum) 447 uphdr = getphdr(phnum, PT_SUNW_UNWIND, file, elf); 448 449 for (cnt = 1; cnt < shnum; cnt++) { 450 Cache *_cache = &cache[cnt]; 451 Shdr *shdr = _cache->c_shdr; 452 uchar_t *data; 453 size_t datasize; 454 uint64_t off, ndx, frame_ptr, fde_cnt, tabndx; 455 uint_t vers, frame_ptr_enc, fde_cnt_enc, table_enc; 456 457 /* 458 * AMD64 - this is a strmcp() just to find the gcc produced 459 * sections. Soon gcc should be setting the section type - and 460 * we'll not need this strcmp(). 461 */ 462 if ((shdr->sh_type != SHT_AMD64_UNWIND) && 463 (strncmp(_cache->c_name, MSG_ORIG(MSG_SCN_FRM), 464 MSG_SCN_FRM_SIZE) != 0) && 465 (strncmp(_cache->c_name, MSG_ORIG(MSG_SCN_FRMHDR), 466 MSG_SCN_FRMHDR_SIZE) != 0)) 467 continue; 468 469 if (!match(0, _cache->c_name, cnt)) 470 continue; 471 472 if (_cache->c_data == NULL) 473 continue; 474 475 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 476 dbg_print(0, MSG_INTL(MSG_ELF_SCN_UNWIND), _cache->c_name); 477 478 data = (uchar_t *)(_cache->c_data->d_buf); 479 datasize = _cache->c_data->d_size; 480 off = 0; 481 482 /* 483 * Is this a .eh_frame_hdr 484 */ 485 if ((uphdr && (shdr->sh_addr == uphdr->p_vaddr)) || 486 (strncmp(_cache->c_name, MSG_ORIG(MSG_SCN_FRMHDR), 487 MSG_SCN_FRMHDR_SIZE) == 0)) { 488 dbg_print(0, MSG_ORIG(MSG_UNW_FRMHDR)); 489 ndx = 0; 490 491 vers = data[ndx++]; 492 frame_ptr_enc = data[ndx++]; 493 fde_cnt_enc = data[ndx++]; 494 table_enc = data[ndx++]; 495 496 dbg_print(0, MSG_ORIG(MSG_UNW_FRMVERS), vers); 497 498 frame_ptr = dwarf_ehe_extract(data, &ndx, frame_ptr_enc, 499 ehdr->e_ident, shdr->sh_addr + ndx); 500 501 dbg_print(0, MSG_ORIG(MSG_UNW_FRPTRENC), 502 conv_dwarf_ehe(frame_ptr_enc, &dwarf_ehe_buf), 503 EC_XWORD(frame_ptr)); 504 505 fde_cnt = dwarf_ehe_extract(data, &ndx, fde_cnt_enc, 506 ehdr->e_ident, shdr->sh_addr + ndx); 507 508 dbg_print(0, MSG_ORIG(MSG_UNW_FDCNENC), 509 conv_dwarf_ehe(fde_cnt_enc, &dwarf_ehe_buf), 510 EC_XWORD(fde_cnt)); 511 dbg_print(0, MSG_ORIG(MSG_UNW_TABENC), 512 conv_dwarf_ehe(table_enc, &dwarf_ehe_buf)); 513 dbg_print(0, MSG_ORIG(MSG_UNW_BINSRTAB1)); 514 dbg_print(0, MSG_ORIG(MSG_UNW_BINSRTAB2)); 515 516 for (tabndx = 0; tabndx < fde_cnt; tabndx++) { 517 dbg_print(0, MSG_ORIG(MSG_UNW_BINSRTABENT), 518 EC_XWORD(dwarf_ehe_extract(data, &ndx, 519 table_enc, ehdr->e_ident, shdr->sh_addr)), 520 EC_XWORD(dwarf_ehe_extract(data, &ndx, 521 table_enc, ehdr->e_ident, shdr->sh_addr))); 522 } 523 continue; 524 } 525 526 /* 527 * Walk the Eh_frame's 528 */ 529 while (off < datasize) { 530 uint_t cieid, cielength, cieversion; 531 uint_t cieretaddr; 532 int cieRflag, cieLflag, ciePflag, cieZflag; 533 uint_t cieaugndx, length, id; 534 uint64_t ciecalign, ciedalign; 535 char *cieaugstr; 536 537 ndx = 0; 538 /* 539 * extract length in lsb format 540 */ 541 length = LSB32EXTRACT(data + off + ndx); 542 ndx += 4; 543 544 /* 545 * extract CIE id in lsb format 546 */ 547 id = LSB32EXTRACT(data + off + ndx); 548 ndx += 4; 549 550 /* 551 * A CIE record has a id of '0', otherwise this is a 552 * FDE entry and the 'id' is the CIE pointer. 553 */ 554 if (id == 0) { 555 uint64_t persVal; 556 557 cielength = length; 558 cieid = id; 559 cieLflag = ciePflag = cieRflag = cieZflag = 0; 560 561 dbg_print(0, MSG_ORIG(MSG_UNW_CIE), 562 EC_XWORD(shdr->sh_addr + off)); 563 dbg_print(0, MSG_ORIG(MSG_UNW_CIELNGTH), 564 cielength, cieid); 565 566 cieversion = data[off + ndx]; 567 ndx += 1; 568 cieaugstr = (char *)(&data[off + ndx]); 569 ndx += strlen(cieaugstr) + 1; 570 571 dbg_print(0, MSG_ORIG(MSG_UNW_CIEVERS), 572 cieversion, cieaugstr); 573 574 ciecalign = uleb_extract(&data[off], &ndx); 575 ciedalign = sleb_extract(&data[off], &ndx); 576 cieretaddr = data[off + ndx]; 577 ndx += 1; 578 579 dbg_print(0, MSG_ORIG(MSG_UNW_CIECALGN), 580 EC_XWORD(ciecalign), EC_XWORD(ciedalign), 581 cieretaddr); 582 583 if (cieaugstr[0]) 584 dbg_print(0, 585 MSG_ORIG(MSG_UNW_CIEAXVAL)); 586 587 for (cieaugndx = 0; cieaugstr[cieaugndx]; 588 cieaugndx++) { 589 uint_t val; 590 591 switch (cieaugstr[cieaugndx]) { 592 case 'z': 593 val = uleb_extract(&data[off], 594 &ndx); 595 dbg_print(0, 596 MSG_ORIG(MSG_UNW_CIEAXSIZ), 597 val); 598 cieZflag = 1; 599 break; 600 case 'P': 601 ciePflag = data[off + ndx]; 602 ndx += 1; 603 604 persVal = dwarf_ehe_extract( 605 &data[off], &ndx, ciePflag, 606 ehdr->e_ident, 607 shdr->sh_addr + off + ndx); 608 dbg_print(0, 609 MSG_ORIG(MSG_UNW_CIEAXPERS), 610 ciePflag, 611 conv_dwarf_ehe(ciePflag, 612 &dwarf_ehe_buf), 613 EC_XWORD(persVal)); 614 break; 615 case 'R': 616 val = data[off + ndx]; 617 ndx += 1; 618 dbg_print(0, 619 MSG_ORIG(MSG_UNW_CIEAXCENC), 620 val, conv_dwarf_ehe(val, 621 &dwarf_ehe_buf)); 622 cieRflag = val; 623 break; 624 case 'L': 625 val = data[off + ndx]; 626 ndx += 1; 627 dbg_print(0, 628 MSG_ORIG(MSG_UNW_CIEAXLSDA), 629 val, conv_dwarf_ehe(val, 630 &dwarf_ehe_buf)); 631 cieLflag = val; 632 break; 633 default: 634 dbg_print(0, 635 MSG_ORIG(MSG_UNW_CIEAXUNEC), 636 cieaugstr[cieaugndx]); 637 break; 638 } 639 } 640 if ((cielength + 4) > ndx) 641 unwindtbl(&ndx, cielength, data, off, 642 MSG_ORIG(MSG_UNW_CIECFI), 643 MSG_ORIG(MSG_UNW_CIEPRE), 644 MSG_UNW_CIEPRE_SIZE); 645 off += cielength + 4; 646 647 } else { 648 uint_t fdelength = length; 649 int fdecieptr = id; 650 uint64_t fdeinitloc, fdeaddrrange; 651 652 dbg_print(0, MSG_ORIG(MSG_UNW_FDE), 653 EC_XWORD(shdr->sh_addr + off)); 654 dbg_print(0, MSG_ORIG(MSG_UNW_FDELNGTH), 655 fdelength, fdecieptr); 656 657 fdeinitloc = dwarf_ehe_extract(&data[off], 658 &ndx, cieRflag, ehdr->e_ident, 659 shdr->sh_addr + off + ndx); 660 fdeaddrrange = dwarf_ehe_extract(&data[off], 661 &ndx, (cieRflag & ~DW_EH_PE_pcrel), 662 ehdr->e_ident, 663 shdr->sh_addr + off + ndx); 664 665 dbg_print(0, MSG_ORIG(MSG_UNW_FDEINITLOC), 666 EC_XWORD(fdeinitloc), 667 EC_XWORD(fdeaddrrange)); 668 669 if (cieaugstr[0]) 670 dbg_print(0, 671 MSG_ORIG(MSG_UNW_FDEAXVAL)); 672 if (cieZflag) { 673 uint64_t val; 674 val = uleb_extract(&data[off], &ndx); 675 dbg_print(0, 676 MSG_ORIG(MSG_UNW_FDEAXSIZE), 677 EC_XWORD(val)); 678 if (val & cieLflag) { 679 fdeinitloc = dwarf_ehe_extract( 680 &data[off], &ndx, cieLflag, 681 ehdr->e_ident, 682 shdr->sh_addr + off + ndx); 683 dbg_print(0, 684 MSG_ORIG(MSG_UNW_FDEAXLSDA), 685 EC_XWORD(val)); 686 } 687 } 688 if ((fdelength + 4) > ndx) 689 unwindtbl(&ndx, fdelength, data, off, 690 MSG_ORIG(MSG_UNW_FDECFI), 691 MSG_ORIG(MSG_UNW_FDEPRE), 692 MSG_UNW_FDEPRE_SIZE); 693 off += fdelength + 4; 694 } 695 } 696 } 697 } 698 699 /* 700 * Print the hardware/software capabilities. For executables and shared objects 701 * this should be accompanied with a program header. 702 */ 703 static void 704 cap(const char *file, Cache *cache, Word shnum, Word phnum, Ehdr *ehdr, 705 Elf *elf) 706 { 707 Word cnt; 708 Shdr *cshdr = 0; 709 Cache *ccache; 710 Off cphdr_off = 0; 711 Xword cphdr_sz; 712 713 /* 714 * Determine if a hardware/software capabilities header exists. 715 */ 716 if (phnum) { 717 Phdr *phdr; 718 719 if ((phdr = elf_getphdr(elf)) == NULL) { 720 failure(file, MSG_ORIG(MSG_ELF_GETPHDR)); 721 return; 722 } 723 724 for (cnt = 0; cnt < phnum; phdr++, cnt++) { 725 if (phdr->p_type == PT_SUNWCAP) { 726 cphdr_off = phdr->p_offset; 727 cphdr_sz = phdr->p_filesz; 728 break; 729 } 730 } 731 } 732 733 /* 734 * Determine if a hardware/software capabilities section exists. 735 */ 736 for (cnt = 1; cnt < shnum; cnt++) { 737 Cache *_cache = &cache[cnt]; 738 Shdr *shdr = _cache->c_shdr; 739 740 if (shdr->sh_type != SHT_SUNW_cap) 741 continue; 742 743 if (cphdr_off && ((cphdr_off < shdr->sh_offset) || 744 (cphdr_off + cphdr_sz) > (shdr->sh_offset + shdr->sh_size))) 745 continue; 746 747 if (_cache->c_data == NULL) 748 continue; 749 750 ccache = _cache; 751 cshdr = shdr; 752 break; 753 } 754 755 if ((cshdr == 0) && (cphdr_off == 0)) 756 return; 757 758 /* 759 * Print the hardware/software capabilities section. 760 */ 761 if (cshdr) { 762 Word ndx, capn; 763 Cap *cap = (Cap *)ccache->c_data->d_buf; 764 765 if ((cshdr->sh_entsize == 0) || (cshdr->sh_size == 0)) { 766 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 767 file, ccache->c_name); 768 return; 769 } 770 771 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 772 dbg_print(0, MSG_INTL(MSG_ELF_SCN_CAP), ccache->c_name); 773 774 Elf_cap_title(0); 775 776 capn = (Word)(cshdr->sh_size / cshdr->sh_entsize); 777 778 for (ndx = 0; ndx < capn; cap++, ndx++) { 779 if (cap->c_tag != CA_SUNW_NULL) 780 Elf_cap_entry(0, cap, ndx, ehdr->e_machine); 781 } 782 } else 783 (void) fprintf(stderr, MSG_INTL(MSG_WARN_INVCAP1), file); 784 785 /* 786 * If this object is an executable or shared object, then the 787 * hardware/software capabilities section should have an accompanying 788 * program header. 789 */ 790 if (cshdr && ((ehdr->e_type == ET_EXEC) || (ehdr->e_type == ET_DYN))) { 791 if (cphdr_off == 0) 792 (void) fprintf(stderr, MSG_INTL(MSG_WARN_INVCAP2), 793 file, ccache->c_name); 794 else if ((cphdr_off != cshdr->sh_offset) || 795 (cphdr_sz != cshdr->sh_size)) 796 (void) fprintf(stderr, MSG_INTL(MSG_WARN_INVCAP3), 797 file, ccache->c_name); 798 } 799 } 800 801 /* 802 * Print the interpretor. 803 */ 804 static void 805 interp(const char *file, Cache *cache, Word shnum, Word phnum, Elf *elf) 806 { 807 Word cnt; 808 Shdr *ishdr = 0; 809 Cache *icache; 810 Off iphdr_off = 0; 811 Xword iphdr_fsz; 812 813 /* 814 * Determine if an interp header exists. 815 */ 816 if (phnum) { 817 Phdr *phdr; 818 819 if ((phdr = getphdr(phnum, PT_INTERP, file, elf)) != 0) { 820 iphdr_off = phdr->p_offset; 821 iphdr_fsz = phdr->p_filesz; 822 } 823 } 824 825 if (iphdr_off == 0) 826 return; 827 828 /* 829 * Determine if an interp section exists. 830 */ 831 for (cnt = 1; cnt < shnum; cnt++) { 832 Cache *_cache = &cache[cnt]; 833 Shdr *shdr = _cache->c_shdr; 834 835 /* 836 * Scan sections to find a section which contains the PT_INTERP 837 * string. The target section can't be in a NOBITS section. 838 */ 839 if ((shdr->sh_type == SHT_NOBITS) || 840 (iphdr_off < shdr->sh_offset) || 841 (iphdr_off + iphdr_fsz) > (shdr->sh_offset + shdr->sh_size)) 842 continue; 843 844 icache = _cache; 845 ishdr = shdr; 846 break; 847 } 848 849 /* 850 * Print the interpreter string based on the offset defined in the 851 * program header, as this is the offset used by the kernel. 852 */ 853 if (ishdr && icache->c_data) { 854 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 855 dbg_print(0, MSG_INTL(MSG_ELF_SCN_INTERP), icache->c_name); 856 dbg_print(0, MSG_ORIG(MSG_FMT_INDENT), 857 (char *)icache->c_data->d_buf + 858 (iphdr_off - ishdr->sh_offset)); 859 } else 860 (void) fprintf(stderr, MSG_INTL(MSG_WARN_INVINTERP1), file); 861 862 /* 863 * If there are any inconsistences between the program header and 864 * section information, flag them. 865 */ 866 if (ishdr && ((iphdr_off != ishdr->sh_offset) || 867 (iphdr_fsz != ishdr->sh_size))) { 868 (void) fprintf(stderr, MSG_INTL(MSG_WARN_INVINTERP2), file, 869 icache->c_name); 870 } 871 } 872 873 /* 874 * Print the syminfo section. 875 */ 876 static void 877 syminfo(Cache *cache, Word shnum, const char *file) 878 { 879 Shdr *infoshdr; 880 Syminfo *info; 881 Sym *syms; 882 Dyn *dyns; 883 Word infonum, cnt, ndx, symnum; 884 Cache *infocache = 0, *symsec, *strsec; 885 886 for (cnt = 1; cnt < shnum; cnt++) { 887 if (cache[cnt].c_shdr->sh_type == SHT_SUNW_syminfo) { 888 infocache = &cache[cnt]; 889 break; 890 } 891 } 892 if (infocache == 0) 893 return; 894 895 infoshdr = infocache->c_shdr; 896 if ((infoshdr->sh_entsize == 0) || (infoshdr->sh_size == 0)) { 897 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 898 file, infocache->c_name); 899 return; 900 } 901 if (infocache->c_data == NULL) 902 return; 903 904 infonum = (Word)(infoshdr->sh_size / infoshdr->sh_entsize); 905 info = (Syminfo *)infocache->c_data->d_buf; 906 907 /* 908 * Get the data buffer of the associated dynamic section. 909 */ 910 if ((infoshdr->sh_info == 0) || (infoshdr->sh_info >= shnum)) { 911 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHINFO), 912 file, infocache->c_name, EC_WORD(infoshdr->sh_info)); 913 return; 914 } 915 if (cache[infoshdr->sh_info].c_data == NULL) 916 return; 917 918 dyns = cache[infoshdr->sh_info].c_data->d_buf; 919 if (dyns == 0) { 920 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 921 file, cache[infoshdr->sh_info].c_name); 922 return; 923 } 924 925 /* 926 * Get the data buffer for the associated symbol table and string table. 927 */ 928 if (stringtbl(cache, 1, cnt, shnum, file, 929 &symnum, &symsec, &strsec) == 0) 930 return; 931 932 syms = symsec->c_data->d_buf; 933 934 /* 935 * Loop through the syminfo entries. 936 */ 937 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 938 dbg_print(0, MSG_INTL(MSG_ELF_SCN_SYMINFO), infocache->c_name); 939 Elf_syminfo_title(0); 940 941 for (ndx = 1, info++; ndx < infonum; ndx++, info++) { 942 Sym *sym; 943 const char *needed = 0, *name; 944 945 if ((info->si_flags == 0) && (info->si_boundto == 0)) 946 continue; 947 948 sym = &syms[ndx]; 949 name = string(infocache, ndx, strsec, file, sym->st_name); 950 951 if (info->si_boundto < SYMINFO_BT_LOWRESERVE) { 952 Dyn *dyn = &dyns[info->si_boundto]; 953 954 needed = string(infocache, info->si_boundto, 955 strsec, file, dyn->d_un.d_val); 956 } 957 Elf_syminfo_entry(0, ndx, info, name, needed); 958 } 959 } 960 961 /* 962 * Print version definition section entries. 963 */ 964 static void 965 version_def(Verdef *vdf, Word vdf_num, Cache *vcache, Cache *scache, 966 const char *file) 967 { 968 Word cnt; 969 char index[MAXNDXSIZE]; 970 971 Elf_ver_def_title(0); 972 973 for (cnt = 1; cnt <= vdf_num; cnt++, 974 vdf = (Verdef *)((uintptr_t)vdf + vdf->vd_next)) { 975 const char *name, *dep; 976 Half vcnt = vdf->vd_cnt - 1; 977 Half ndx = vdf->vd_ndx; 978 Verdaux *vdap = (Verdaux *)((uintptr_t)vdf + vdf->vd_aux); 979 980 /* 981 * Obtain the name and first dependency (if any). 982 */ 983 name = string(vcache, cnt, scache, file, vdap->vda_name); 984 vdap = (Verdaux *)((uintptr_t)vdap + vdap->vda_next); 985 if (vcnt) 986 dep = string(vcache, cnt, scache, file, vdap->vda_name); 987 else 988 dep = MSG_ORIG(MSG_STR_EMPTY); 989 990 (void) snprintf(index, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), 991 EC_XWORD(ndx)); 992 Elf_ver_line_1(0, index, name, dep, 993 conv_ver_flags(vdf->vd_flags)); 994 995 /* 996 * Print any additional dependencies. 997 */ 998 if (vcnt) { 999 vdap = (Verdaux *)((uintptr_t)vdap + vdap->vda_next); 1000 for (vcnt--; vcnt; vcnt--, 1001 vdap = (Verdaux *)((uintptr_t)vdap + 1002 vdap->vda_next)) { 1003 dep = string(vcache, cnt, scache, file, 1004 vdap->vda_name); 1005 Elf_ver_line_2(0, MSG_ORIG(MSG_STR_EMPTY), dep); 1006 } 1007 } 1008 } 1009 } 1010 1011 /* 1012 * Print version needed section entries. 1013 * 1014 * entry: 1015 * vnd - Address of verneed data 1016 * vnd_num - # of Verneed entries 1017 * vcache - Cache of verneed section being processed 1018 * scache - Cache of associated string table section 1019 * file - Name of object being processed. 1020 * versym - Information about versym section 1021 * 1022 * exit: 1023 * The versions have been printed. If GNU style versioning 1024 * is in effect, versym->max_verndx has been updated to 1025 * contain the largest version index seen. 1026 */ 1027 static void 1028 version_need(Verneed *vnd, Word vnd_num, Cache *vcache, Cache *scache, 1029 const char *file, VERSYM_STATE *versym) 1030 { 1031 Word cnt; 1032 char index[MAXNDXSIZE]; 1033 const char *index_str; 1034 1035 Elf_ver_need_title(0, versym->gnu); 1036 1037 /* 1038 * The versym section in an object that follows Solaris versioning 1039 * rules contains indexes into the verdef section. Symbols defined 1040 * in other objects (UNDEF) are given a version of 0, indicating that 1041 * they are not defined by this file, and the Verneed entries do not 1042 * have associated version indexes. For these reasons, we do not 1043 * display a version index for Solaris Verneed sections. 1044 * 1045 * The GNU versioning rules are different: Symbols defined in other 1046 * objects receive a version index in the range above those defined 1047 * by the Verdef section, and the vna_other field of the Vernaux 1048 * structs inside the Verneed section contain the version index for 1049 * that item. We therefore display the index when showing the 1050 * contents of a GNU Verneed section. You should not expect these 1051 * indexes to appear in sorted order --- it seems that the GNU ld 1052 * assigns the versions as symbols are encountered during linking, 1053 * and then the results are assembled into the Verneed section 1054 * afterwards. 1055 */ 1056 if (versym->gnu) { 1057 index_str = index; 1058 } else { 1059 /* For Solaris versioning, display a NULL string */ 1060 index_str = MSG_ORIG(MSG_STR_EMPTY); 1061 } 1062 1063 for (cnt = 1; cnt <= vnd_num; cnt++, 1064 vnd = (Verneed *)((uintptr_t)vnd + vnd->vn_next)) { 1065 const char *name, *dep; 1066 Half vcnt = vnd->vn_cnt; 1067 Vernaux *vnap = (Vernaux *)((uintptr_t)vnd + vnd->vn_aux); 1068 1069 /* 1070 * Obtain the name of the needed file and the version name 1071 * within it that we're dependent on. Note that the count 1072 * should be at least one, otherwise this is a pretty bogus 1073 * entry. 1074 */ 1075 name = string(vcache, cnt, scache, file, vnd->vn_file); 1076 if (vcnt) 1077 dep = string(vcache, cnt, scache, file, vnap->vna_name); 1078 else 1079 dep = MSG_INTL(MSG_STR_NULL); 1080 1081 if (versym->gnu) { 1082 /* Format the version index value */ 1083 (void) snprintf(index, MAXNDXSIZE, 1084 MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(vnap->vna_other)); 1085 if (vnap->vna_other > versym->max_verndx) 1086 versym->max_verndx = vnap->vna_other; 1087 } 1088 Elf_ver_line_1(0, index_str, name, dep, 1089 conv_ver_flags(vnap->vna_flags)); 1090 1091 /* 1092 * Print any additional version dependencies. 1093 */ 1094 if (vcnt) { 1095 vnap = (Vernaux *)((uintptr_t)vnap + vnap->vna_next); 1096 for (vcnt--; vcnt; vcnt--, 1097 vnap = (Vernaux *)((uintptr_t)vnap + 1098 vnap->vna_next)) { 1099 dep = string(vcache, cnt, scache, file, 1100 vnap->vna_name); 1101 if (versym->gnu) { 1102 /* Format the next index value */ 1103 (void) snprintf(index, MAXNDXSIZE, 1104 MSG_ORIG(MSG_FMT_INDEX), 1105 EC_XWORD(vnap->vna_other)); 1106 Elf_ver_line_1(0, index_str, 1107 MSG_ORIG(MSG_STR_EMPTY), dep, 1108 conv_ver_flags(vnap->vna_flags)); 1109 if (vnap->vna_other > 1110 versym->max_verndx) 1111 versym->max_verndx = 1112 vnap->vna_other; 1113 } else { 1114 Elf_ver_line_3(0, 1115 MSG_ORIG(MSG_STR_EMPTY), dep, 1116 conv_ver_flags(vnap->vna_flags)); 1117 } 1118 } 1119 } 1120 } 1121 } 1122 1123 /* 1124 * Compute the max_verndx value for a GNU style object with 1125 * a Verneed section. This is only needed if version_need() is not 1126 * called. 1127 * 1128 * entry: 1129 * vnd - Address of verneed data 1130 * vnd_num - # of Verneed entries 1131 * versym - Information about versym section 1132 * 1133 * exit: 1134 * versym->max_verndx has been updated to contain the largest 1135 * version index seen. 1136 */ 1137 static void 1138 update_gnu_max_verndx(Verneed *vnd, Word vnd_num, VERSYM_STATE *versym) 1139 { 1140 Word cnt; 1141 1142 for (cnt = 1; cnt <= vnd_num; cnt++, 1143 vnd = (Verneed *)((uintptr_t)vnd + vnd->vn_next)) { 1144 Half vcnt = vnd->vn_cnt; 1145 Vernaux *vnap = (Vernaux *)((uintptr_t)vnd + vnd->vn_aux); 1146 1147 if (vnap->vna_other > versym->max_verndx) 1148 versym->max_verndx = vnap->vna_other; 1149 1150 /* 1151 * Check any additional version dependencies. 1152 */ 1153 if (vcnt) { 1154 vnap = (Vernaux *)((uintptr_t)vnap + vnap->vna_next); 1155 for (vcnt--; vcnt; vcnt--, 1156 vnap = (Vernaux *)((uintptr_t)vnap + 1157 vnap->vna_next)) { 1158 if (vnap->vna_other > versym->max_verndx) 1159 versym->max_verndx = vnap->vna_other; 1160 } 1161 } 1162 } 1163 } 1164 1165 /* 1166 * Display version section information if the flags require it. 1167 * Return version information needed by other output. 1168 * 1169 * entry: 1170 * cache - Cache of all section headers 1171 * shnum - # of sections in cache 1172 * file - Name of file 1173 * flags - Command line option flags 1174 * versym - VERSYM_STATE block to be filled in. 1175 */ 1176 static void 1177 versions(Cache *cache, Word shnum, const char *file, uint_t flags, 1178 VERSYM_STATE *versym) 1179 { 1180 GElf_Word cnt; 1181 Cache *verdef_cache = NULL, *verneed_cache = NULL; 1182 1183 1184 /* Gather information about the version sections */ 1185 bzero(versym, sizeof (*versym)); 1186 versym->max_verndx = 1; 1187 for (cnt = 1; cnt < shnum; cnt++) { 1188 Cache *_cache = &cache[cnt]; 1189 Shdr *shdr = _cache->c_shdr; 1190 Dyn *dyn; 1191 ulong_t numdyn; 1192 1193 switch (shdr->sh_type) { 1194 case SHT_DYNAMIC: 1195 /* 1196 * The GNU ld puts a DT_VERSYM entry in the dynamic 1197 * section so that the runtime linker can use it to 1198 * implement their versioning rules. They allow multiple 1199 * incompatible functions with the same name to exist 1200 * in different versions. The Solaris ld does not 1201 * support this mechanism, and as such, does not 1202 * produce DT_VERSYM. We use this fact to determine 1203 * which ld produced this object, and how to interpret 1204 * the version values. 1205 */ 1206 if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0) || 1207 (_cache->c_data == NULL)) 1208 continue; 1209 numdyn = shdr->sh_size / shdr->sh_entsize; 1210 dyn = (Dyn *)_cache->c_data->d_buf; 1211 for (; numdyn-- > 0; dyn++) 1212 if (dyn->d_tag == DT_VERSYM) { 1213 versym->gnu = 1; 1214 break; 1215 } 1216 break; 1217 1218 case SHT_SUNW_versym: 1219 /* Record data address for later symbol processing */ 1220 if (_cache->c_data != NULL) { 1221 versym->cache = _cache; 1222 versym->data = _cache->c_data->d_buf; 1223 continue; 1224 } 1225 break; 1226 1227 case SHT_SUNW_verdef: 1228 case SHT_SUNW_verneed: 1229 /* 1230 * Ensure the data is non-NULL and the number 1231 * of items is non-zero. Otherwise, we don't 1232 * understand the section, and will not use it. 1233 */ 1234 if ((_cache->c_data == NULL) || 1235 (_cache->c_data->d_buf == NULL)) { 1236 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 1237 file, _cache->c_name); 1238 continue; 1239 } 1240 if (shdr->sh_info == 0) { 1241 (void) fprintf(stderr, 1242 MSG_INTL(MSG_ERR_BADSHINFO), 1243 file, _cache->c_name, 1244 EC_WORD(shdr->sh_info)); 1245 continue; 1246 } 1247 1248 /* Make sure the string table index is in range */ 1249 if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { 1250 (void) fprintf(stderr, 1251 MSG_INTL(MSG_ERR_BADSHLINK), file, 1252 _cache->c_name, EC_WORD(shdr->sh_link)); 1253 continue; 1254 } 1255 1256 /* 1257 * The section is usable. Save the cache entry. 1258 */ 1259 if (shdr->sh_type == SHT_SUNW_verdef) { 1260 verdef_cache = _cache; 1261 /* 1262 * Under Solaris rules, if there is a verdef 1263 * section, the max versym index is number 1264 * of version definitions it supplies. 1265 */ 1266 versym->max_verndx = shdr->sh_info; 1267 } else { 1268 verneed_cache = _cache; 1269 } 1270 break; 1271 } 1272 } 1273 1274 if ((flags & FLG_VERSIONS) == 0) { 1275 /* 1276 * If GNU versioning applies to this object, and there 1277 * is a Verneed section, then examine it to determine 1278 * the maximum Versym version index for this file. 1279 */ 1280 if ((versym->gnu) && (verneed_cache != NULL)) 1281 update_gnu_max_verndx( 1282 (Verneed *)verneed_cache->c_data->d_buf, 1283 verneed_cache->c_shdr->sh_info, versym); 1284 return; 1285 } 1286 1287 /* 1288 * Now that all the information is available, display the 1289 * Verdef and Verneed section contents. 1290 */ 1291 if (verdef_cache != NULL) { 1292 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 1293 dbg_print(0, MSG_INTL(MSG_ELF_SCN_VERDEF), 1294 verdef_cache->c_name); 1295 version_def((Verdef *)verdef_cache->c_data->d_buf, 1296 verdef_cache->c_shdr->sh_info, verdef_cache, 1297 &cache[verdef_cache->c_shdr->sh_link], file); 1298 } 1299 if (verneed_cache != NULL) { 1300 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 1301 dbg_print(0, MSG_INTL(MSG_ELF_SCN_VERNEED), 1302 verneed_cache->c_name); 1303 /* 1304 * If GNU versioning applies to this object, version_need() 1305 * will update versym->max_verndx, and it is not 1306 * necessary to call update_gnu_max_verndx(). 1307 */ 1308 version_need((Verneed *)verneed_cache->c_data->d_buf, 1309 verneed_cache->c_shdr->sh_info, verneed_cache, 1310 &cache[verneed_cache->c_shdr->sh_link], file, versym); 1311 } 1312 } 1313 1314 /* 1315 * Initialize a symbol table state structure 1316 * 1317 * entry: 1318 * state - State structure to be initialized 1319 * cache - Cache of all section headers 1320 * shnum - # of sections in cache 1321 * secndx - Index of symbol table section 1322 * ehdr - ELF header for file 1323 * versym - Information about versym section 1324 * file - Name of file 1325 * flags - Command line option flags 1326 */ 1327 static int 1328 init_symtbl_state(SYMTBL_STATE *state, Cache *cache, Word shnum, Word secndx, 1329 Ehdr *ehdr, VERSYM_STATE *versym, const char *file, uint_t flags) 1330 { 1331 Shdr *shdr; 1332 1333 state->file = file; 1334 state->ehdr = ehdr; 1335 state->cache = cache; 1336 state->shnum = shnum; 1337 state->seccache = &cache[secndx]; 1338 state->secndx = secndx; 1339 state->secname = state->seccache->c_name; 1340 state->flags = flags; 1341 state->shxndx.checked = 0; 1342 state->shxndx.data = NULL; 1343 state->shxndx.n = 0; 1344 1345 shdr = state->seccache->c_shdr; 1346 1347 /* 1348 * Check the symbol data and per-item size. 1349 */ 1350 if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { 1351 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 1352 file, state->secname); 1353 return (0); 1354 } 1355 if (state->seccache->c_data == NULL) 1356 return (0); 1357 1358 /* LINTED */ 1359 state->symn = (Word)(shdr->sh_size / shdr->sh_entsize); 1360 state->sym = (Sym *)state->seccache->c_data->d_buf; 1361 1362 /* 1363 * Check associated string table section. 1364 */ 1365 if ((shdr->sh_link == 0) || (shdr->sh_link >= shnum)) { 1366 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), 1367 file, state->secname, EC_WORD(shdr->sh_link)); 1368 return (0); 1369 } 1370 1371 /* 1372 * Determine if there is a associated Versym section 1373 * with this Symbol Table. 1374 */ 1375 if (versym->cache && 1376 (versym->cache->c_shdr->sh_link == state->secndx)) 1377 state->versym = versym; 1378 else 1379 state->versym = NULL; 1380 1381 1382 return (1); 1383 } 1384 1385 /* 1386 * Determine the extended section index used for symbol tables entries. 1387 */ 1388 static void 1389 symbols_getxindex(SYMTBL_STATE * state) 1390 { 1391 uint_t symn; 1392 Word symcnt; 1393 1394 state->shxndx.checked = 1; /* Note that we've been called */ 1395 for (symcnt = 1; symcnt < state->shnum; symcnt++) { 1396 Cache *_cache = &state->cache[symcnt]; 1397 Shdr *shdr = _cache->c_shdr; 1398 1399 if ((shdr->sh_type != SHT_SYMTAB_SHNDX) || 1400 (shdr->sh_link != state->secndx)) 1401 continue; 1402 1403 if ((shdr->sh_entsize) && 1404 /* LINTED */ 1405 ((symn = (uint_t)(shdr->sh_size / shdr->sh_entsize)) == 0)) 1406 continue; 1407 1408 if (_cache->c_data == NULL) 1409 continue; 1410 1411 state->shxndx.data = _cache->c_data->d_buf; 1412 state->shxndx.n = symn; 1413 return; 1414 } 1415 } 1416 1417 /* 1418 * Produce a line of output for the given symbol 1419 * 1420 * entry: 1421 * state - Symbol table state 1422 * symndx - Index of symbol within the table 1423 * info - Value of st_info (indicates local/global range) 1424 * symndx_disp - Index to display. This may not be the same 1425 * as symndx if the display is relative to the logical 1426 * combination of the SUNW_ldynsym/dynsym tables. 1427 * sym - Symbol to display 1428 */ 1429 static void 1430 output_symbol(SYMTBL_STATE *state, Word symndx, Word info, Word disp_symndx, 1431 Sym *sym) 1432 { 1433 /* 1434 * Symbol types for which we check that the specified 1435 * address/size land inside the target section. 1436 */ 1437 static const int addr_symtype[STT_NUM] = { 1438 0, /* STT_NOTYPE */ 1439 1, /* STT_OBJECT */ 1440 1, /* STT_FUNC */ 1441 0, /* STT_SECTION */ 1442 0, /* STT_FILE */ 1443 1, /* STT_COMMON */ 1444 0, /* STT_TLS */ 1445 }; 1446 #if STT_NUM != (STT_TLS + 1) 1447 #error "STT_NUM has grown. Update addr_symtype[]" 1448 #endif 1449 1450 char index[MAXNDXSIZE]; 1451 const char *symname, *sec; 1452 Versym verndx; 1453 int gnuver; 1454 uchar_t type; 1455 Shdr *tshdr; 1456 Word shndx; 1457 Conv_inv_buf_t inv_buf; 1458 1459 /* Ensure symbol index is in range */ 1460 if (symndx >= state->symn) { 1461 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSORTNDX), 1462 state->file, state->secname, EC_WORD(symndx)); 1463 return; 1464 } 1465 1466 /* 1467 * If we are using extended symbol indexes, find the 1468 * corresponding SHN_SYMTAB_SHNDX table. 1469 */ 1470 if ((sym->st_shndx == SHN_XINDEX) && (state->shxndx.checked == 0)) 1471 symbols_getxindex(state); 1472 1473 /* LINTED */ 1474 symname = string(state->seccache, symndx, 1475 &state->cache[state->seccache->c_shdr->sh_link], state->file, 1476 sym->st_name); 1477 1478 tshdr = 0; 1479 sec = NULL; 1480 1481 if (state->ehdr->e_type == ET_CORE) { 1482 sec = (char *)MSG_INTL(MSG_STR_UNKNOWN); 1483 } else if (state->flags & FLG_FAKESHDR) { 1484 /* 1485 * If we are using fake section headers derived from 1486 * the program headers, then the section indexes 1487 * in the symbols do not correspond to these headers. 1488 * The section names are not available, so all we can 1489 * do is to display them in numeric form. 1490 */ 1491 sec = conv_sym_shndx(sym->st_shndx, &inv_buf); 1492 } else if ((sym->st_shndx < SHN_LORESERVE) && 1493 (sym->st_shndx < state->shnum)) { 1494 shndx = sym->st_shndx; 1495 tshdr = state->cache[shndx].c_shdr; 1496 sec = state->cache[shndx].c_name; 1497 } else if (sym->st_shndx == SHN_XINDEX) { 1498 if (state->shxndx.data) { 1499 Word _shxndx; 1500 1501 if (symndx > state->shxndx.n) { 1502 (void) fprintf(stderr, 1503 MSG_INTL(MSG_ERR_BADSYMXINDEX1), 1504 state->file, state->secname, 1505 EC_WORD(symndx)); 1506 } else if ((_shxndx = 1507 state->shxndx.data[symndx]) > state->shnum) { 1508 (void) fprintf(stderr, 1509 MSG_INTL(MSG_ERR_BADSYMXINDEX2), 1510 state->file, state->secname, 1511 EC_WORD(symndx), EC_WORD(_shxndx)); 1512 } else { 1513 shndx = _shxndx; 1514 tshdr = state->cache[shndx].c_shdr; 1515 sec = state->cache[shndx].c_name; 1516 } 1517 } else { 1518 (void) fprintf(stderr, 1519 MSG_INTL(MSG_ERR_BADSYMXINDEX3), 1520 state->file, state->secname, EC_WORD(symndx)); 1521 } 1522 } else if ((sym->st_shndx < SHN_LORESERVE) && 1523 (sym->st_shndx >= state->shnum)) { 1524 (void) fprintf(stderr, 1525 MSG_INTL(MSG_ERR_BADSYM5), state->file, 1526 state->secname, demangle(symname, state->flags), 1527 sym->st_shndx); 1528 } 1529 1530 /* 1531 * If versioning is available display the 1532 * version index. If not, then use 0. 1533 */ 1534 if (state->versym) { 1535 Versym test_verndx; 1536 1537 verndx = test_verndx = state->versym->data[symndx]; 1538 gnuver = state->versym->gnu; 1539 1540 /* 1541 * Check to see if this is a defined symbol with a 1542 * version index that is outside the valid range for 1543 * the file. The interpretation of this depends on 1544 * the style of versioning used by the object. 1545 * 1546 * Versions >= VER_NDX_LORESERVE have special meanings, 1547 * and are exempt from this checking. 1548 * 1549 * GNU style version indexes use the top bit of the 1550 * 16-bit index value (0x8000) as the "hidden bit". 1551 * We must mask off this bit in order to compare 1552 * the version against the maximum value. 1553 */ 1554 if (gnuver) 1555 test_verndx &= ~0x8000; 1556 1557 if ((test_verndx > state->versym->max_verndx) && 1558 (verndx < VER_NDX_LORESERVE)) 1559 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADVER), 1560 state->file, state->secname, EC_WORD(symndx), 1561 EC_HALF(test_verndx), state->versym->max_verndx); 1562 } else { 1563 verndx = 0; 1564 gnuver = 0; 1565 } 1566 1567 /* 1568 * Error checking for TLS. 1569 */ 1570 type = ELF_ST_TYPE(sym->st_info); 1571 if (type == STT_TLS) { 1572 if (tshdr && 1573 (sym->st_shndx != SHN_UNDEF) && 1574 ((tshdr->sh_flags & SHF_TLS) == 0)) { 1575 (void) fprintf(stderr, 1576 MSG_INTL(MSG_ERR_BADSYM3), state->file, 1577 state->secname, demangle(symname, state->flags)); 1578 } 1579 } else if ((type != STT_SECTION) && sym->st_size && 1580 tshdr && (tshdr->sh_flags & SHF_TLS)) { 1581 (void) fprintf(stderr, 1582 MSG_INTL(MSG_ERR_BADSYM4), state->file, 1583 state->secname, demangle(symname, state->flags)); 1584 } 1585 1586 /* 1587 * If a symbol with non-zero size has a type that 1588 * specifies an address, then make sure the location 1589 * it references is actually contained within the 1590 * section. UNDEF symbols don't count in this case, 1591 * so we ignore them. 1592 * 1593 * The meaning of the st_value field in a symbol 1594 * depends on the type of object. For a relocatable 1595 * object, it is the offset within the section. 1596 * For sharable objects, it is the offset relative to 1597 * the base of the object, and for other types, it is 1598 * the virtual address. To get an offset within the 1599 * section for non-ET_REL files, we subtract the 1600 * base address of the section. 1601 */ 1602 if (addr_symtype[type] && (sym->st_size > 0) && 1603 (sym->st_shndx != SHN_UNDEF) && ((sym->st_shndx < SHN_LORESERVE) || 1604 (sym->st_shndx == SHN_XINDEX)) && (tshdr != NULL)) { 1605 Word v = sym->st_value; 1606 if (state->ehdr->e_type != ET_REL) 1607 v -= tshdr->sh_addr; 1608 if (((v + sym->st_size) > tshdr->sh_size)) { 1609 (void) fprintf(stderr, 1610 MSG_INTL(MSG_ERR_BADSYM6), state->file, 1611 state->secname, demangle(symname, state->flags), 1612 EC_WORD(shndx), EC_XWORD(tshdr->sh_size), 1613 EC_XWORD(sym->st_value), EC_XWORD(sym->st_size)); 1614 } 1615 } 1616 1617 /* 1618 * A typical symbol table uses the sh_info field to indicate one greater 1619 * than the symbol table index of the last local symbol, STB_LOCAL. 1620 * Therefore, symbol indexes less than sh_info should have local 1621 * binding. Symbol indexes greater than, or equal to sh_info, should 1622 * have global binding. Note, we exclude UNDEF/NOTY symbols with zero 1623 * value and size, as these symbols may be the result of an mcs(1) 1624 * section deletion. 1625 */ 1626 if (info) { 1627 uchar_t bind = ELF_ST_BIND(sym->st_info); 1628 1629 if ((symndx < info) && (bind != STB_LOCAL)) { 1630 (void) fprintf(stderr, 1631 MSG_INTL(MSG_ERR_BADSYM7), state->file, 1632 state->secname, demangle(symname, state->flags), 1633 EC_XWORD(info)); 1634 1635 } else if ((symndx >= info) && (bind == STB_LOCAL) && 1636 ((sym->st_shndx != SHN_UNDEF) || 1637 (ELF_ST_TYPE(sym->st_info) != STT_NOTYPE) || 1638 (sym->st_size != 0) || (sym->st_value != 0))) { 1639 (void) fprintf(stderr, 1640 MSG_INTL(MSG_ERR_BADSYM8), state->file, 1641 state->secname, demangle(symname, state->flags), 1642 EC_XWORD(info)); 1643 } 1644 } 1645 1646 (void) snprintf(index, MAXNDXSIZE, 1647 MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(disp_symndx)); 1648 Elf_syms_table_entry(0, ELF_DBG_ELFDUMP, index, 1649 state->ehdr->e_machine, sym, verndx, gnuver, sec, symname); 1650 } 1651 1652 /* 1653 * Search for and process any symbol tables. 1654 */ 1655 void 1656 symbols(Cache *cache, Word shnum, Ehdr *ehdr, VERSYM_STATE *versym, 1657 const char *file, uint_t flags) 1658 { 1659 SYMTBL_STATE state; 1660 Cache *_cache; 1661 Word secndx; 1662 1663 for (secndx = 1; secndx < shnum; secndx++) { 1664 Word symcnt; 1665 Shdr *shdr; 1666 1667 _cache = &cache[secndx]; 1668 shdr = _cache->c_shdr; 1669 1670 if ((shdr->sh_type != SHT_SYMTAB) && 1671 (shdr->sh_type != SHT_DYNSYM) && 1672 (shdr->sh_type != SHT_SUNW_LDYNSYM)) 1673 continue; 1674 if (!match(0, _cache->c_name, secndx)) 1675 continue; 1676 1677 if (!init_symtbl_state(&state, cache, shnum, secndx, ehdr, 1678 versym, file, flags)) 1679 continue; 1680 /* 1681 * Loop through the symbol tables entries. 1682 */ 1683 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 1684 dbg_print(0, MSG_INTL(MSG_ELF_SCN_SYMTAB), state.secname); 1685 Elf_syms_table_title(0, ELF_DBG_ELFDUMP); 1686 1687 for (symcnt = 0; symcnt < state.symn; symcnt++) 1688 output_symbol(&state, symcnt, shdr->sh_info, symcnt, 1689 state.sym + symcnt); 1690 } 1691 } 1692 1693 /* 1694 * Search for and process any SHT_SUNW_symsort or SHT_SUNW_tlssort sections. 1695 * These sections are always associated with the .SUNW_ldynsym./.dynsym pair. 1696 */ 1697 static void 1698 sunw_sort(Cache *cache, Word shnum, Ehdr *ehdr, VERSYM_STATE *versym, 1699 const char *file, uint_t flags) 1700 { 1701 SYMTBL_STATE ldynsym_state, dynsym_state; 1702 Cache *sortcache, *symcache; 1703 Shdr *sortshdr, *symshdr; 1704 Word sortsecndx, symsecndx; 1705 Word ldynsym_cnt; 1706 Word *ndx; 1707 Word ndxn; 1708 int output_cnt = 0; 1709 Conv_inv_buf_t inv_buf; 1710 1711 for (sortsecndx = 1; sortsecndx < shnum; sortsecndx++) { 1712 1713 sortcache = &cache[sortsecndx]; 1714 sortshdr = sortcache->c_shdr; 1715 1716 if ((sortshdr->sh_type != SHT_SUNW_symsort) && 1717 (sortshdr->sh_type != SHT_SUNW_tlssort)) 1718 continue; 1719 if (!match(0, sortcache->c_name, sortsecndx)) 1720 continue; 1721 1722 /* 1723 * If the section references a SUNW_ldynsym, then we 1724 * expect to see the associated .dynsym immediately 1725 * following. If it references a .dynsym, there is no 1726 * SUNW_ldynsym. If it is any other type, then we don't 1727 * know what to do with it. 1728 */ 1729 if ((sortshdr->sh_link == 0) || (sortshdr->sh_link >= shnum)) { 1730 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), 1731 file, sortcache->c_name, 1732 EC_WORD(sortshdr->sh_link)); 1733 continue; 1734 } 1735 symcache = &cache[sortshdr->sh_link]; 1736 symshdr = symcache->c_shdr; 1737 symsecndx = sortshdr->sh_link; 1738 ldynsym_cnt = 0; 1739 switch (symshdr->sh_type) { 1740 case SHT_SUNW_LDYNSYM: 1741 if (!init_symtbl_state(&ldynsym_state, cache, shnum, 1742 symsecndx, ehdr, versym, file, flags)) 1743 continue; 1744 ldynsym_cnt = ldynsym_state.symn; 1745 /* 1746 * We know that the dynsym follows immediately 1747 * after the SUNW_ldynsym, and so, should be at 1748 * (sortshdr->sh_link + 1). However, elfdump is a 1749 * diagnostic tool, so we do the full paranoid 1750 * search instead. 1751 */ 1752 for (symsecndx = 1; symsecndx < shnum; symsecndx++) { 1753 symcache = &cache[symsecndx]; 1754 symshdr = symcache->c_shdr; 1755 if (symshdr->sh_type == SHT_DYNSYM) 1756 break; 1757 } 1758 if (symsecndx >= shnum) { /* Dynsym not found! */ 1759 (void) fprintf(stderr, 1760 MSG_INTL(MSG_ERR_NODYNSYM), 1761 file, sortcache->c_name); 1762 continue; 1763 } 1764 /* Fallthrough to process associated dynsym */ 1765 /*FALLTHROUGH*/ 1766 case SHT_DYNSYM: 1767 if (!init_symtbl_state(&dynsym_state, cache, shnum, 1768 symsecndx, ehdr, versym, file, flags)) 1769 continue; 1770 break; 1771 default: 1772 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADNDXSEC), 1773 file, sortcache->c_name, conv_sec_type( 1774 ehdr->e_machine, symshdr->sh_type, 0, &inv_buf)); 1775 continue; 1776 } 1777 1778 /* 1779 * Output header 1780 */ 1781 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 1782 if (ldynsym_cnt > 0) { 1783 dbg_print(0, MSG_INTL(MSG_ELF_SCN_SYMSORT2), 1784 sortcache->c_name, ldynsym_state.secname, 1785 dynsym_state.secname); 1786 /* 1787 * The data for .SUNW_ldynsym and dynsym sections 1788 * is supposed to be adjacent with SUNW_ldynsym coming 1789 * first. Check, and issue a warning if it isn't so. 1790 */ 1791 if (((ldynsym_state.sym + ldynsym_state.symn) 1792 != dynsym_state.sym) && 1793 ((flags & FLG_FAKESHDR) == 0)) 1794 (void) fprintf(stderr, 1795 MSG_INTL(MSG_ERR_LDYNNOTADJ), file, 1796 ldynsym_state.secname, 1797 dynsym_state.secname); 1798 } else { 1799 dbg_print(0, MSG_INTL(MSG_ELF_SCN_SYMSORT1), 1800 sortcache->c_name, dynsym_state.secname); 1801 } 1802 Elf_syms_table_title(0, ELF_DBG_ELFDUMP); 1803 1804 /* If not first one, insert a line of whitespace */ 1805 if (output_cnt++ > 0) 1806 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 1807 1808 /* 1809 * SUNW_dynsymsort and SUNW_dyntlssort are arrays of 1810 * symbol indices. Iterate over the array entries, 1811 * dispaying the referenced symbols. 1812 */ 1813 ndxn = sortshdr->sh_size / sortshdr->sh_entsize; 1814 ndx = (Word *)sortcache->c_data->d_buf; 1815 for (; ndxn-- > 0; ndx++) { 1816 if (*ndx >= ldynsym_cnt) { 1817 Word sec_ndx = *ndx - ldynsym_cnt; 1818 1819 output_symbol(&dynsym_state, sec_ndx, 0, 1820 *ndx, dynsym_state.sym + sec_ndx); 1821 } else { 1822 output_symbol(&ldynsym_state, *ndx, 0, 1823 *ndx, ldynsym_state.sym + *ndx); 1824 } 1825 } 1826 } 1827 } 1828 1829 /* 1830 * Search for and process any relocation sections. 1831 */ 1832 static void 1833 reloc(Cache *cache, Word shnum, Ehdr *ehdr, const char *file, 1834 uint_t flags) 1835 { 1836 Word cnt; 1837 1838 for (cnt = 1; cnt < shnum; cnt++) { 1839 Word type, symnum; 1840 Xword relndx, relnum, relsize; 1841 void *rels; 1842 Sym *syms; 1843 Cache *symsec, *strsec; 1844 Cache *_cache = &cache[cnt]; 1845 Shdr *shdr = _cache->c_shdr; 1846 char *relname = _cache->c_name; 1847 Conv_inv_buf_t inv_buf; 1848 1849 if (((type = shdr->sh_type) != SHT_RELA) && 1850 (type != SHT_REL)) 1851 continue; 1852 if (!match(0, relname, cnt)) 1853 continue; 1854 1855 /* 1856 * Decide entry size. 1857 */ 1858 if (((relsize = shdr->sh_entsize) == 0) || 1859 (relsize > shdr->sh_size)) { 1860 if (type == SHT_RELA) 1861 relsize = sizeof (Rela); 1862 else 1863 relsize = sizeof (Rel); 1864 } 1865 1866 /* 1867 * Determine the number of relocations available. 1868 */ 1869 if (shdr->sh_size == 0) { 1870 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 1871 file, relname); 1872 continue; 1873 } 1874 if (_cache->c_data == NULL) 1875 continue; 1876 1877 rels = _cache->c_data->d_buf; 1878 relnum = shdr->sh_size / relsize; 1879 1880 /* 1881 * Get the data buffer for the associated symbol table and 1882 * string table. 1883 */ 1884 if (stringtbl(cache, 1, cnt, shnum, file, 1885 &symnum, &symsec, &strsec) == 0) 1886 continue; 1887 1888 syms = symsec->c_data->d_buf; 1889 1890 /* 1891 * Loop through the relocation entries. 1892 */ 1893 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 1894 dbg_print(0, MSG_INTL(MSG_ELF_SCN_RELOC), _cache->c_name); 1895 Elf_reloc_title(0, ELF_DBG_ELFDUMP, type); 1896 1897 for (relndx = 0; relndx < relnum; relndx++, 1898 rels = (void *)((char *)rels + relsize)) { 1899 char section[BUFSIZ]; 1900 const char *symname; 1901 Word symndx, reltype; 1902 Rela *rela; 1903 Rel *rel; 1904 1905 /* 1906 * Unravel the relocation and determine the symbol with 1907 * which this relocation is associated. 1908 */ 1909 if (type == SHT_RELA) { 1910 rela = (Rela *)rels; 1911 symndx = ELF_R_SYM(rela->r_info); 1912 reltype = ELF_R_TYPE(rela->r_info); 1913 } else { 1914 rel = (Rel *)rels; 1915 symndx = ELF_R_SYM(rel->r_info); 1916 reltype = ELF_R_TYPE(rel->r_info); 1917 } 1918 1919 symname = relsymname(cache, _cache, strsec, symndx, 1920 symnum, relndx, syms, section, BUFSIZ, file, 1921 flags); 1922 1923 /* 1924 * A zero symbol index is only valid for a few 1925 * relocations. 1926 */ 1927 if (symndx == 0) { 1928 Half mach = ehdr->e_machine; 1929 int badrel = 0; 1930 1931 if ((mach == EM_SPARC) || 1932 (mach == EM_SPARC32PLUS) || 1933 (mach == EM_SPARCV9)) { 1934 if ((reltype != R_SPARC_NONE) && 1935 (reltype != R_SPARC_REGISTER) && 1936 (reltype != R_SPARC_RELATIVE)) 1937 badrel++; 1938 } else if (mach == EM_386) { 1939 if ((reltype != R_386_NONE) && 1940 (reltype != R_386_RELATIVE)) 1941 badrel++; 1942 } else if (mach == EM_AMD64) { 1943 if ((reltype != R_AMD64_NONE) && 1944 (reltype != R_AMD64_RELATIVE)) 1945 badrel++; 1946 } 1947 1948 if (badrel) { 1949 (void) fprintf(stderr, 1950 MSG_INTL(MSG_ERR_BADREL1), file, 1951 conv_reloc_type(mach, reltype, 1952 0, &inv_buf)); 1953 } 1954 } 1955 1956 Elf_reloc_entry_1(0, ELF_DBG_ELFDUMP, 1957 MSG_ORIG(MSG_STR_EMPTY), ehdr->e_machine, type, 1958 rels, relname, symname, 0); 1959 } 1960 } 1961 } 1962 1963 1964 /* 1965 * This value controls which test dyn_test() performs. 1966 */ 1967 typedef enum { DYN_TEST_ADDR, DYN_TEST_SIZE, DYN_TEST_ENTSIZE } dyn_test_t; 1968 1969 /* 1970 * Used by dynamic() to compare the value of a dynamic element against 1971 * the starting address of the section it references. 1972 * 1973 * entry: 1974 * test_type - Specify which dyn item is being tested. 1975 * sh_type - SHT_* type value for required section. 1976 * sec_cache - Cache entry for section, or NULL if the object lacks 1977 * a section of this type. 1978 * dyn - Dyn entry to be tested 1979 * dynsec_cnt - # of dynamic section being examined. The first 1980 * dynamic section is 1, the next is 2, and so on... 1981 * ehdr - ELF header for file 1982 * file - Name of file 1983 */ 1984 static void 1985 dyn_test(dyn_test_t test_type, Word sh_type, Cache *sec_cache, Dyn *dyn, 1986 Word dynsec_cnt, Ehdr *ehdr, const char *file) 1987 { 1988 Conv_inv_buf_t buf1, buf2; 1989 1990 /* 1991 * These tests are based around the implicit assumption that 1992 * there is only one dynamic section in an object, and also only 1993 * one of the sections it references. We have therefore gathered 1994 * all of the necessary information to test this in a single pass 1995 * over the section headers, which is very efficient. We are not 1996 * aware of any case where more than one dynamic section would 1997 * be meaningful in an ELF object, so this is a reasonable solution. 1998 * 1999 * To test multiple dynamic sections correctly would be more 2000 * expensive in code and time. We would have to build a data structure 2001 * containing all the dynamic elements. Then, we would use the address 2002 * to locate the section it references and ensure the section is of 2003 * the right type and that the address in the dynamic element is 2004 * to the start of the section. Then, we could check the size and 2005 * entsize values against those same sections. This is O(n^2), and 2006 * also complicated. 2007 * 2008 * In the highly unlikely case that there is more than one dynamic 2009 * section, we only test the first one, and simply allow the values 2010 * of the subsequent one to be displayed unchallenged. 2011 */ 2012 if (dynsec_cnt != 1) 2013 return; 2014 2015 /* 2016 * A DT_ item that references a section address should always find 2017 * the section in the file. 2018 */ 2019 if (sec_cache == NULL) { 2020 (void) fprintf(stderr, MSG_INTL(MSG_ERR_DYNNOBCKSEC), file, 2021 conv_sec_type(ehdr->e_machine, sh_type, 0, &buf1), 2022 conv_dyn_tag(dyn->d_tag, ehdr->e_machine, 0, &buf2)); 2023 return; 2024 } 2025 2026 2027 switch (test_type) { 2028 case DYN_TEST_ADDR: 2029 /* The section address should match the DT_ item value */ 2030 if (dyn->d_un.d_val != sec_cache->c_shdr->sh_addr) 2031 (void) fprintf(stderr, 2032 MSG_INTL(MSG_ERR_DYNBADADDR), file, 2033 conv_dyn_tag(dyn->d_tag, ehdr->e_machine, 0, &buf1), 2034 EC_ADDR(dyn->d_un.d_val), sec_cache->c_ndx, 2035 sec_cache->c_name, 2036 EC_ADDR(sec_cache->c_shdr->sh_addr)); 2037 break; 2038 2039 case DYN_TEST_SIZE: 2040 /* The section size should match the DT_ item value */ 2041 if (dyn->d_un.d_val != sec_cache->c_shdr->sh_size) 2042 (void) fprintf(stderr, 2043 MSG_INTL(MSG_ERR_DYNBADSIZE), file, 2044 conv_dyn_tag(dyn->d_tag, ehdr->e_machine, 0, &buf1), 2045 EC_XWORD(dyn->d_un.d_val), 2046 sec_cache->c_ndx, sec_cache->c_name, 2047 EC_XWORD(sec_cache->c_shdr->sh_size)); 2048 break; 2049 2050 case DYN_TEST_ENTSIZE: 2051 /* The sh_entsize value should match the DT_ item value */ 2052 if (dyn->d_un.d_val != sec_cache->c_shdr->sh_entsize) 2053 (void) fprintf(stderr, 2054 MSG_INTL(MSG_ERR_DYNBADENTSIZE), file, 2055 conv_dyn_tag(dyn->d_tag, ehdr->e_machine, 0, &buf1), 2056 EC_XWORD(dyn->d_un.d_val), 2057 sec_cache->c_ndx, sec_cache->c_name, 2058 EC_XWORD(sec_cache->c_shdr->sh_entsize)); 2059 break; 2060 } 2061 } 2062 2063 2064 /* 2065 * Search for and process a .dynamic section. 2066 */ 2067 static void 2068 dynamic(Cache *cache, Word shnum, Ehdr *ehdr, const char *file) 2069 { 2070 struct { 2071 Cache *dynstr; 2072 Cache *dynsym; 2073 Cache *hash; 2074 Cache *fini; 2075 Cache *fini_array; 2076 Cache *init; 2077 Cache *init_array; 2078 Cache *preinit_array; 2079 Cache *rel; 2080 Cache *rela; 2081 Cache *sunw_cap; 2082 Cache *sunw_ldynsym; 2083 Cache *sunw_move; 2084 Cache *sunw_syminfo; 2085 Cache *sunw_symsort; 2086 Cache *sunw_tlssort; 2087 Cache *sunw_verdef; 2088 Cache *sunw_verneed; 2089 Cache *sunw_versym; 2090 } sec; 2091 Word dynsec_ndx; 2092 Word dynsec_num; 2093 int dynsec_cnt; 2094 Word cnt; 2095 2096 /* 2097 * Make a pass over all the sections, gathering section information 2098 * we'll need below. 2099 */ 2100 dynsec_num = 0; 2101 bzero(&sec, sizeof (sec)); 2102 for (cnt = 1; cnt < shnum; cnt++) { 2103 Cache *_cache = &cache[cnt]; 2104 2105 switch (_cache->c_shdr->sh_type) { 2106 case SHT_DYNAMIC: 2107 if (dynsec_num == 0) { 2108 dynsec_ndx = cnt; 2109 2110 /* Does it have a valid string table? */ 2111 (void) stringtbl(cache, 0, cnt, shnum, file, 2112 0, 0, &sec.dynstr); 2113 } 2114 dynsec_num++; 2115 break; 2116 2117 2118 case SHT_PROGBITS: 2119 /* 2120 * We want to detect the .init and .fini sections, 2121 * if present. These are SHT_PROGBITS, so all we 2122 * have to go on is the section name. Normally comparing 2123 * names is a bad idea, but there are some special 2124 * names (i.e. .init/.fini/.interp) that are very 2125 * difficult to use in any other context, and for 2126 * these symbols, we do the heuristic match. 2127 */ 2128 if (strcmp(_cache->c_name, 2129 MSG_ORIG(MSG_ELF_INIT)) == 0) { 2130 if (sec.init == NULL) 2131 sec.init = _cache; 2132 } else if (strcmp(_cache->c_name, 2133 MSG_ORIG(MSG_ELF_FINI)) == 0) { 2134 if (sec.fini == NULL) 2135 sec.fini = _cache; 2136 } 2137 break; 2138 2139 case SHT_REL: 2140 /* 2141 * We want the SHT_REL section with the lowest 2142 * offset. The linker gathers them together, 2143 * and puts the address of the first one 2144 * into the DT_REL dynamic element. 2145 */ 2146 if ((sec.rel == NULL) || 2147 (_cache->c_shdr->sh_offset < 2148 sec.rel->c_shdr->sh_offset)) 2149 sec.rel = _cache; 2150 break; 2151 2152 case SHT_RELA: 2153 /* RELA is handled just like RELA above */ 2154 if ((sec.rela == NULL) || 2155 (_cache->c_shdr->sh_offset < 2156 sec.rela->c_shdr->sh_offset)) 2157 sec.rela = _cache; 2158 break; 2159 2160 /* 2161 * The GRAB macro is used for the simple case in which 2162 * we simply grab the first section of the desired type. 2163 */ 2164 #define GRAB(_sec_type, _sec_field) \ 2165 case _sec_type: \ 2166 if (sec._sec_field == NULL) \ 2167 sec._sec_field = _cache; \ 2168 break 2169 GRAB(SHT_DYNSYM, dynsym); 2170 GRAB(SHT_FINI_ARRAY, fini_array); 2171 GRAB(SHT_HASH, hash); 2172 GRAB(SHT_INIT_ARRAY, init_array); 2173 GRAB(SHT_SUNW_move, sunw_move); 2174 GRAB(SHT_PREINIT_ARRAY, preinit_array); 2175 GRAB(SHT_SUNW_cap, sunw_cap); 2176 GRAB(SHT_SUNW_LDYNSYM, sunw_ldynsym); 2177 GRAB(SHT_SUNW_syminfo, sunw_syminfo); 2178 GRAB(SHT_SUNW_symsort, sunw_symsort); 2179 GRAB(SHT_SUNW_tlssort, sunw_tlssort); 2180 GRAB(SHT_SUNW_verdef, sunw_verdef); 2181 GRAB(SHT_SUNW_verneed, sunw_verneed); 2182 GRAB(SHT_SUNW_versym, sunw_versym); 2183 #undef GRAB 2184 } 2185 } 2186 2187 /* 2188 * If no dynamic section, return immediately. If more than one 2189 * dynamic section, then something odd is going on and an error 2190 * is in order, but then continue on and display them all. 2191 */ 2192 if (dynsec_num == 0) 2193 return; 2194 if (dynsec_num > 1) 2195 (void) fprintf(stderr, MSG_INTL(MSG_ERR_MULTDYN), 2196 file, EC_WORD(dynsec_num)); 2197 2198 2199 dynsec_cnt = 0; 2200 for (cnt = dynsec_ndx; (cnt < shnum) && (dynsec_cnt < dynsec_num); 2201 cnt++) { 2202 Dyn *dyn; 2203 ulong_t numdyn; 2204 int ndx, end_ndx; 2205 Cache *_cache = &cache[cnt], *strsec; 2206 Shdr *shdr = _cache->c_shdr; 2207 int dumped = 0; 2208 2209 if (shdr->sh_type != SHT_DYNAMIC) 2210 continue; 2211 dynsec_cnt++; 2212 2213 /* 2214 * Verify the associated string table section. 2215 */ 2216 if (stringtbl(cache, 0, cnt, shnum, file, 0, 0, &strsec) == 0) 2217 continue; 2218 2219 if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { 2220 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 2221 file, _cache->c_name); 2222 continue; 2223 } 2224 if (_cache->c_data == NULL) 2225 continue; 2226 2227 numdyn = shdr->sh_size / shdr->sh_entsize; 2228 dyn = (Dyn *)_cache->c_data->d_buf; 2229 2230 /* 2231 * We expect the REL/RELA entries to reference the reloc 2232 * section with the lowest address. However, this is 2233 * not true for dumped objects. Detect if this object has 2234 * been dumped so that we can skip the reloc address test 2235 * in that case. 2236 */ 2237 for (ndx = 0; ndx < numdyn; dyn++, ndx++) { 2238 if (dyn->d_tag == DT_FLAGS_1) { 2239 dumped = (dyn->d_un.d_val & DF_1_CONFALT) != 0; 2240 break; 2241 } 2242 } 2243 dyn = (Dyn *)_cache->c_data->d_buf; 2244 2245 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 2246 dbg_print(0, MSG_INTL(MSG_ELF_SCN_DYNAMIC), _cache->c_name); 2247 2248 Elf_dyn_title(0); 2249 2250 for (ndx = 0; ndx < numdyn; dyn++, ndx++) { 2251 union { 2252 Conv_dyn_flag_buf_t flag; 2253 Conv_dyn_flag1_buf_t flag1; 2254 Conv_dyn_posflag1_buf_t posflag1; 2255 Conv_dyn_feature1_buf_t feature1; 2256 } c_buf; 2257 const char *name = NULL; 2258 2259 /* 2260 * Print the information numerically, and if possible 2261 * as a string. If a string is available, name is 2262 * set to reference it. 2263 * 2264 * Also, take this opportunity to sanity check 2265 * the values of DT elements. In the code above, 2266 * we gathered information on sections that are 2267 * referenced by the dynamic section. Here, we 2268 * compare the attributes of those sections to 2269 * the DT_ items that reference them and report 2270 * on inconsistencies. 2271 * 2272 * Things not currently tested that could be improved 2273 * in later revisions include: 2274 * - We don't check PLT or GOT related items 2275 * - We don't handle computing the lengths of 2276 * relocation arrays. To handle this 2277 * requires examining data that spans 2278 * across sections, in a contiguous span 2279 * within a single segment. 2280 * - DT_VERDEFNUM and DT_VERNEEDNUM can't be 2281 * verified without parsing the sections. 2282 * - We don't handle DT_SUNW_SYMSZ, which would 2283 * be the sum of the lengths of .dynsym and 2284 * .SUNW_ldynsym 2285 * - DT_SUNW_STRPAD can't be verified other than 2286 * to check that it's not larger than 2287 * the string table. 2288 * - Some items come in "all or none" clusters 2289 * that give an address, element size, 2290 * and data length in bytes. We don't 2291 * verify that there are no missing items 2292 * in such groups. 2293 */ 2294 switch (dyn->d_tag) { 2295 case DT_NULL: 2296 /* 2297 * Special case: DT_NULLs can come in groups 2298 * that we prefer to reduce to a single line. 2299 */ 2300 end_ndx = ndx; 2301 while ((end_ndx < (numdyn - 1)) && 2302 ((dyn + 1)->d_tag == DT_NULL)) { 2303 dyn++; 2304 end_ndx++; 2305 } 2306 Elf_dyn_null_entry(0, dyn, ndx, end_ndx); 2307 ndx = end_ndx; 2308 continue; 2309 2310 /* 2311 * String items all reference the dynstr. The string() 2312 * function does the necessary sanity checking. 2313 */ 2314 case DT_NEEDED: 2315 case DT_SONAME: 2316 case DT_FILTER: 2317 case DT_AUXILIARY: 2318 case DT_CONFIG: 2319 case DT_RPATH: 2320 case DT_RUNPATH: 2321 case DT_USED: 2322 case DT_DEPAUDIT: 2323 case DT_AUDIT: 2324 case DT_SUNW_AUXILIARY: 2325 case DT_SUNW_FILTER: 2326 name = string(_cache, ndx, strsec, 2327 file, dyn->d_un.d_ptr); 2328 break; 2329 2330 case DT_FLAGS: 2331 name = conv_dyn_flag(dyn->d_un.d_val, 2332 0, &c_buf.flag); 2333 break; 2334 case DT_FLAGS_1: 2335 name = conv_dyn_flag1(dyn->d_un.d_val, 0, 2336 &c_buf.flag1); 2337 break; 2338 case DT_POSFLAG_1: 2339 name = conv_dyn_posflag1(dyn->d_un.d_val, 0, 2340 &c_buf.posflag1); 2341 break; 2342 case DT_FEATURE_1: 2343 name = conv_dyn_feature1(dyn->d_un.d_val, 0, 2344 &c_buf.feature1); 2345 break; 2346 case DT_DEPRECATED_SPARC_REGISTER: 2347 name = MSG_INTL(MSG_STR_DEPRECATED); 2348 break; 2349 2350 /* 2351 * Cases below this point are strictly sanity checking, 2352 * and do not generate a name string. The TEST_ macros 2353 * are used to hide the boilerplate arguments neeeded 2354 * by dyn_test(). 2355 */ 2356 #define TEST_ADDR(_sh_type, _sec_field) \ 2357 dyn_test(DYN_TEST_ADDR, _sh_type, \ 2358 sec._sec_field, dyn, dynsec_cnt, ehdr, file) 2359 #define TEST_SIZE(_sh_type, _sec_field) \ 2360 dyn_test(DYN_TEST_SIZE, _sh_type, \ 2361 sec._sec_field, dyn, dynsec_cnt, ehdr, file) 2362 #define TEST_ENTSIZE(_sh_type, _sec_field) \ 2363 dyn_test(DYN_TEST_ENTSIZE, _sh_type, \ 2364 sec._sec_field, dyn, dynsec_cnt, ehdr, file) 2365 2366 case DT_FINI: 2367 TEST_ADDR(SHT_PROGBITS, fini); 2368 break; 2369 2370 case DT_FINI_ARRAY: 2371 TEST_ADDR(SHT_FINI_ARRAY, fini_array); 2372 break; 2373 2374 case DT_FINI_ARRAYSZ: 2375 TEST_SIZE(SHT_FINI_ARRAY, fini_array); 2376 break; 2377 2378 case DT_HASH: 2379 TEST_ADDR(SHT_HASH, hash); 2380 break; 2381 2382 case DT_INIT: 2383 TEST_ADDR(SHT_PROGBITS, init); 2384 break; 2385 2386 case DT_INIT_ARRAY: 2387 TEST_ADDR(SHT_INIT_ARRAY, init_array); 2388 break; 2389 2390 case DT_INIT_ARRAYSZ: 2391 TEST_SIZE(SHT_INIT_ARRAY, init_array); 2392 break; 2393 2394 case DT_MOVEENT: 2395 TEST_ENTSIZE(SHT_SUNW_move, sunw_move); 2396 break; 2397 2398 case DT_MOVESZ: 2399 TEST_SIZE(SHT_SUNW_move, sunw_move); 2400 break; 2401 2402 case DT_MOVETAB: 2403 TEST_ADDR(SHT_SUNW_move, sunw_move); 2404 break; 2405 2406 case DT_PREINIT_ARRAY: 2407 TEST_ADDR(SHT_PREINIT_ARRAY, preinit_array); 2408 break; 2409 2410 case DT_PREINIT_ARRAYSZ: 2411 TEST_SIZE(SHT_PREINIT_ARRAY, preinit_array); 2412 break; 2413 2414 case DT_REL: 2415 if (!dumped) 2416 TEST_ADDR(SHT_REL, rel); 2417 break; 2418 2419 case DT_RELENT: 2420 TEST_ENTSIZE(SHT_REL, rel); 2421 break; 2422 2423 case DT_RELA: 2424 if (!dumped) 2425 TEST_ADDR(SHT_RELA, rela); 2426 break; 2427 2428 case DT_RELAENT: 2429 TEST_ENTSIZE(SHT_RELA, rela); 2430 break; 2431 2432 case DT_STRTAB: 2433 TEST_ADDR(SHT_STRTAB, dynstr); 2434 break; 2435 2436 case DT_STRSZ: 2437 TEST_SIZE(SHT_STRTAB, dynstr); 2438 break; 2439 2440 case DT_SUNW_CAP: 2441 TEST_ADDR(SHT_SUNW_cap, sunw_cap); 2442 break; 2443 2444 case DT_SUNW_SYMTAB: 2445 TEST_ADDR(SHT_SUNW_LDYNSYM, sunw_ldynsym); 2446 break; 2447 2448 case DT_SYMENT: 2449 TEST_ENTSIZE(SHT_DYNSYM, dynsym); 2450 break; 2451 2452 case DT_SYMINENT: 2453 TEST_ENTSIZE(SHT_SUNW_syminfo, sunw_syminfo); 2454 break; 2455 2456 case DT_SYMINFO: 2457 TEST_ADDR(SHT_SUNW_syminfo, sunw_syminfo); 2458 break; 2459 2460 case DT_SYMINSZ: 2461 TEST_SIZE(SHT_SUNW_syminfo, sunw_syminfo); 2462 break; 2463 2464 case DT_SYMTAB: 2465 TEST_ADDR(SHT_DYNSYM, dynsym); 2466 break; 2467 2468 case DT_SUNW_SORTENT: 2469 /* 2470 * This entry is related to both the symsort and 2471 * tlssort sections. 2472 */ 2473 { 2474 int test_tls = 2475 (sec.sunw_tlssort != NULL); 2476 int test_sym = 2477 (sec.sunw_symsort != NULL) || 2478 !test_tls; 2479 if (test_sym) 2480 TEST_ENTSIZE(SHT_SUNW_symsort, 2481 sunw_symsort); 2482 if (test_tls) 2483 TEST_ENTSIZE(SHT_SUNW_tlssort, 2484 sunw_tlssort); 2485 } 2486 break; 2487 2488 2489 case DT_SUNW_SYMSORT: 2490 TEST_ADDR(SHT_SUNW_symsort, sunw_symsort); 2491 break; 2492 2493 case DT_SUNW_SYMSORTSZ: 2494 TEST_SIZE(SHT_SUNW_symsort, sunw_symsort); 2495 break; 2496 2497 case DT_SUNW_TLSSORT: 2498 TEST_ADDR(SHT_SUNW_tlssort, sunw_tlssort); 2499 break; 2500 2501 case DT_SUNW_TLSSORTSZ: 2502 TEST_SIZE(SHT_SUNW_tlssort, sunw_tlssort); 2503 break; 2504 2505 case DT_VERDEF: 2506 TEST_ADDR(SHT_SUNW_verdef, sunw_verdef); 2507 break; 2508 2509 case DT_VERNEED: 2510 TEST_ADDR(SHT_SUNW_verneed, sunw_verneed); 2511 break; 2512 2513 case DT_VERSYM: 2514 TEST_ADDR(SHT_SUNW_versym, sunw_versym); 2515 break; 2516 #undef TEST_ADDR 2517 #undef TEST_SIZE 2518 #undef TEST_ENTSIZE 2519 } 2520 2521 if (name == NULL) 2522 name = MSG_ORIG(MSG_STR_EMPTY); 2523 Elf_dyn_entry(0, dyn, ndx, name, ehdr->e_machine); 2524 } 2525 } 2526 } 2527 2528 /* 2529 * Search for and process a MOVE section. 2530 */ 2531 static void 2532 move(Cache *cache, Word shnum, const char *file, uint_t flags) 2533 { 2534 Word cnt; 2535 const char *fmt = 0; 2536 2537 for (cnt = 1; cnt < shnum; cnt++) { 2538 Word movenum, symnum, ndx; 2539 Sym *syms; 2540 Cache *_cache = &cache[cnt]; 2541 Shdr *shdr = _cache->c_shdr; 2542 Cache *symsec, *strsec; 2543 Move *move; 2544 2545 if (shdr->sh_type != SHT_SUNW_move) 2546 continue; 2547 if (!match(0, _cache->c_name, cnt)) 2548 continue; 2549 2550 /* 2551 * Determine the move data and number. 2552 */ 2553 if ((shdr->sh_entsize == 0) || (shdr->sh_size == 0)) { 2554 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 2555 file, _cache->c_name); 2556 continue; 2557 } 2558 if (_cache->c_data == NULL) 2559 continue; 2560 2561 move = (Move *)_cache->c_data->d_buf; 2562 movenum = shdr->sh_size / shdr->sh_entsize; 2563 2564 /* 2565 * Get the data buffer for the associated symbol table and 2566 * string table. 2567 */ 2568 if (stringtbl(cache, 1, cnt, shnum, file, 2569 &symnum, &symsec, &strsec) == 0) 2570 return; 2571 2572 syms = (Sym *)symsec->c_data->d_buf; 2573 2574 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 2575 dbg_print(0, MSG_INTL(MSG_ELF_SCN_MOVE), _cache->c_name); 2576 dbg_print(0, MSG_INTL(MSG_MOVE_TITLE)); 2577 2578 if (fmt == 0) 2579 fmt = MSG_INTL(MSG_MOVE_ENTRY); 2580 2581 for (ndx = 0; ndx < movenum; move++, ndx++) { 2582 const char *symname; 2583 char index[MAXNDXSIZE], section[BUFSIZ]; 2584 Word symndx, shndx; 2585 Sym *sym; 2586 2587 /* 2588 * Check for null entries 2589 */ 2590 if ((move->m_info == 0) && (move->m_value == 0) && 2591 (move->m_poffset == 0) && (move->m_repeat == 0) && 2592 (move->m_stride == 0)) { 2593 dbg_print(0, fmt, MSG_ORIG(MSG_STR_EMPTY), 2594 EC_XWORD(move->m_poffset), 0, 0, 0, 2595 EC_LWORD(0), MSG_ORIG(MSG_STR_EMPTY)); 2596 continue; 2597 } 2598 if (((symndx = ELF_M_SYM(move->m_info)) == 0) || 2599 (symndx >= symnum)) { 2600 (void) fprintf(stderr, 2601 MSG_INTL(MSG_ERR_BADMINFO), file, 2602 _cache->c_name, EC_XWORD(move->m_info)); 2603 2604 (void) snprintf(index, MAXNDXSIZE, 2605 MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(symndx)); 2606 dbg_print(0, fmt, index, 2607 EC_XWORD(move->m_poffset), 2608 ELF_M_SIZE(move->m_info), move->m_repeat, 2609 move->m_stride, move->m_value, 2610 MSG_INTL(MSG_STR_UNKNOWN)); 2611 continue; 2612 } 2613 2614 symname = relsymname(cache, _cache, strsec, 2615 symndx, symnum, ndx, syms, section, BUFSIZ, file, 2616 flags); 2617 sym = (Sym *)(syms + symndx); 2618 2619 /* 2620 * Additional sanity check. 2621 */ 2622 shndx = sym->st_shndx; 2623 if (!((shndx == SHN_COMMON) || 2624 (((shndx >= 1) && (shndx <= shnum)) && 2625 (cache[shndx].c_shdr)->sh_type == SHT_NOBITS))) { 2626 (void) fprintf(stderr, 2627 MSG_INTL(MSG_ERR_BADSYM2), file, 2628 _cache->c_name, demangle(symname, flags)); 2629 } 2630 2631 (void) snprintf(index, MAXNDXSIZE, 2632 MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(symndx)); 2633 dbg_print(0, fmt, index, EC_XWORD(move->m_poffset), 2634 ELF_M_SIZE(move->m_info), move->m_repeat, 2635 move->m_stride, move->m_value, 2636 demangle(symname, flags)); 2637 } 2638 } 2639 } 2640 2641 /* 2642 * Traverse a note section analyzing each note information block. 2643 * The data buffers size is used to validate references before they are made, 2644 * and is decremented as each element is processed. 2645 */ 2646 void 2647 note_entry(Cache *cache, Word *data, size_t size, const char *file) 2648 { 2649 size_t bsize = size; 2650 2651 /* 2652 * Print out a single `note' information block. 2653 */ 2654 while (size > 0) { 2655 size_t namesz, descsz, type, pad, noteoff; 2656 2657 noteoff = bsize - size; 2658 /* 2659 * Make sure we can at least reference the 3 initial entries 2660 * (4-byte words) of the note information block. 2661 */ 2662 if (size >= (sizeof (Word) * 3)) 2663 size -= (sizeof (Word) * 3); 2664 else { 2665 (void) fprintf(stderr, MSG_INTL(MSG_NOTE_BADDATASZ), 2666 file, cache->c_name, EC_WORD(noteoff)); 2667 return; 2668 } 2669 2670 /* 2671 * Make sure any specified name string can be referenced. 2672 */ 2673 if ((namesz = *data++) != 0) { 2674 if (size >= namesz) 2675 size -= namesz; 2676 else { 2677 (void) fprintf(stderr, 2678 MSG_INTL(MSG_NOTE_BADNMSZ), file, 2679 cache->c_name, EC_WORD(noteoff), 2680 EC_WORD(namesz)); 2681 return; 2682 } 2683 } 2684 2685 /* 2686 * Make sure any specified descriptor can be referenced. 2687 */ 2688 if ((descsz = *data++) != 0) { 2689 /* 2690 * If namesz isn't a 4-byte multiple, account for any 2691 * padding that must exist before the descriptor. 2692 */ 2693 if ((pad = (namesz & (sizeof (Word) - 1))) != 0) { 2694 pad = sizeof (Word) - pad; 2695 size -= pad; 2696 } 2697 if (size >= descsz) 2698 size -= descsz; 2699 else { 2700 (void) fprintf(stderr, 2701 MSG_INTL(MSG_NOTE_BADDESZ), file, 2702 cache->c_name, EC_WORD(noteoff), 2703 EC_WORD(namesz)); 2704 return; 2705 } 2706 } 2707 2708 type = *data++; 2709 2710 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 2711 dbg_print(0, MSG_ORIG(MSG_NOTE_TYPE), EC_WORD(type)); 2712 2713 dbg_print(0, MSG_ORIG(MSG_NOTE_NAMESZ), EC_WORD(namesz)); 2714 if (namesz) { 2715 char *name = (char *)data; 2716 2717 /* 2718 * Since the name string may have 'null' bytes 2719 * in it (ia32 .string) - we just write the 2720 * whole stream in a single fwrite. 2721 */ 2722 (void) fwrite(name, namesz, 1, stdout); 2723 name = name + ((namesz + (sizeof (Word) - 1)) & 2724 ~(sizeof (Word) - 1)); 2725 /* LINTED */ 2726 data = (Word *)name; 2727 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 2728 } 2729 2730 /* 2731 * If multiple information blocks exist within a .note section 2732 * account for any padding that must exist before the next 2733 * information block. 2734 */ 2735 if ((pad = (descsz & (sizeof (Word) - 1))) != 0) { 2736 pad = sizeof (Word) - pad; 2737 if (size > pad) 2738 size -= pad; 2739 } 2740 2741 dbg_print(0, MSG_ORIG(MSG_NOTE_DESCSZ), EC_WORD(descsz)); 2742 if (descsz) { 2743 int ndx, byte, word; 2744 char string[58], *str = string; 2745 uchar_t *desc = (uchar_t *)data; 2746 2747 /* 2748 * Dump descriptor bytes. 2749 */ 2750 for (ndx = byte = word = 0; descsz; descsz--, desc++) { 2751 int tok = *desc; 2752 2753 (void) snprintf(str, 58, MSG_ORIG(MSG_NOTE_TOK), 2754 tok); 2755 str += 3; 2756 2757 if (++byte == 4) { 2758 *str++ = ' ', *str++ = ' '; 2759 word++; 2760 byte = 0; 2761 } 2762 if (word == 4) { 2763 *str = '\0'; 2764 dbg_print(0, MSG_ORIG(MSG_NOTE_DESC), 2765 ndx, string); 2766 word = 0; 2767 ndx += 16; 2768 str = string; 2769 } 2770 } 2771 if (byte || word) { 2772 *str = '\0'; 2773 dbg_print(0, MSG_ORIG(MSG_NOTE_DESC), 2774 ndx, string); 2775 } 2776 2777 desc += pad; 2778 /* LINTED */ 2779 data = (Word *)desc; 2780 } 2781 } 2782 } 2783 2784 /* 2785 * Search for and process a .note section. 2786 */ 2787 static void 2788 note(Cache *cache, Word shnum, const char *file) 2789 { 2790 Word cnt; 2791 2792 /* 2793 * Otherwise look for any .note sections. 2794 */ 2795 for (cnt = 1; cnt < shnum; cnt++) { 2796 Cache *_cache = &cache[cnt]; 2797 Shdr *shdr = _cache->c_shdr; 2798 2799 if (shdr->sh_type != SHT_NOTE) 2800 continue; 2801 if (!match(0, _cache->c_name, cnt)) 2802 continue; 2803 2804 /* 2805 * As these sections are often hand rolled, make sure they're 2806 * properly aligned before proceeding, and issue an error 2807 * as necessary. 2808 * 2809 * Note that we will continue on to display the note even 2810 * if it has bad alignment. We can do this safely, because 2811 * libelf knows the alignment required for SHT_NOTE, and 2812 * takes steps to deliver a properly aligned buffer to us 2813 * even if the actual file is misaligned. 2814 */ 2815 if (shdr->sh_offset & (sizeof (Word) - 1)) 2816 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADALIGN), 2817 file, _cache->c_name); 2818 2819 if (_cache->c_data == NULL) 2820 continue; 2821 2822 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 2823 dbg_print(0, MSG_INTL(MSG_ELF_SCN_NOTE), _cache->c_name); 2824 note_entry(_cache, (Word *)_cache->c_data->d_buf, 2825 /* LINTED */ 2826 (Word)_cache->c_data->d_size, file); 2827 } 2828 } 2829 2830 /* 2831 * Determine an individual hash entry. This may be the initial hash entry, 2832 * or an associated chain entry. 2833 */ 2834 static void 2835 hash_entry(Cache *refsec, Cache *strsec, const char *hsecname, Word hashndx, 2836 Word symndx, Word symn, Sym *syms, const char *file, ulong_t bkts, 2837 uint_t flags, int chain) 2838 { 2839 Sym *sym; 2840 const char *symname, *str; 2841 char _bucket[MAXNDXSIZE], _symndx[MAXNDXSIZE]; 2842 ulong_t nbkt, nhash; 2843 2844 if (symndx > symn) { 2845 (void) fprintf(stderr, MSG_INTL(MSG_ERR_HSBADSYMNDX), file, 2846 EC_WORD(symndx), EC_WORD(hashndx)); 2847 symname = MSG_INTL(MSG_STR_UNKNOWN); 2848 } else { 2849 sym = (Sym *)(syms + symndx); 2850 symname = string(refsec, symndx, strsec, file, sym->st_name); 2851 } 2852 2853 if (chain == 0) { 2854 (void) snprintf(_bucket, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INTEGER), 2855 hashndx); 2856 str = (const char *)_bucket; 2857 } else 2858 str = MSG_ORIG(MSG_STR_EMPTY); 2859 2860 (void) snprintf(_symndx, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX2), 2861 EC_WORD(symndx)); 2862 dbg_print(0, MSG_ORIG(MSG_FMT_HASH_INFO), str, _symndx, 2863 demangle(symname, flags)); 2864 2865 /* 2866 * Determine if this string is in the correct bucket. 2867 */ 2868 nhash = elf_hash(symname); 2869 nbkt = nhash % bkts; 2870 2871 if (nbkt != hashndx) { 2872 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADHASH), file, 2873 hsecname, symname, EC_WORD(hashndx), nbkt); 2874 } 2875 } 2876 2877 #define MAXCOUNT 500 2878 2879 static void 2880 hash(Cache *cache, Word shnum, const char *file, uint_t flags) 2881 { 2882 static int count[MAXCOUNT]; 2883 Word cnt; 2884 ulong_t ndx, bkts; 2885 char number[MAXNDXSIZE]; 2886 2887 for (cnt = 1; cnt < shnum; cnt++) { 2888 uint_t *hash, *chain; 2889 Cache *_cache = &cache[cnt]; 2890 Shdr *sshdr, *hshdr = _cache->c_shdr; 2891 char *ssecname, *hsecname = _cache->c_name; 2892 Sym *syms; 2893 Word symn; 2894 2895 if (hshdr->sh_type != SHT_HASH) 2896 continue; 2897 2898 /* 2899 * Determine the hash table data and size. 2900 */ 2901 if ((hshdr->sh_entsize == 0) || (hshdr->sh_size == 0)) { 2902 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 2903 file, hsecname); 2904 continue; 2905 } 2906 if (_cache->c_data == NULL) 2907 continue; 2908 2909 hash = (uint_t *)_cache->c_data->d_buf; 2910 bkts = *hash; 2911 chain = hash + 2 + bkts; 2912 hash += 2; 2913 2914 /* 2915 * Get the data buffer for the associated symbol table. 2916 */ 2917 if ((hshdr->sh_link == 0) || (hshdr->sh_link >= shnum)) { 2918 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), 2919 file, hsecname, EC_WORD(hshdr->sh_link)); 2920 continue; 2921 } 2922 2923 _cache = &cache[hshdr->sh_link]; 2924 ssecname = _cache->c_name; 2925 2926 if (_cache->c_data == NULL) 2927 continue; 2928 2929 if ((syms = (Sym *)_cache->c_data->d_buf) == NULL) { 2930 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 2931 file, ssecname); 2932 continue; 2933 } 2934 2935 sshdr = _cache->c_shdr; 2936 /* LINTED */ 2937 symn = (Word)(sshdr->sh_size / sshdr->sh_entsize); 2938 2939 /* 2940 * Get the associated string table section. 2941 */ 2942 if ((sshdr->sh_link == 0) || (sshdr->sh_link >= shnum)) { 2943 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHLINK), 2944 file, ssecname, EC_WORD(sshdr->sh_link)); 2945 continue; 2946 } 2947 2948 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 2949 dbg_print(0, MSG_INTL(MSG_ELF_SCN_HASH), hsecname); 2950 dbg_print(0, MSG_INTL(MSG_ELF_HASH_INFO)); 2951 2952 /* 2953 * Loop through the hash buckets, printing the appropriate 2954 * symbols. 2955 */ 2956 for (ndx = 0; ndx < bkts; ndx++, hash++) { 2957 Word _ndx, _cnt; 2958 2959 if (*hash == 0) { 2960 count[0]++; 2961 continue; 2962 } 2963 2964 hash_entry(_cache, &cache[sshdr->sh_link], hsecname, 2965 ndx, *hash, symn, syms, file, bkts, flags, 0); 2966 2967 /* 2968 * Determine if any other symbols are chained to this 2969 * bucket. 2970 */ 2971 _ndx = chain[*hash]; 2972 _cnt = 1; 2973 while (_ndx) { 2974 hash_entry(_cache, &cache[sshdr->sh_link], 2975 hsecname, ndx, _ndx, symn, syms, file, 2976 bkts, flags, 1); 2977 _ndx = chain[_ndx]; 2978 _cnt++; 2979 } 2980 2981 if (_cnt >= MAXCOUNT) { 2982 (void) fprintf(stderr, 2983 MSG_INTL(MSG_HASH_OVERFLW), file, 2984 _cache->c_name, EC_WORD(ndx), 2985 EC_WORD(_cnt)); 2986 } else 2987 count[_cnt]++; 2988 } 2989 break; 2990 } 2991 2992 /* 2993 * Print out the count information. 2994 */ 2995 bkts = cnt = 0; 2996 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 2997 2998 for (ndx = 0; ndx < MAXCOUNT; ndx++) { 2999 Word _cnt; 3000 3001 if ((_cnt = count[ndx]) == 0) 3002 continue; 3003 3004 (void) snprintf(number, MAXNDXSIZE, 3005 MSG_ORIG(MSG_FMT_INTEGER), _cnt); 3006 dbg_print(0, MSG_INTL(MSG_ELF_HASH_BKTS1), number, 3007 EC_WORD(ndx)); 3008 bkts += _cnt; 3009 cnt += (Word)(ndx * _cnt); 3010 } 3011 if (cnt) { 3012 (void) snprintf(number, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INTEGER), 3013 bkts); 3014 dbg_print(0, MSG_INTL(MSG_ELF_HASH_BKTS2), number, 3015 EC_WORD(cnt)); 3016 } 3017 } 3018 3019 static void 3020 group(Cache *cache, Word shnum, const char *file, uint_t flags) 3021 { 3022 Word scnt; 3023 3024 for (scnt = 1; scnt < shnum; scnt++) { 3025 Cache *_cache = &cache[scnt]; 3026 Shdr *shdr = _cache->c_shdr; 3027 Word *grpdata, gcnt, grpcnt, symnum, unknown; 3028 Cache *symsec, *strsec; 3029 Sym *syms, *sym; 3030 char flgstrbuf[MSG_GRP_COMDAT_SIZE + 10]; 3031 3032 if (shdr->sh_type != SHT_GROUP) 3033 continue; 3034 if (!match(0, _cache->c_name, scnt)) 3035 continue; 3036 if ((_cache->c_data == NULL) || 3037 ((grpdata = (Word *)_cache->c_data->d_buf) == NULL)) 3038 continue; 3039 grpcnt = shdr->sh_size / sizeof (Word); 3040 3041 /* 3042 * Get the data buffer for the associated symbol table and 3043 * string table. 3044 */ 3045 if (stringtbl(cache, 1, scnt, shnum, file, 3046 &symnum, &symsec, &strsec) == 0) 3047 return; 3048 3049 syms = symsec->c_data->d_buf; 3050 3051 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 3052 dbg_print(0, MSG_INTL(MSG_ELF_SCN_GRP), _cache->c_name); 3053 dbg_print(0, MSG_INTL(MSG_GRP_TITLE)); 3054 3055 /* 3056 * The first element of the group defines the group. The 3057 * associated symbol is defined by the sh_link field. 3058 */ 3059 if ((shdr->sh_info == SHN_UNDEF) || (shdr->sh_info > symnum)) { 3060 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHINFO), 3061 file, _cache->c_name, EC_WORD(shdr->sh_info)); 3062 return; 3063 } 3064 3065 (void) strcpy(flgstrbuf, MSG_ORIG(MSG_STR_OSQBRKT)); 3066 if (grpdata[0] & GRP_COMDAT) { 3067 (void) strcat(flgstrbuf, MSG_ORIG(MSG_GRP_COMDAT)); 3068 } 3069 if ((unknown = (grpdata[0] & ~GRP_COMDAT)) != 0) { 3070 size_t len = strlen(flgstrbuf); 3071 3072 (void) snprintf(&flgstrbuf[len], 3073 (MSG_GRP_COMDAT_SIZE + 10 - len), 3074 MSG_ORIG(MSG_GRP_UNKNOWN), unknown); 3075 } 3076 (void) strcat(flgstrbuf, MSG_ORIG(MSG_STR_CSQBRKT)); 3077 sym = (Sym *)(syms + shdr->sh_info); 3078 3079 dbg_print(0, MSG_INTL(MSG_GRP_SIGNATURE), flgstrbuf, 3080 demangle(string(_cache, 0, strsec, file, sym->st_name), 3081 flags)); 3082 3083 for (gcnt = 1; gcnt < grpcnt; gcnt++) { 3084 char index[MAXNDXSIZE]; 3085 const char *name; 3086 3087 (void) snprintf(index, MAXNDXSIZE, 3088 MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(gcnt)); 3089 3090 if (grpdata[gcnt] >= shnum) 3091 name = MSG_INTL(MSG_GRP_INVALSCN); 3092 else 3093 name = cache[grpdata[gcnt]].c_name; 3094 3095 (void) printf(MSG_ORIG(MSG_GRP_ENTRY), index, name, 3096 EC_XWORD(grpdata[gcnt])); 3097 } 3098 } 3099 } 3100 3101 static void 3102 got(Cache *cache, Word shnum, Ehdr *ehdr, const char *file, uint_t flags) 3103 { 3104 Cache *gotcache = NULL, *symtab = NULL; 3105 Addr gotbgn, gotend; 3106 Shdr *gotshdr; 3107 Word cnt, gotents, gotndx; 3108 size_t gentsize; 3109 Got_info *gottable; 3110 char *gotdata; 3111 Sym *gotsym; 3112 Xword gotsymaddr; 3113 3114 /* 3115 * First, find the got. 3116 */ 3117 for (cnt = 1; cnt < shnum; cnt++) { 3118 if (strncmp(cache[cnt].c_name, MSG_ORIG(MSG_ELF_GOT), 3119 MSG_ELF_GOT_SIZE) == 0) { 3120 gotcache = &cache[cnt]; 3121 break; 3122 } 3123 } 3124 if (gotcache == NULL) 3125 return; 3126 3127 /* 3128 * A got section within a relocatable object is suspicious. 3129 */ 3130 if (ehdr->e_type == ET_REL) { 3131 (void) fprintf(stderr, MSG_INTL(MSG_GOT_UNEXPECTED), file, 3132 gotcache->c_name); 3133 } 3134 3135 gotshdr = gotcache->c_shdr; 3136 if (gotshdr->sh_size == 0) { 3137 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 3138 file, gotcache->c_name); 3139 return; 3140 } 3141 3142 gotbgn = gotshdr->sh_addr; 3143 gotend = gotbgn + gotshdr->sh_size; 3144 3145 /* 3146 * Some architectures don't properly set the sh_entsize for the GOT 3147 * table. If it's not set, default to a size of a pointer. 3148 */ 3149 if ((gentsize = gotshdr->sh_entsize) == 0) 3150 gentsize = sizeof (Xword); 3151 3152 if (gotcache->c_data == NULL) 3153 return; 3154 3155 /* LINTED */ 3156 gotents = (Word)(gotshdr->sh_size / gentsize); 3157 gotdata = gotcache->c_data->d_buf; 3158 3159 if ((gottable = calloc(gotents, sizeof (Got_info))) == 0) { 3160 int err = errno; 3161 (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), file, 3162 strerror(err)); 3163 return; 3164 } 3165 3166 /* 3167 * Now we scan through all the sections looking for any relocations 3168 * that may be against the GOT. Since these may not be isolated to a 3169 * .rel[a].got section we check them all. 3170 * While scanning sections save the symbol table entry (a symtab 3171 * overriding a dynsym) so that we can lookup _GLOBAL_OFFSET_TABLE_. 3172 */ 3173 for (cnt = 1; cnt < shnum; cnt++) { 3174 Word type, symnum; 3175 Xword relndx, relnum, relsize; 3176 void *rels; 3177 Sym *syms; 3178 Cache *symsec, *strsec; 3179 Cache *_cache = &cache[cnt]; 3180 Shdr *shdr; 3181 3182 shdr = _cache->c_shdr; 3183 type = shdr->sh_type; 3184 3185 if ((symtab == 0) && (type == SHT_DYNSYM)) { 3186 symtab = _cache; 3187 continue; 3188 } 3189 if (type == SHT_SYMTAB) { 3190 symtab = _cache; 3191 continue; 3192 } 3193 if ((type != SHT_RELA) && (type != SHT_REL)) 3194 continue; 3195 3196 /* 3197 * Decide entry size. 3198 */ 3199 if (((relsize = shdr->sh_entsize) == 0) || 3200 (relsize > shdr->sh_size)) { 3201 if (type == SHT_RELA) 3202 relsize = sizeof (Rela); 3203 else 3204 relsize = sizeof (Rel); 3205 } 3206 3207 /* 3208 * Determine the number of relocations available. 3209 */ 3210 if (shdr->sh_size == 0) { 3211 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSZ), 3212 file, _cache->c_name); 3213 continue; 3214 } 3215 if (_cache->c_data == NULL) 3216 continue; 3217 3218 rels = _cache->c_data->d_buf; 3219 relnum = shdr->sh_size / relsize; 3220 3221 /* 3222 * Get the data buffer for the associated symbol table and 3223 * string table. 3224 */ 3225 if (stringtbl(cache, 1, cnt, shnum, file, 3226 &symnum, &symsec, &strsec) == 0) 3227 continue; 3228 3229 syms = symsec->c_data->d_buf; 3230 3231 /* 3232 * Loop through the relocation entries. 3233 */ 3234 for (relndx = 0; relndx < relnum; relndx++, 3235 rels = (void *)((char *)rels + relsize)) { 3236 char section[BUFSIZ]; 3237 Addr offset; 3238 Got_info *gip; 3239 Word symndx, reltype; 3240 Rela *rela; 3241 Rel *rel; 3242 3243 /* 3244 * Unravel the relocation. 3245 */ 3246 if (type == SHT_RELA) { 3247 rela = (Rela *)rels; 3248 symndx = ELF_R_SYM(rela->r_info); 3249 reltype = ELF_R_TYPE(rela->r_info); 3250 offset = rela->r_offset; 3251 } else { 3252 rel = (Rel *)rels; 3253 symndx = ELF_R_SYM(rel->r_info); 3254 reltype = ELF_R_TYPE(rel->r_info); 3255 offset = rel->r_offset; 3256 } 3257 3258 /* 3259 * Only pay attention to relocations against the GOT. 3260 */ 3261 if ((offset < gotbgn) || (offset >= gotend)) 3262 continue; 3263 3264 /* LINTED */ 3265 gotndx = (Word)((offset - gotbgn) / 3266 gotshdr->sh_entsize); 3267 gip = &gottable[gotndx]; 3268 3269 if (gip->g_reltype != 0) { 3270 (void) fprintf(stderr, 3271 MSG_INTL(MSG_GOT_MULTIPLE), file, 3272 EC_WORD(gotndx), EC_ADDR(offset)); 3273 continue; 3274 } 3275 3276 if (symndx) 3277 gip->g_symname = relsymname(cache, _cache, 3278 strsec, symndx, symnum, relndx, syms, 3279 section, BUFSIZ, file, flags); 3280 gip->g_reltype = reltype; 3281 gip->g_rel = rels; 3282 } 3283 } 3284 3285 if (symlookup(MSG_ORIG(MSG_GOT_SYM), cache, shnum, &gotsym, symtab, 3286 file)) 3287 gotsymaddr = gotsym->st_value; 3288 else 3289 gotsymaddr = gotbgn; 3290 3291 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 3292 dbg_print(0, MSG_INTL(MSG_ELF_SCN_GOT), gotcache->c_name); 3293 Elf_got_title(0); 3294 3295 for (gotndx = 0; gotndx < gotents; gotndx++) { 3296 Got_info *gip; 3297 Sword gindex; 3298 Addr gaddr; 3299 Xword gotentry; 3300 3301 gip = &gottable[gotndx]; 3302 3303 gaddr = gotbgn + (gotndx * gentsize); 3304 gindex = (Sword)(gaddr - gotsymaddr) / (Sword)gentsize; 3305 3306 if (gentsize == sizeof (Word)) 3307 /* LINTED */ 3308 gotentry = (Xword)(*((Word *)(gotdata) + gotndx)); 3309 else 3310 /* LINTED */ 3311 gotentry = *((Xword *)(gotdata) + gotndx); 3312 3313 Elf_got_entry(0, gindex, gaddr, gotentry, ehdr->e_machine, 3314 gip->g_reltype, gip->g_rel, gip->g_symname); 3315 } 3316 free(gottable); 3317 } 3318 3319 void 3320 checksum(Elf *elf) 3321 { 3322 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 3323 dbg_print(0, MSG_INTL(MSG_STR_CHECKSUM), elf_checksum(elf)); 3324 } 3325 3326 /* 3327 * This variable is used by regular() to communicate the address of 3328 * the section header cache to sort_shdr_ndx_arr(). Unfortunately, 3329 * the qsort() interface does not include a userdata argument by which 3330 * such arbitrary data can be passed, so we are stuck using global data. 3331 */ 3332 static Cache *sort_shdr_ndx_arr_cache; 3333 3334 3335 /* 3336 * Used with qsort() to sort the section indices so that they can be 3337 * used to access the section headers in order of increasing data offset. 3338 * 3339 * entry: 3340 * sort_shdr_ndx_arr_cache - Contains address of 3341 * section header cache. 3342 * v1, v2 - Point at elements of sort_shdr_bits array to be compared. 3343 * 3344 * exit: 3345 * Returns -1 (less than), 0 (equal) or 1 (greater than). 3346 */ 3347 static int 3348 sort_shdr_ndx_arr(const void *v1, const void *v2) 3349 { 3350 Cache *cache1 = sort_shdr_ndx_arr_cache + *((size_t *)v1); 3351 Cache *cache2 = sort_shdr_ndx_arr_cache + *((size_t *)v2); 3352 3353 if (cache1->c_shdr->sh_offset < cache2->c_shdr->sh_offset) 3354 return (-1); 3355 3356 if (cache1->c_shdr->sh_offset > cache2->c_shdr->sh_offset) 3357 return (1); 3358 3359 return (0); 3360 } 3361 3362 3363 static int 3364 shdr_cache(const char *file, Elf *elf, Ehdr *ehdr, size_t shstrndx, 3365 size_t shnum, Cache **cache_ret) 3366 { 3367 Elf_Scn *scn; 3368 Elf_Data *data; 3369 size_t ndx; 3370 Shdr *nameshdr; 3371 char *names = 0; 3372 Cache *cache, *_cache; 3373 size_t *shdr_ndx_arr, shdr_ndx_arr_cnt; 3374 3375 3376 /* 3377 * Obtain the .shstrtab data buffer to provide the required section 3378 * name strings. 3379 */ 3380 if (shstrndx == SHN_UNDEF) { 3381 /* 3382 * It is rare, but legal, for an object to lack a 3383 * header string table section. 3384 */ 3385 names = NULL; 3386 (void) fprintf(stderr, MSG_INTL(MSG_ERR_NOSHSTRSEC), file); 3387 } else if ((scn = elf_getscn(elf, shstrndx)) == NULL) { 3388 failure(file, MSG_ORIG(MSG_ELF_GETSCN)); 3389 (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SHDR), 3390 EC_XWORD(shstrndx)); 3391 3392 } else if ((data = elf_getdata(scn, NULL)) == NULL) { 3393 failure(file, MSG_ORIG(MSG_ELF_GETDATA)); 3394 (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_DATA), 3395 EC_XWORD(shstrndx)); 3396 3397 } else if ((nameshdr = elf_getshdr(scn)) == NULL) { 3398 failure(file, MSG_ORIG(MSG_ELF_GETSHDR)); 3399 (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SCN), 3400 EC_WORD(elf_ndxscn(scn))); 3401 3402 } else if ((names = data->d_buf) == 0) 3403 (void) fprintf(stderr, MSG_INTL(MSG_ERR_SHSTRNULL), file); 3404 3405 /* 3406 * Allocate a cache to maintain a descriptor for each section. 3407 */ 3408 if ((*cache_ret = cache = malloc(shnum * sizeof (Cache))) == NULL) { 3409 int err = errno; 3410 (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), 3411 file, strerror(err)); 3412 return (0); 3413 } 3414 3415 *cache = cache_init; 3416 _cache = cache; 3417 _cache++; 3418 3419 /* 3420 * Allocate an array that will hold the section index for 3421 * each section that has data in the ELF file: 3422 * 3423 * - Is not a NOBITS section 3424 * - Data has non-zero length 3425 * 3426 * Note that shnum is an upper bound on the size required. It 3427 * is likely that we won't use a few of these array elements. 3428 * Allocating a modest amount of extra memory in this case means 3429 * that we can avoid an extra loop to count the number of needed 3430 * items, and can fill this array immediately in the first loop 3431 * below. 3432 */ 3433 if ((shdr_ndx_arr = malloc(shnum * sizeof (*shdr_ndx_arr))) == NULL) { 3434 int err = errno; 3435 (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), 3436 file, strerror(err)); 3437 return (0); 3438 } 3439 shdr_ndx_arr_cnt = 0; 3440 3441 /* 3442 * Traverse the sections of the file. This gathering of data is 3443 * carried out in two passes. First, the section headers are captured 3444 * and the section header names are evaluated. A verification pass is 3445 * then carried out over the section information. Files have been 3446 * known to exhibit overlapping (and hence erroneous) section header 3447 * information. 3448 * 3449 * Finally, the data for each section is obtained. This processing is 3450 * carried out after section verification because should any section 3451 * header overlap occur, and a file needs translating (ie. xlate'ing 3452 * information from a non-native architecture file), then the process 3453 * of translation can corrupt the section header information. Of 3454 * course, if there is any section overlap, the data related to the 3455 * sections is going to be compromised. However, it is the translation 3456 * of this data that has caused problems with elfdump()'s ability to 3457 * extract the data. 3458 */ 3459 for (ndx = 1, scn = NULL; scn = elf_nextscn(elf, scn); 3460 ndx++, _cache++) { 3461 char scnndxnm[100]; 3462 3463 _cache->c_ndx = ndx; 3464 _cache->c_scn = scn; 3465 3466 if ((_cache->c_shdr = elf_getshdr(scn)) == NULL) { 3467 failure(file, MSG_ORIG(MSG_ELF_GETSHDR)); 3468 (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SCN), 3469 EC_WORD(elf_ndxscn(scn))); 3470 } 3471 3472 /* 3473 * If this section has data in the file, include it in 3474 * the array of sections to check for address overlap. 3475 */ 3476 if ((_cache->c_shdr->sh_size != 0) && 3477 (_cache->c_shdr->sh_type != SHT_NOBITS)) 3478 shdr_ndx_arr[shdr_ndx_arr_cnt++] = ndx; 3479 3480 /* 3481 * If a shstrtab exists, assign the section name. 3482 */ 3483 if (names && _cache->c_shdr) { 3484 if (_cache->c_shdr->sh_name && 3485 /* LINTED */ 3486 (nameshdr->sh_size > _cache->c_shdr->sh_name)) { 3487 _cache->c_name = 3488 names + _cache->c_shdr->sh_name; 3489 continue; 3490 } 3491 3492 /* 3493 * Generate an error if the section name index is zero 3494 * or exceeds the shstrtab data. Fall through to 3495 * fabricate a section name. 3496 */ 3497 if ((_cache->c_shdr->sh_name == 0) || 3498 /* LINTED */ 3499 (nameshdr->sh_size <= _cache->c_shdr->sh_name)) { 3500 (void) fprintf(stderr, 3501 MSG_INTL(MSG_ERR_BADSHNAME), file, 3502 EC_WORD(ndx), 3503 EC_XWORD(_cache->c_shdr->sh_name)); 3504 } 3505 } 3506 3507 /* 3508 * If there exists no shstrtab data, or a section header has no 3509 * name (an invalid index of 0), then compose a name for the 3510 * section. 3511 */ 3512 (void) snprintf(scnndxnm, sizeof (scnndxnm), 3513 MSG_INTL(MSG_FMT_SCNNDX), ndx); 3514 3515 if ((_cache->c_name = malloc(strlen(scnndxnm) + 1)) == NULL) { 3516 int err = errno; 3517 (void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC), 3518 file, strerror(err)); 3519 return (0); 3520 } 3521 (void) strcpy(_cache->c_name, scnndxnm); 3522 } 3523 3524 /* 3525 * Having collected all the sections, validate their address range. 3526 * Cases have existed where the section information has been invalid. 3527 * This can lead to all sorts of other, hard to diagnose errors, as 3528 * each section is processed individually (ie. with elf_getdata()). 3529 * Here, we carry out some address comparisons to catch a family of 3530 * overlapping memory issues we have observed (likely, there are others 3531 * that we have yet to discover). 3532 * 3533 * Note, should any memory overlap occur, obtaining any additional 3534 * data from the file is questionable. However, it might still be 3535 * possible to inspect the ELF header, Programs headers, or individual 3536 * sections, so rather than bailing on an error condition, continue 3537 * processing to see if any data can be salvaged. 3538 */ 3539 if (shdr_ndx_arr_cnt > 1) { 3540 sort_shdr_ndx_arr_cache = cache; 3541 qsort(shdr_ndx_arr, shdr_ndx_arr_cnt, 3542 sizeof (*shdr_ndx_arr), sort_shdr_ndx_arr); 3543 } 3544 for (ndx = 0; ndx < shdr_ndx_arr_cnt; ndx++) { 3545 Cache *_cache = cache + shdr_ndx_arr[ndx]; 3546 Shdr *shdr = _cache->c_shdr; 3547 Off bgn1, bgn = shdr->sh_offset; 3548 Off end1, end = shdr->sh_offset + shdr->sh_size; 3549 size_t ndx1; 3550 3551 /* 3552 * Check the section against all following ones, reporting 3553 * any overlaps. Since we've sorted the sections by offset, 3554 * we can stop after the first comparison that fails. There 3555 * are no overlaps in a properly formed ELF file, in which 3556 * case this algorithm runs in O(n) time. This will degenerate 3557 * to O(n^2) for a completely broken file. Such a file is 3558 * (1) highly unlikely, and (2) unusable, so it is reasonable 3559 * for the analysis to take longer. 3560 */ 3561 for (ndx1 = ndx + 1; ndx1 < shdr_ndx_arr_cnt; ndx1++) { 3562 Cache *_cache1 = cache + shdr_ndx_arr[ndx1]; 3563 Shdr *shdr1 = _cache1->c_shdr; 3564 3565 bgn1 = shdr1->sh_offset; 3566 end1 = shdr1->sh_offset + shdr1->sh_size; 3567 3568 if (((bgn1 <= bgn) && (end1 > bgn)) || 3569 ((bgn1 < end) && (end1 >= end))) { 3570 (void) fprintf(stderr, 3571 MSG_INTL(MSG_ERR_SECMEMOVER), file, 3572 EC_WORD(elf_ndxscn(_cache->c_scn)), 3573 _cache->c_name, EC_OFF(bgn), EC_OFF(end), 3574 EC_WORD(elf_ndxscn(_cache1->c_scn)), 3575 _cache1->c_name, EC_OFF(bgn1), 3576 EC_OFF(end1)); 3577 } else { /* No overlap, so can stop */ 3578 break; 3579 } 3580 } 3581 3582 /* 3583 * In addition to checking for sections overlapping 3584 * each other (done above), we should also make sure 3585 * the section doesn't overlap the section header array. 3586 */ 3587 bgn1 = ehdr->e_shoff; 3588 end1 = ehdr->e_shoff + (ehdr->e_shentsize * ehdr->e_shnum); 3589 3590 if (((bgn1 <= bgn) && (end1 > bgn)) || 3591 ((bgn1 < end) && (end1 >= end))) { 3592 (void) fprintf(stderr, 3593 MSG_INTL(MSG_ERR_SHDRMEMOVER), file, EC_OFF(bgn1), 3594 EC_OFF(end1), 3595 EC_WORD(elf_ndxscn(_cache->c_scn)), 3596 _cache->c_name, EC_OFF(bgn), EC_OFF(end)); 3597 } 3598 } 3599 3600 /* 3601 * Obtain the data for each section. 3602 */ 3603 for (ndx = 1; ndx < shnum; ndx++) { 3604 Cache *_cache = &cache[ndx]; 3605 Elf_Scn *scn = _cache->c_scn; 3606 3607 if ((_cache->c_data = elf_getdata(scn, NULL)) == NULL) { 3608 failure(file, MSG_ORIG(MSG_ELF_GETDATA)); 3609 (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SCNDATA), 3610 EC_WORD(elf_ndxscn(scn))); 3611 } 3612 } 3613 3614 return (1); 3615 } 3616 3617 3618 3619 void 3620 regular(const char *file, int fd, Elf *elf, uint_t flags, int wfd) 3621 { 3622 Elf_Scn *scn; 3623 Ehdr *ehdr; 3624 size_t ndx, shstrndx, shnum, phnum; 3625 Shdr *shdr; 3626 Cache *cache; 3627 VERSYM_STATE versym; 3628 3629 if ((ehdr = elf_getehdr(elf)) == NULL) { 3630 failure(file, MSG_ORIG(MSG_ELF_GETEHDR)); 3631 return; 3632 } 3633 3634 if (elf_getshnum(elf, &shnum) == 0) { 3635 failure(file, MSG_ORIG(MSG_ELF_GETSHNUM)); 3636 return; 3637 } 3638 3639 if (elf_getshstrndx(elf, &shstrndx) == 0) { 3640 failure(file, MSG_ORIG(MSG_ELF_GETSHSTRNDX)); 3641 return; 3642 } 3643 3644 if (elf_getphnum(elf, &phnum) == 0) { 3645 failure(file, MSG_ORIG(MSG_ELF_GETPHNUM)); 3646 return; 3647 } 3648 /* 3649 * If the user requested section headers derived from the 3650 * program headers (-P option) and this file doesn't have 3651 * any program headers (i.e. ET_REL), then we can't do it. 3652 */ 3653 if ((phnum == 0) && (flags & FLG_FAKESHDR)) { 3654 (void) fprintf(stderr, MSG_INTL(MSG_ERR_PNEEDSPH), file); 3655 return; 3656 } 3657 3658 3659 if ((scn = elf_getscn(elf, 0)) != NULL) { 3660 if ((shdr = elf_getshdr(scn)) == NULL) { 3661 failure(file, MSG_ORIG(MSG_ELF_GETSHDR)); 3662 (void) fprintf(stderr, MSG_INTL(MSG_ELF_ERR_SCN), 0); 3663 return; 3664 } 3665 } else 3666 shdr = 0; 3667 3668 /* 3669 * Print the elf header. 3670 */ 3671 if (flags & FLG_EHDR) 3672 Elf_ehdr(0, ehdr, shdr); 3673 3674 /* 3675 * If the section headers or program headers have inadequate 3676 * alignment for the class of object, print a warning. libelf 3677 * can handle such files, but programs that use them can crash 3678 * when they dereference unaligned items. 3679 */ 3680 if (ehdr->e_phoff & (sizeof (Addr) - 1)) 3681 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADPHDRALIGN), file); 3682 if (ehdr->e_shoff & (sizeof (Addr) - 1)) 3683 (void) fprintf(stderr, MSG_INTL(MSG_ERR_BADSHDRALIGN), file); 3684 3685 /* 3686 * Print the program headers. 3687 */ 3688 if ((flags & FLG_PHDR) && (phnum != 0)) { 3689 Conv_inv_buf_t inv_buf; 3690 Phdr *phdr; 3691 3692 if ((phdr = elf_getphdr(elf)) == NULL) { 3693 failure(file, MSG_ORIG(MSG_ELF_GETPHDR)); 3694 return; 3695 } 3696 3697 for (ndx = 0; ndx < phnum; phdr++, ndx++) { 3698 if (!match(0, conv_phdr_type(ehdr->e_machine, 3699 phdr->p_type, CONV_FMT_ALT_FILE, &inv_buf), ndx)) 3700 continue; 3701 3702 dbg_print(0, MSG_ORIG(MSG_STR_EMPTY)); 3703 dbg_print(0, MSG_INTL(MSG_ELF_PHDR), EC_WORD(ndx)); 3704 Elf_phdr(0, ehdr->e_machine, phdr); 3705 } 3706 } 3707 3708 /* 3709 * Decide how to proceed if there are no sections, if there's just 3710 * one section (the first section can act as an extension of the 3711 * ELF header), or if only program header information was requested. 3712 */ 3713 if ((shnum <= 1) || (flags && (flags & ~(FLG_EHDR | FLG_PHDR)) == 0)) { 3714 /* If a core file, display the note and return */ 3715 if ((ehdr->e_type == ET_CORE) && (flags & FLG_NOTE)) { 3716 note(0, shnum, file); 3717 return; 3718 } 3719 3720 /* If only program header info was requested, we're done */ 3721 if (flags && (flags & ~(FLG_EHDR | FLG_PHDR)) == 0) 3722 return; 3723 3724 /* 3725 * Section headers are missing. Resort to synthesizing 3726 * section headers from the program headers. 3727 */ 3728 if ((flags & FLG_FAKESHDR) == 0) { 3729 (void) fprintf(stderr, MSG_INTL(MSG_ERR_NOSHDR), file); 3730 flags |= FLG_FAKESHDR; 3731 } 3732 } 3733 3734 /* 3735 * Generate a cache of section headers and related information 3736 * for use by the rest of elfdump. If requested (or the file 3737 * contains no section headers), we generate a fake set of 3738 * headers from the information accessible from the program headers. 3739 * Otherwise, we use the real section headers contained in the file. 3740 */ 3741 3742 if (flags & FLG_FAKESHDR) { 3743 if (fake_shdr_cache(file, fd, elf, ehdr, &cache, &shnum) == 0) 3744 return; 3745 } else { 3746 if (shdr_cache(file, elf, ehdr, shstrndx, shnum, &cache) == 0) 3747 return; 3748 } 3749 3750 /* 3751 * If -w was specified, find and write out the section(s) data. 3752 */ 3753 if (wfd) { 3754 for (ndx = 1; ndx < shnum; ndx++) { 3755 Cache *_cache = &cache[ndx]; 3756 3757 if (match(1, _cache->c_name, ndx) && _cache->c_data) { 3758 (void) write(wfd, _cache->c_data->d_buf, 3759 _cache->c_data->d_size); 3760 } 3761 } 3762 } 3763 3764 if (flags & FLG_SHDR) 3765 sections(file, cache, shnum, ehdr); 3766 3767 if (flags & FLG_INTERP) 3768 interp(file, cache, shnum, phnum, elf); 3769 3770 versions(cache, shnum, file, flags, &versym); 3771 3772 if (flags & FLG_SYMBOLS) 3773 symbols(cache, shnum, ehdr, &versym, file, flags); 3774 3775 if (flags & FLG_SORT) 3776 sunw_sort(cache, shnum, ehdr, &versym, file, flags); 3777 3778 if (flags & FLG_HASH) 3779 hash(cache, shnum, file, flags); 3780 3781 if (flags & FLG_GOT) 3782 got(cache, shnum, ehdr, file, flags); 3783 3784 if (flags & FLG_GROUP) 3785 group(cache, shnum, file, flags); 3786 3787 if (flags & FLG_SYMINFO) 3788 syminfo(cache, shnum, file); 3789 3790 if (flags & FLG_RELOC) 3791 reloc(cache, shnum, ehdr, file, flags); 3792 3793 if (flags & FLG_DYNAMIC) 3794 dynamic(cache, shnum, ehdr, file); 3795 3796 if (flags & FLG_NOTE) 3797 note(cache, shnum, file); 3798 3799 if (flags & FLG_MOVE) 3800 move(cache, shnum, file, flags); 3801 3802 if (flags & FLG_CHECKSUM) 3803 checksum(elf); 3804 3805 if (flags & FLG_CAP) 3806 cap(file, cache, shnum, phnum, ehdr, elf); 3807 3808 if (flags & FLG_UNWIND) 3809 unwind(cache, shnum, phnum, ehdr, file, elf); 3810 3811 3812 /* Release the memory used to cache section headers */ 3813 if (flags & FLG_FAKESHDR) 3814 fake_shdr_cache_free(cache, shnum); 3815 else 3816 free(cache); 3817 } 3818