1 /* Discard section not used at runtime from object files. 2 Copyright (C) 2000-2012, 2014, 2015 Red Hat, Inc. 3 This file is part of elfutils. 4 Written by Ulrich Drepper <drepper (at) redhat.com>, 2000. 5 6 This file is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 elfutils is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #ifdef HAVE_CONFIG_H 20 # include <config.h> 21 #endif 22 23 #include <argp.h> 24 #include <assert.h> 25 #include <byteswap.h> 26 #include <endian.h> 27 #include <error.h> 28 #include <fcntl.h> 29 #include <gelf.h> 30 #include <libelf.h> 31 #include <libintl.h> 32 #include <locale.h> 33 #include <stdbool.h> 34 #include <stdio.h> 35 #include <stdio_ext.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <unistd.h> 39 #include <sys/param.h> 40 #include <sys/stat.h> 41 #include <sys/time.h> 42 43 #include <elf-knowledge.h> 44 #include <libebl.h> 45 #include <system.h> 46 47 typedef uint8_t GElf_Byte; 48 49 /* Name and version of program. */ 50 static void print_version (FILE *stream, struct argp_state *state); 51 ARGP_PROGRAM_VERSION_HOOK_DEF = print_version; 52 53 /* Bug report address. */ 54 ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT; 55 56 57 /* Values for the parameters which have no short form. */ 58 #define OPT_REMOVE_COMMENT 0x100 59 #define OPT_PERMISSIVE 0x101 60 #define OPT_STRIP_SECTIONS 0x102 61 #define OPT_RELOC_DEBUG 0x103 62 63 64 /* Definitions of arguments for argp functions. */ 65 static const struct argp_option options[] = 66 { 67 { NULL, 0, NULL, 0, N_("Output selection:"), 0 }, 68 { "output", 'o', "FILE", 0, N_("Place stripped output into FILE"), 0 }, 69 { NULL, 'f', "FILE", 0, N_("Extract the removed sections into FILE"), 0 }, 70 { NULL, 'F', "FILE", 0, N_("Embed name FILE instead of -f argument"), 0 }, 71 72 { NULL, 0, NULL, 0, N_("Output options:"), 0 }, 73 { "strip-all", 's', NULL, OPTION_HIDDEN, NULL, 0 }, 74 { "strip-debug", 'g', NULL, 0, N_("Remove all debugging symbols"), 0 }, 75 { NULL, 'd', NULL, OPTION_ALIAS, NULL, 0 }, 76 { NULL, 'S', NULL, OPTION_ALIAS, NULL, 0 }, 77 { "strip-sections", OPT_STRIP_SECTIONS, NULL, 0, 78 N_("Remove section headers (not recommended)"), 0 }, 79 { "preserve-dates", 'p', NULL, 0, 80 N_("Copy modified/access timestamps to the output"), 0 }, 81 { "reloc-debug-sections", OPT_RELOC_DEBUG, NULL, 0, 82 N_("Resolve all trivial relocations between debug sections if the removed sections are placed in a debug file (only relevant for ET_REL files, operation is not reversable, needs -f)"), 0 }, 83 { "remove-comment", OPT_REMOVE_COMMENT, NULL, 0, 84 N_("Remove .comment section"), 0 }, 85 { "remove-section", 'R', "SECTION", OPTION_HIDDEN, NULL, 0 }, 86 { "permissive", OPT_PERMISSIVE, NULL, 0, 87 N_("Relax a few rules to handle slightly broken ELF files"), 0 }, 88 { NULL, 0, NULL, 0, NULL, 0 } 89 }; 90 91 /* Short description of program. */ 92 static const char doc[] = N_("Discard symbols from object files."); 93 94 /* Strings for arguments in help texts. */ 95 static const char args_doc[] = N_("[FILE...]"); 96 97 /* Prototype for option handler. */ 98 static error_t parse_opt (int key, char *arg, struct argp_state *state); 99 100 /* Data structure to communicate with argp functions. */ 101 static struct argp argp = 102 { 103 options, parse_opt, args_doc, doc, NULL, NULL, NULL 104 }; 105 106 107 /* Print symbols in file named FNAME. */ 108 static int process_file (const char *fname); 109 110 /* Handle one ELF file. */ 111 static int handle_elf (int fd, Elf *elf, const char *prefix, 112 const char *fname, mode_t mode, struct timespec tvp[2]); 113 114 /* Handle all files contained in the archive. */ 115 static int handle_ar (int fd, Elf *elf, const char *prefix, const char *fname, 116 struct timespec tvp[2]) __attribute__ ((unused)); 117 118 static int debug_fd = -1; 119 static char *tmp_debug_fname = NULL; 120 121 /* Close debug file descriptor, if opened. And remove temporary debug file. */ 122 static void cleanup_debug (void); 123 124 #define INTERNAL_ERROR(fname) \ 125 do { \ 126 cleanup_debug (); \ 127 error (EXIT_FAILURE, 0, gettext ("%s: INTERNAL ERROR %d (%s): %s"), \ 128 fname, __LINE__, PACKAGE_VERSION, elf_errmsg (-1)); \ 129 } while (0) 130 131 132 /* Name of the output file. */ 133 static const char *output_fname; 134 135 /* Name of the debug output file. */ 136 static const char *debug_fname; 137 138 /* Name to pretend the debug output file has. */ 139 static const char *debug_fname_embed; 140 141 /* If true output files shall have same date as the input file. */ 142 static bool preserve_dates; 143 144 /* If true .comment sections will be removed. */ 145 static bool remove_comment; 146 147 /* If true remove all debug sections. */ 148 static bool remove_debug; 149 150 /* If true remove all section headers. */ 151 static bool remove_shdrs; 152 153 /* If true relax some ELF rules for input files. */ 154 static bool permissive; 155 156 /* If true perform relocations between debug sections. */ 157 static bool reloc_debug; 158 159 160 int 161 main (int argc, char *argv[]) 162 { 163 int remaining; 164 int result = 0; 165 166 /* We use no threads here which can interfere with handling a stream. */ 167 __fsetlocking (stdin, FSETLOCKING_BYCALLER); 168 __fsetlocking (stdout, FSETLOCKING_BYCALLER); 169 __fsetlocking (stderr, FSETLOCKING_BYCALLER); 170 171 /* Set locale. */ 172 setlocale (LC_ALL, ""); 173 174 /* Make sure the message catalog can be found. */ 175 bindtextdomain (PACKAGE_TARNAME, LOCALEDIR); 176 177 /* Initialize the message catalog. */ 178 textdomain (PACKAGE_TARNAME); 179 180 /* Parse and process arguments. */ 181 if (argp_parse (&argp, argc, argv, 0, &remaining, NULL) != 0) 182 return EXIT_FAILURE; 183 184 if (reloc_debug && debug_fname == NULL) 185 error (EXIT_FAILURE, 0, 186 gettext ("--reloc-debug-sections used without -f")); 187 188 /* Tell the library which version we are expecting. */ 189 elf_version (EV_CURRENT); 190 191 if (remaining == argc) 192 /* The user didn't specify a name so we use a.out. */ 193 result = process_file ("a.out"); 194 else 195 { 196 /* If we have seen the '-o' or '-f' option there must be exactly one 197 input file. */ 198 if ((output_fname != NULL || debug_fname != NULL) 199 && remaining + 1 < argc) 200 error (EXIT_FAILURE, 0, gettext ("\ 201 Only one input file allowed together with '-o' and '-f'")); 202 203 /* Process all the remaining files. */ 204 do 205 result |= process_file (argv[remaining]); 206 while (++remaining < argc); 207 } 208 209 return result; 210 } 211 212 213 /* Print the version information. */ 214 static void 215 print_version (FILE *stream, struct argp_state *state __attribute__ ((unused))) 216 { 217 fprintf (stream, "strip (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION); 218 fprintf (stream, gettext ("\ 219 Copyright (C) %s Red Hat, Inc.\n\ 220 This is free software; see the source for copying conditions. There is NO\n\ 221 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\ 222 "), "2012"); 223 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper"); 224 } 225 226 227 /* Handle program arguments. */ 228 static error_t 229 parse_opt (int key, char *arg, struct argp_state *state) 230 { 231 switch (key) 232 { 233 case 'f': 234 if (debug_fname != NULL) 235 { 236 error (0, 0, gettext ("-f option specified twice")); 237 return EINVAL; 238 } 239 debug_fname = arg; 240 break; 241 242 case 'F': 243 if (debug_fname_embed != NULL) 244 { 245 error (0, 0, gettext ("-F option specified twice")); 246 return EINVAL; 247 } 248 debug_fname_embed = arg; 249 break; 250 251 case 'o': 252 if (output_fname != NULL) 253 { 254 error (0, 0, gettext ("-o option specified twice")); 255 return EINVAL; 256 } 257 output_fname = arg; 258 break; 259 260 case 'p': 261 preserve_dates = true; 262 break; 263 264 case OPT_RELOC_DEBUG: 265 reloc_debug = true; 266 break; 267 268 case OPT_REMOVE_COMMENT: 269 remove_comment = true; 270 break; 271 272 case 'R': 273 if (!strcmp (arg, ".comment")) 274 remove_comment = true; 275 else 276 { 277 argp_error (state, 278 gettext ("-R option supports only .comment section")); 279 return EINVAL; 280 } 281 break; 282 283 case 'g': 284 case 'd': 285 case 'S': 286 remove_debug = true; 287 break; 288 289 case OPT_STRIP_SECTIONS: 290 remove_shdrs = true; 291 break; 292 293 case OPT_PERMISSIVE: 294 permissive = true; 295 break; 296 297 case 's': /* Ignored for compatibility. */ 298 break; 299 300 default: 301 return ARGP_ERR_UNKNOWN; 302 } 303 return 0; 304 } 305 306 307 static int 308 process_file (const char *fname) 309 { 310 /* If we have to preserve the modify and access timestamps get them 311 now. We cannot use fstat() after opening the file since the open 312 would change the access time. */ 313 struct stat pre_st; 314 struct timespec tv[2]; 315 again: 316 if (preserve_dates) 317 { 318 if (stat (fname, &pre_st) != 0) 319 { 320 error (0, errno, gettext ("cannot stat input file '%s'"), fname); 321 return 1; 322 } 323 324 /* If we have to preserve the timestamp, we need it in the 325 format utimes() understands. */ 326 tv[0] = pre_st.st_atim; 327 tv[1] = pre_st.st_mtim; 328 } 329 330 /* Open the file. */ 331 int fd = open (fname, output_fname == NULL ? O_RDWR : O_RDONLY); 332 if (fd == -1) 333 { 334 error (0, errno, gettext ("while opening '%s'"), fname); 335 return 1; 336 } 337 338 /* We always use fstat() even if we called stat() before. This is 339 done to make sure the information returned by stat() is for the 340 same file. */ 341 struct stat st; 342 if (fstat (fd, &st) != 0) 343 { 344 error (0, errno, gettext ("cannot stat input file '%s'"), fname); 345 return 1; 346 } 347 /* Paranoid mode on. */ 348 if (preserve_dates 349 && (st.st_ino != pre_st.st_ino || st.st_dev != pre_st.st_dev)) 350 { 351 /* We detected a race. Try again. */ 352 close (fd); 353 goto again; 354 } 355 356 /* Now get the ELF descriptor. */ 357 Elf *elf = elf_begin (fd, output_fname == NULL ? ELF_C_RDWR : ELF_C_READ, 358 NULL); 359 int result; 360 switch (elf_kind (elf)) 361 { 362 case ELF_K_ELF: 363 result = handle_elf (fd, elf, NULL, fname, st.st_mode & ACCESSPERMS, 364 preserve_dates ? tv : NULL); 365 break; 366 367 case ELF_K_AR: 368 /* It is not possible to strip the content of an archive direct 369 the output to a specific file. */ 370 if (unlikely (output_fname != NULL || debug_fname != NULL)) 371 { 372 error (0, 0, gettext ("%s: cannot use -o or -f when stripping archive"), 373 fname); 374 result = 1; 375 } 376 else 377 { 378 /* We would like to support ar archives, but currently it just 379 doesn't work at all since we call elf_clone on the members 380 which doesn't really support ar members. 381 result = handle_ar (fd, elf, NULL, fname, 382 preserve_dates ? tv : NULL); 383 */ 384 error (0, 0, gettext ("%s: no support for stripping archive"), 385 fname); 386 result = 1; 387 } 388 break; 389 390 default: 391 error (0, 0, gettext ("%s: File format not recognized"), fname); 392 result = 1; 393 break; 394 } 395 396 if (unlikely (elf_end (elf) != 0)) 397 INTERNAL_ERROR (fname); 398 399 close (fd); 400 401 return result; 402 } 403 404 405 /* Maximum size of array allocated on stack. */ 406 #define MAX_STACK_ALLOC (400 * 1024) 407 408 static int 409 handle_elf (int fd, Elf *elf, const char *prefix, const char *fname, 410 mode_t mode, struct timespec tvp[2]) 411 { 412 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix); 413 size_t fname_len = strlen (fname) + 1; 414 char *fullname = alloca (prefix_len + 1 + fname_len); 415 char *cp = fullname; 416 Elf *debugelf = NULL; 417 tmp_debug_fname = NULL; 418 int result = 0; 419 size_t shdridx = 0; 420 size_t shstrndx; 421 struct shdr_info 422 { 423 Elf_Scn *scn; 424 GElf_Shdr shdr; 425 Elf_Data *data; 426 Elf_Data *debug_data; 427 const char *name; 428 Elf32_Word idx; /* Index in new file. */ 429 Elf32_Word old_sh_link; /* Original value of shdr.sh_link. */ 430 Elf32_Word symtab_idx; 431 Elf32_Word version_idx; 432 Elf32_Word group_idx; 433 Elf32_Word group_cnt; 434 Elf_Scn *newscn; 435 struct Ebl_Strent *se; 436 Elf32_Word *newsymidx; 437 } *shdr_info = NULL; 438 Elf_Scn *scn; 439 size_t cnt; 440 size_t idx; 441 bool changes; 442 GElf_Ehdr newehdr_mem; 443 GElf_Ehdr *newehdr; 444 GElf_Ehdr debugehdr_mem; 445 GElf_Ehdr *debugehdr; 446 struct Ebl_Strtab *shst = NULL; 447 Elf_Data debuglink_crc_data; 448 bool any_symtab_changes = false; 449 Elf_Data *shstrtab_data = NULL; 450 void *debuglink_buf = NULL; 451 452 /* Create the full name of the file. */ 453 if (prefix != NULL) 454 { 455 cp = mempcpy (cp, prefix, prefix_len); 456 *cp++ = ':'; 457 } 458 memcpy (cp, fname, fname_len); 459 460 /* If we are not replacing the input file open a new file here. */ 461 if (output_fname != NULL) 462 { 463 fd = open (output_fname, O_RDWR | O_CREAT, mode); 464 if (unlikely (fd == -1)) 465 { 466 error (0, errno, gettext ("cannot open '%s'"), output_fname); 467 return 1; 468 } 469 } 470 471 debug_fd = -1; 472 473 /* Get the EBL handling. Removing all debugging symbols with the -g 474 option or resolving all relocations between debug sections with 475 the --reloc-debug-sections option are currently the only reasons 476 we need EBL so don't open the backend unless necessary. */ 477 Ebl *ebl = NULL; 478 if (remove_debug || reloc_debug) 479 { 480 ebl = ebl_openbackend (elf); 481 if (ebl == NULL) 482 { 483 error (0, errno, gettext ("cannot open EBL backend")); 484 result = 1; 485 goto fail; 486 } 487 } 488 489 /* Open the additional file the debug information will be stored in. */ 490 if (debug_fname != NULL) 491 { 492 /* Create a temporary file name. We do not want to overwrite 493 the debug file if the file would not contain any 494 information. */ 495 size_t debug_fname_len = strlen (debug_fname); 496 tmp_debug_fname = (char *) xmalloc (debug_fname_len + sizeof (".XXXXXX")); 497 strcpy (mempcpy (tmp_debug_fname, debug_fname, debug_fname_len), 498 ".XXXXXX"); 499 500 debug_fd = mkstemp (tmp_debug_fname); 501 if (unlikely (debug_fd == -1)) 502 { 503 error (0, errno, gettext ("cannot open '%s'"), debug_fname); 504 result = 1; 505 goto fail; 506 } 507 } 508 509 /* Get the information from the old file. */ 510 GElf_Ehdr ehdr_mem; 511 GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem); 512 if (ehdr == NULL) 513 INTERNAL_ERROR (fname); 514 515 /* Get the section header string table index. */ 516 if (unlikely (elf_getshdrstrndx (elf, &shstrndx) < 0)) 517 { 518 cleanup_debug (); 519 error (EXIT_FAILURE, 0, 520 gettext ("cannot get section header string table index")); 521 } 522 523 /* Get the number of phdrs in the old file. */ 524 size_t phnum; 525 if (elf_getphdrnum (elf, &phnum) != 0) 526 { 527 cleanup_debug (); 528 error (EXIT_FAILURE, 0, gettext ("cannot get number of phdrs")); 529 } 530 531 /* We now create a new ELF descriptor for the same file. We 532 construct it almost exactly in the same way with some information 533 dropped. */ 534 Elf *newelf; 535 if (output_fname != NULL) 536 newelf = elf_begin (fd, ELF_C_WRITE_MMAP, NULL); 537 else 538 newelf = elf_clone (elf, ELF_C_EMPTY); 539 540 if (unlikely (gelf_newehdr (newelf, gelf_getclass (elf)) == 0) 541 || (ehdr->e_type != ET_REL 542 && unlikely (gelf_newphdr (newelf, phnum) == 0))) 543 { 544 error (0, 0, gettext ("cannot create new file '%s': %s"), 545 output_fname ?: fname, elf_errmsg (-1)); 546 goto fail; 547 } 548 549 /* Copy over the old program header if needed. */ 550 if (ehdr->e_type != ET_REL) 551 for (cnt = 0; cnt < phnum; ++cnt) 552 { 553 GElf_Phdr phdr_mem; 554 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem); 555 if (phdr == NULL 556 || unlikely (gelf_update_phdr (newelf, cnt, phdr) == 0)) 557 INTERNAL_ERROR (fname); 558 } 559 560 if (debug_fname != NULL) 561 { 562 /* Also create an ELF descriptor for the debug file */ 563 debugelf = elf_begin (debug_fd, ELF_C_WRITE_MMAP, NULL); 564 if (unlikely (gelf_newehdr (debugelf, gelf_getclass (elf)) == 0) 565 || (ehdr->e_type != ET_REL 566 && unlikely (gelf_newphdr (debugelf, phnum) == 0))) 567 { 568 error (0, 0, gettext ("cannot create new file '%s': %s"), 569 debug_fname, elf_errmsg (-1)); 570 goto fail_close; 571 } 572 573 /* Copy over the old program header if needed. */ 574 if (ehdr->e_type != ET_REL) 575 for (cnt = 0; cnt < phnum; ++cnt) 576 { 577 GElf_Phdr phdr_mem; 578 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem); 579 if (phdr == NULL 580 || unlikely (gelf_update_phdr (debugelf, cnt, phdr) == 0)) 581 INTERNAL_ERROR (fname); 582 } 583 } 584 585 /* Number of sections. */ 586 size_t shnum; 587 if (unlikely (elf_getshdrnum (elf, &shnum) < 0)) 588 { 589 error (0, 0, gettext ("cannot determine number of sections: %s"), 590 elf_errmsg (-1)); 591 goto fail_close; 592 } 593 594 if (shstrndx >= shnum) 595 goto illformed; 596 597 #define elf_assert(test) do { if (!(test)) goto illformed; } while (0) 598 599 /* Storage for section information. We leave room for two more 600 entries since we unconditionally create a section header string 601 table. Maybe some weird tool created an ELF file without one. 602 The other one is used for the debug link section. */ 603 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC) 604 shdr_info = (struct shdr_info *) xcalloc (shnum + 2, 605 sizeof (struct shdr_info)); 606 else 607 { 608 shdr_info = (struct shdr_info *) alloca ((shnum + 2) 609 * sizeof (struct shdr_info)); 610 memset (shdr_info, '\0', (shnum + 2) * sizeof (struct shdr_info)); 611 } 612 613 /* Prepare section information data structure. */ 614 scn = NULL; 615 cnt = 1; 616 while ((scn = elf_nextscn (elf, scn)) != NULL) 617 { 618 /* This should always be true (i.e., there should not be any 619 holes in the numbering). */ 620 elf_assert (elf_ndxscn (scn) == cnt); 621 622 shdr_info[cnt].scn = scn; 623 624 /* Get the header. */ 625 if (gelf_getshdr (scn, &shdr_info[cnt].shdr) == NULL) 626 INTERNAL_ERROR (fname); 627 628 /* Get the name of the section. */ 629 shdr_info[cnt].name = elf_strptr (elf, shstrndx, 630 shdr_info[cnt].shdr.sh_name); 631 if (shdr_info[cnt].name == NULL) 632 { 633 illformed: 634 error (0, 0, gettext ("illformed file '%s'"), fname); 635 goto fail_close; 636 } 637 638 /* Mark them as present but not yet investigated. */ 639 shdr_info[cnt].idx = 1; 640 641 /* Remember the shdr.sh_link value. */ 642 shdr_info[cnt].old_sh_link = shdr_info[cnt].shdr.sh_link; 643 if (shdr_info[cnt].old_sh_link >= shnum) 644 goto illformed; 645 646 /* Sections in files other than relocatable object files which 647 not loaded can be freely moved by us. In theory we can also 648 freely move around allocated nobits sections. But we don't 649 to keep the layout of all allocated sections as similar as 650 possible to the original file. In relocatable object files 651 everything can be moved. */ 652 if (ehdr->e_type == ET_REL 653 || (shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) == 0) 654 shdr_info[cnt].shdr.sh_offset = 0; 655 656 /* If this is an extended section index table store an 657 appropriate reference. */ 658 if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX)) 659 { 660 elf_assert (shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx == 0); 661 shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx = cnt; 662 } 663 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GROUP)) 664 { 665 /* Cross-reference the sections contained in the section 666 group. */ 667 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL); 668 if (shdr_info[cnt].data == NULL 669 || shdr_info[cnt].data->d_size < sizeof (Elf32_Word)) 670 INTERNAL_ERROR (fname); 671 672 /* XXX Fix for unaligned access. */ 673 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf; 674 size_t inner; 675 for (inner = 1; 676 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word); 677 ++inner) 678 { 679 if (grpref[inner] < shnum) 680 shdr_info[grpref[inner]].group_idx = cnt; 681 else 682 goto illformed; 683 } 684 685 if (inner == 1 || (inner == 2 && (grpref[0] & GRP_COMDAT) == 0)) 686 /* If the section group contains only one element and this 687 is n COMDAT section we can drop it right away. */ 688 shdr_info[cnt].idx = 0; 689 else 690 shdr_info[cnt].group_cnt = inner - 1; 691 } 692 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GNU_versym)) 693 { 694 elf_assert (shdr_info[shdr_info[cnt].shdr.sh_link].version_idx == 0); 695 shdr_info[shdr_info[cnt].shdr.sh_link].version_idx = cnt; 696 } 697 698 /* If this section is part of a group make sure it is not 699 discarded right away. */ 700 if ((shdr_info[cnt].shdr.sh_flags & SHF_GROUP) != 0) 701 { 702 elf_assert (shdr_info[cnt].group_idx != 0); 703 704 if (shdr_info[shdr_info[cnt].group_idx].idx == 0) 705 { 706 /* The section group section will be removed. */ 707 shdr_info[cnt].group_idx = 0; 708 shdr_info[cnt].shdr.sh_flags &= ~SHF_GROUP; 709 } 710 } 711 712 /* Increment the counter. */ 713 ++cnt; 714 } 715 716 /* Now determine which sections can go away. The general rule is that 717 all sections which are not used at runtime are stripped out. But 718 there are a few exceptions: 719 720 - special sections named ".comment" and ".note" are kept 721 - OS or architecture specific sections are kept since we might not 722 know how to handle them 723 - if a section is referred to from a section which is not removed 724 in the sh_link or sh_info element it cannot be removed either 725 */ 726 for (cnt = 1; cnt < shnum; ++cnt) 727 /* Check whether the section can be removed. */ 728 if (remove_shdrs ? !(shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) 729 : ebl_section_strip_p (ebl, ehdr, &shdr_info[cnt].shdr, 730 shdr_info[cnt].name, remove_comment, 731 remove_debug)) 732 { 733 /* For now assume this section will be removed. */ 734 shdr_info[cnt].idx = 0; 735 736 idx = shdr_info[cnt].group_idx; 737 while (idx != 0) 738 { 739 /* The section group data is already loaded. */ 740 elf_assert (shdr_info[idx].data != NULL 741 && shdr_info[idx].data->d_buf != NULL 742 && shdr_info[idx].data->d_size >= sizeof (Elf32_Word)); 743 744 /* If the references section group is a normal section 745 group and has one element remaining, or if it is an 746 empty COMDAT section group it is removed. */ 747 bool is_comdat = (((Elf32_Word *) shdr_info[idx].data->d_buf)[0] 748 & GRP_COMDAT) != 0; 749 750 --shdr_info[idx].group_cnt; 751 if ((!is_comdat && shdr_info[idx].group_cnt == 1) 752 || (is_comdat && shdr_info[idx].group_cnt == 0)) 753 { 754 shdr_info[idx].idx = 0; 755 /* Continue recursively. */ 756 idx = shdr_info[idx].group_idx; 757 } 758 else 759 break; 760 } 761 } 762 763 /* Mark the SHT_NULL section as handled. */ 764 shdr_info[0].idx = 2; 765 766 767 /* Handle exceptions: section groups and cross-references. We might 768 have to repeat this a few times since the resetting of the flag 769 might propagate. */ 770 do 771 { 772 changes = false; 773 774 for (cnt = 1; cnt < shnum; ++cnt) 775 { 776 if (shdr_info[cnt].idx == 0) 777 { 778 /* If a relocation section is marked as being removed make 779 sure the section it is relocating is removed, too. */ 780 if (shdr_info[cnt].shdr.sh_type == SHT_REL 781 || shdr_info[cnt].shdr.sh_type == SHT_RELA) 782 { 783 if (shdr_info[cnt].shdr.sh_info >= shnum) 784 goto illformed; 785 else if (shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0) 786 shdr_info[cnt].idx = 1; 787 } 788 789 /* If a group section is marked as being removed make 790 sure all the sections it contains are being removed, too. */ 791 if (shdr_info[cnt].shdr.sh_type == SHT_GROUP) 792 { 793 Elf32_Word *grpref; 794 grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf; 795 for (size_t in = 1; 796 in < shdr_info[cnt].data->d_size / sizeof (Elf32_Word); 797 ++in) 798 if (grpref[in] < shnum) 799 { 800 if (shdr_info[grpref[in]].idx != 0) 801 { 802 shdr_info[cnt].idx = 1; 803 break; 804 } 805 } 806 else 807 goto illformed; 808 } 809 } 810 811 if (shdr_info[cnt].idx == 1) 812 { 813 /* The content of symbol tables we don't remove must not 814 reference any section which we do remove. Otherwise 815 we cannot remove the section. */ 816 if (debug_fname != NULL 817 && shdr_info[cnt].debug_data == NULL 818 && (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM 819 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB)) 820 { 821 /* Make sure the data is loaded. */ 822 if (shdr_info[cnt].data == NULL) 823 { 824 shdr_info[cnt].data 825 = elf_getdata (shdr_info[cnt].scn, NULL); 826 if (shdr_info[cnt].data == NULL) 827 INTERNAL_ERROR (fname); 828 } 829 Elf_Data *symdata = shdr_info[cnt].data; 830 831 /* If there is an extended section index table load it 832 as well. */ 833 if (shdr_info[cnt].symtab_idx != 0 834 && shdr_info[shdr_info[cnt].symtab_idx].data == NULL) 835 { 836 elf_assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB); 837 838 shdr_info[shdr_info[cnt].symtab_idx].data 839 = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn, 840 NULL); 841 if (shdr_info[shdr_info[cnt].symtab_idx].data == NULL) 842 INTERNAL_ERROR (fname); 843 } 844 Elf_Data *xndxdata 845 = shdr_info[shdr_info[cnt].symtab_idx].data; 846 847 /* Go through all symbols and make sure the section they 848 reference is not removed. */ 849 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT); 850 851 for (size_t inner = 0; 852 inner < shdr_info[cnt].data->d_size / elsize; 853 ++inner) 854 { 855 GElf_Sym sym_mem; 856 Elf32_Word xndx; 857 GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata, 858 inner, &sym_mem, 859 &xndx); 860 if (sym == NULL) 861 INTERNAL_ERROR (fname); 862 863 size_t scnidx = sym->st_shndx; 864 if (scnidx == SHN_UNDEF || scnidx >= shnum 865 || (scnidx >= SHN_LORESERVE 866 && scnidx <= SHN_HIRESERVE 867 && scnidx != SHN_XINDEX) 868 /* Don't count in the section symbols. */ 869 || GELF_ST_TYPE (sym->st_info) == STT_SECTION) 870 /* This is no section index, leave it alone. */ 871 continue; 872 else if (scnidx == SHN_XINDEX) 873 scnidx = xndx; 874 875 if (scnidx >= shnum) 876 goto illformed; 877 878 if (shdr_info[scnidx].idx == 0) 879 /* This symbol table has a real symbol in 880 a discarded section. So preserve the 881 original table in the debug file. */ 882 shdr_info[cnt].debug_data = symdata; 883 } 884 } 885 886 /* Cross referencing happens: 887 - for the cases the ELF specification says. That are 888 + SHT_DYNAMIC in sh_link to string table 889 + SHT_HASH in sh_link to symbol table 890 + SHT_REL and SHT_RELA in sh_link to symbol table 891 + SHT_SYMTAB and SHT_DYNSYM in sh_link to string table 892 + SHT_GROUP in sh_link to symbol table 893 + SHT_SYMTAB_SHNDX in sh_link to symbol table 894 Other (OS or architecture-specific) sections might as 895 well use this field so we process it unconditionally. 896 - references inside section groups 897 - specially marked references in sh_info if the SHF_INFO_LINK 898 flag is set 899 */ 900 901 if (shdr_info[shdr_info[cnt].shdr.sh_link].idx == 0) 902 { 903 shdr_info[shdr_info[cnt].shdr.sh_link].idx = 1; 904 changes |= shdr_info[cnt].shdr.sh_link < cnt; 905 } 906 907 /* Handle references through sh_info. */ 908 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)) 909 { 910 if (shdr_info[cnt].shdr.sh_info >= shnum) 911 goto illformed; 912 else if ( shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0) 913 { 914 shdr_info[shdr_info[cnt].shdr.sh_info].idx = 1; 915 changes |= shdr_info[cnt].shdr.sh_info < cnt; 916 } 917 } 918 919 /* Mark the section as investigated. */ 920 shdr_info[cnt].idx = 2; 921 } 922 923 if (debug_fname != NULL 924 && (shdr_info[cnt].idx == 0 || shdr_info[cnt].debug_data != NULL)) 925 { 926 /* This section is being preserved in the debug file. 927 Sections it refers to must be preserved there too. 928 929 In this pass we mark sections to be preserved in both 930 files by setting the .debug_data pointer to the original 931 file's .data pointer. Below, we'll copy the section 932 contents. */ 933 934 inline void check_preserved (size_t i) 935 { 936 if (i != 0 && i < shnum + 2 && shdr_info[i].idx != 0 937 && shdr_info[i].debug_data == NULL) 938 { 939 if (shdr_info[i].data == NULL) 940 shdr_info[i].data = elf_getdata (shdr_info[i].scn, NULL); 941 if (shdr_info[i].data == NULL) 942 INTERNAL_ERROR (fname); 943 944 shdr_info[i].debug_data = shdr_info[i].data; 945 changes |= i < cnt; 946 } 947 } 948 949 check_preserved (shdr_info[cnt].shdr.sh_link); 950 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)) 951 check_preserved (shdr_info[cnt].shdr.sh_info); 952 } 953 } 954 } 955 while (changes); 956 957 /* Copy the removed sections to the debug output file. 958 The ones that are not removed in the stripped file are SHT_NOBITS. */ 959 if (debug_fname != NULL) 960 { 961 for (cnt = 1; cnt < shnum; ++cnt) 962 { 963 scn = elf_newscn (debugelf); 964 if (scn == NULL) 965 { 966 cleanup_debug (); 967 error (EXIT_FAILURE, 0, 968 gettext ("while generating output file: %s"), 969 elf_errmsg (-1)); 970 } 971 972 bool discard_section = (shdr_info[cnt].idx > 0 973 && shdr_info[cnt].debug_data == NULL 974 && shdr_info[cnt].shdr.sh_type != SHT_NOTE 975 && shdr_info[cnt].shdr.sh_type != SHT_GROUP 976 && cnt != ehdr->e_shstrndx); 977 978 /* Set the section header in the new file. */ 979 GElf_Shdr debugshdr = shdr_info[cnt].shdr; 980 if (discard_section) 981 debugshdr.sh_type = SHT_NOBITS; 982 983 if (unlikely (gelf_update_shdr (scn, &debugshdr) == 0)) 984 /* There cannot be any overflows. */ 985 INTERNAL_ERROR (fname); 986 987 /* Get the data from the old file if necessary. */ 988 if (shdr_info[cnt].data == NULL) 989 { 990 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL); 991 if (shdr_info[cnt].data == NULL) 992 INTERNAL_ERROR (fname); 993 } 994 995 /* Set the data. This is done by copying from the old file. */ 996 Elf_Data *debugdata = elf_newdata (scn); 997 if (debugdata == NULL) 998 INTERNAL_ERROR (fname); 999 1000 /* Copy the structure. This data may be modified in place 1001 before we write out the file. */ 1002 *debugdata = *shdr_info[cnt].data; 1003 if (discard_section) 1004 debugdata->d_buf = NULL; 1005 else if (shdr_info[cnt].debug_data != NULL 1006 || shdr_info[cnt].shdr.sh_type == SHT_GROUP) 1007 { 1008 /* Copy the original data before it gets modified. */ 1009 shdr_info[cnt].debug_data = debugdata; 1010 if (debugdata->d_buf == NULL) 1011 INTERNAL_ERROR (fname); 1012 debugdata->d_buf = memcpy (xmalloc (debugdata->d_size), 1013 debugdata->d_buf, debugdata->d_size); 1014 } 1015 } 1016 1017 /* Finish the ELF header. Fill in the fields not handled by 1018 libelf from the old file. */ 1019 debugehdr = gelf_getehdr (debugelf, &debugehdr_mem); 1020 if (debugehdr == NULL) 1021 INTERNAL_ERROR (fname); 1022 1023 memcpy (debugehdr->e_ident, ehdr->e_ident, EI_NIDENT); 1024 debugehdr->e_type = ehdr->e_type; 1025 debugehdr->e_machine = ehdr->e_machine; 1026 debugehdr->e_version = ehdr->e_version; 1027 debugehdr->e_entry = ehdr->e_entry; 1028 debugehdr->e_flags = ehdr->e_flags; 1029 debugehdr->e_shstrndx = ehdr->e_shstrndx; 1030 1031 if (unlikely (gelf_update_ehdr (debugelf, debugehdr) == 0)) 1032 { 1033 error (0, 0, gettext ("%s: error while creating ELF header: %s"), 1034 debug_fname, elf_errmsg (-1)); 1035 result = 1; 1036 goto fail_close; 1037 } 1038 } 1039 1040 /* Although we always create a new section header string table we 1041 don't explicitly mark the existing one as unused. It can still 1042 be used through a symbol table section we are keeping. If not it 1043 will already be marked as unused. */ 1044 1045 /* We need a string table for the section headers. */ 1046 shst = ebl_strtabinit (true); 1047 if (shst == NULL) 1048 { 1049 cleanup_debug (); 1050 error (EXIT_FAILURE, errno, gettext ("while preparing output for '%s'"), 1051 output_fname ?: fname); 1052 } 1053 1054 /* Assign new section numbers. */ 1055 shdr_info[0].idx = 0; 1056 for (cnt = idx = 1; cnt < shnum; ++cnt) 1057 if (shdr_info[cnt].idx > 0) 1058 { 1059 shdr_info[cnt].idx = idx++; 1060 1061 /* Create a new section. */ 1062 shdr_info[cnt].newscn = elf_newscn (newelf); 1063 if (shdr_info[cnt].newscn == NULL) 1064 { 1065 cleanup_debug (); 1066 error (EXIT_FAILURE, 0, 1067 gettext ("while generating output file: %s"), 1068 elf_errmsg (-1)); 1069 } 1070 1071 elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx); 1072 1073 /* Add this name to the section header string table. */ 1074 shdr_info[cnt].se = ebl_strtabadd (shst, shdr_info[cnt].name, 0); 1075 } 1076 1077 /* Test whether we are doing anything at all. */ 1078 if (cnt == idx) 1079 /* Nope, all removable sections are already gone. */ 1080 goto fail_close; 1081 1082 /* Create the reference to the file with the debug info. */ 1083 if (debug_fname != NULL && !remove_shdrs) 1084 { 1085 /* Add the section header string table section name. */ 1086 shdr_info[cnt].se = ebl_strtabadd (shst, ".gnu_debuglink", 15); 1087 shdr_info[cnt].idx = idx++; 1088 1089 /* Create the section header. */ 1090 shdr_info[cnt].shdr.sh_type = SHT_PROGBITS; 1091 shdr_info[cnt].shdr.sh_flags = 0; 1092 shdr_info[cnt].shdr.sh_addr = 0; 1093 shdr_info[cnt].shdr.sh_link = SHN_UNDEF; 1094 shdr_info[cnt].shdr.sh_info = SHN_UNDEF; 1095 shdr_info[cnt].shdr.sh_entsize = 0; 1096 shdr_info[cnt].shdr.sh_addralign = 4; 1097 /* We set the offset to zero here. Before we write the ELF file the 1098 field must have the correct value. This is done in the final 1099 loop over all section. Then we have all the information needed. */ 1100 shdr_info[cnt].shdr.sh_offset = 0; 1101 1102 /* Create the section. */ 1103 shdr_info[cnt].newscn = elf_newscn (newelf); 1104 if (shdr_info[cnt].newscn == NULL) 1105 { 1106 cleanup_debug (); 1107 error (EXIT_FAILURE, 0, 1108 gettext ("while create section header section: %s"), 1109 elf_errmsg (-1)); 1110 } 1111 elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx); 1112 1113 shdr_info[cnt].data = elf_newdata (shdr_info[cnt].newscn); 1114 if (shdr_info[cnt].data == NULL) 1115 { 1116 cleanup_debug (); 1117 error (EXIT_FAILURE, 0, gettext ("cannot allocate section data: %s"), 1118 elf_errmsg (-1)); 1119 } 1120 1121 char *debug_basename = basename (debug_fname_embed ?: debug_fname); 1122 off_t crc_offset = strlen (debug_basename) + 1; 1123 /* Align to 4 byte boundary */ 1124 crc_offset = ((crc_offset - 1) & ~3) + 4; 1125 1126 shdr_info[cnt].data->d_align = 4; 1127 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size 1128 = crc_offset + 4; 1129 debuglink_buf = xcalloc (1, shdr_info[cnt].data->d_size); 1130 shdr_info[cnt].data->d_buf = debuglink_buf; 1131 1132 strcpy (shdr_info[cnt].data->d_buf, debug_basename); 1133 1134 /* Cache this Elf_Data describing the CRC32 word in the section. 1135 We'll fill this in when we have written the debug file. */ 1136 debuglink_crc_data = *shdr_info[cnt].data; 1137 debuglink_crc_data.d_buf = ((char *) debuglink_crc_data.d_buf 1138 + crc_offset); 1139 debuglink_crc_data.d_size = 4; 1140 1141 /* One more section done. */ 1142 ++cnt; 1143 } 1144 1145 /* Index of the section header table in the shdr_info array. */ 1146 shdridx = cnt; 1147 1148 /* Add the section header string table section name. */ 1149 shdr_info[cnt].se = ebl_strtabadd (shst, ".shstrtab", 10); 1150 shdr_info[cnt].idx = idx; 1151 1152 /* Create the section header. */ 1153 shdr_info[cnt].shdr.sh_type = SHT_STRTAB; 1154 shdr_info[cnt].shdr.sh_flags = 0; 1155 shdr_info[cnt].shdr.sh_addr = 0; 1156 shdr_info[cnt].shdr.sh_link = SHN_UNDEF; 1157 shdr_info[cnt].shdr.sh_info = SHN_UNDEF; 1158 shdr_info[cnt].shdr.sh_entsize = 0; 1159 /* We set the offset to zero here. Before we write the ELF file the 1160 field must have the correct value. This is done in the final 1161 loop over all section. Then we have all the information needed. */ 1162 shdr_info[cnt].shdr.sh_offset = 0; 1163 shdr_info[cnt].shdr.sh_addralign = 1; 1164 1165 /* Create the section. */ 1166 shdr_info[cnt].newscn = elf_newscn (newelf); 1167 if (shdr_info[cnt].newscn == NULL) 1168 { 1169 cleanup_debug (); 1170 error (EXIT_FAILURE, 0, 1171 gettext ("while create section header section: %s"), 1172 elf_errmsg (-1)); 1173 } 1174 elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == idx); 1175 1176 /* Finalize the string table and fill in the correct indices in the 1177 section headers. */ 1178 shstrtab_data = elf_newdata (shdr_info[cnt].newscn); 1179 if (shstrtab_data == NULL) 1180 { 1181 cleanup_debug (); 1182 error (EXIT_FAILURE, 0, 1183 gettext ("while create section header string table: %s"), 1184 elf_errmsg (-1)); 1185 } 1186 ebl_strtabfinalize (shst, shstrtab_data); 1187 1188 /* We have to set the section size. */ 1189 shdr_info[cnt].shdr.sh_size = shstrtab_data->d_size; 1190 1191 /* Update the section information. */ 1192 GElf_Off lastoffset = 0; 1193 for (cnt = 1; cnt <= shdridx; ++cnt) 1194 if (shdr_info[cnt].idx > 0) 1195 { 1196 Elf_Data *newdata; 1197 1198 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1199 elf_assert (scn != NULL); 1200 1201 /* Update the name. */ 1202 shdr_info[cnt].shdr.sh_name = ebl_strtaboffset (shdr_info[cnt].se); 1203 1204 /* Update the section header from the input file. Some fields 1205 might be section indeces which now have to be adjusted. */ 1206 if (shdr_info[cnt].shdr.sh_link != 0) 1207 shdr_info[cnt].shdr.sh_link = 1208 shdr_info[shdr_info[cnt].shdr.sh_link].idx; 1209 1210 if (shdr_info[cnt].shdr.sh_type == SHT_GROUP) 1211 { 1212 elf_assert (shdr_info[cnt].data != NULL 1213 && shdr_info[cnt].data->d_buf != NULL); 1214 1215 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf; 1216 for (size_t inner = 0; 1217 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word); 1218 ++inner) 1219 if (grpref[inner] < shnum) 1220 grpref[inner] = shdr_info[grpref[inner]].idx; 1221 else 1222 goto illformed; 1223 } 1224 1225 /* Handle the SHT_REL, SHT_RELA, and SHF_INFO_LINK flag. */ 1226 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)) 1227 shdr_info[cnt].shdr.sh_info = 1228 shdr_info[shdr_info[cnt].shdr.sh_info].idx; 1229 1230 /* Get the data from the old file if necessary. We already 1231 created the data for the section header string table. */ 1232 if (cnt < shnum) 1233 { 1234 if (shdr_info[cnt].data == NULL) 1235 { 1236 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL); 1237 if (shdr_info[cnt].data == NULL) 1238 INTERNAL_ERROR (fname); 1239 } 1240 1241 /* Set the data. This is done by copying from the old file. */ 1242 newdata = elf_newdata (scn); 1243 if (newdata == NULL) 1244 INTERNAL_ERROR (fname); 1245 1246 /* Copy the structure. */ 1247 *newdata = *shdr_info[cnt].data; 1248 1249 /* We know the size. */ 1250 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size; 1251 1252 /* We have to adjust symbol tables. The st_shndx member might 1253 have to be updated. */ 1254 if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM 1255 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB) 1256 { 1257 Elf_Data *versiondata = NULL; 1258 Elf_Data *shndxdata = NULL; 1259 1260 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT); 1261 1262 if (shdr_info[cnt].symtab_idx != 0) 1263 { 1264 elf_assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX); 1265 /* This section has extended section information. 1266 We have to modify that information, too. */ 1267 shndxdata = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn, 1268 NULL); 1269 1270 elf_assert ((versiondata->d_size / sizeof (Elf32_Word)) 1271 >= shdr_info[cnt].data->d_size / elsize); 1272 } 1273 1274 if (shdr_info[cnt].version_idx != 0) 1275 { 1276 elf_assert (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM); 1277 /* This section has associated version 1278 information. We have to modify that 1279 information, too. */ 1280 versiondata = elf_getdata (shdr_info[shdr_info[cnt].version_idx].scn, 1281 NULL); 1282 1283 elf_assert (versiondata != NULL 1284 && versiondata->d_buf != NULL 1285 && ((versiondata->d_size / sizeof (GElf_Versym)) 1286 >= shdr_info[cnt].data->d_size / elsize)); 1287 } 1288 1289 shdr_info[cnt].newsymidx 1290 = (Elf32_Word *) xcalloc (shdr_info[cnt].data->d_size 1291 / elsize, sizeof (Elf32_Word)); 1292 1293 bool last_was_local = true; 1294 size_t destidx; 1295 size_t inner; 1296 for (destidx = inner = 1; 1297 inner < shdr_info[cnt].data->d_size / elsize; 1298 ++inner) 1299 { 1300 Elf32_Word sec; 1301 GElf_Sym sym_mem; 1302 Elf32_Word xshndx; 1303 GElf_Sym *sym = gelf_getsymshndx (shdr_info[cnt].data, 1304 shndxdata, inner, 1305 &sym_mem, &xshndx); 1306 if (sym == NULL) 1307 INTERNAL_ERROR (fname); 1308 1309 if (sym->st_shndx == SHN_UNDEF 1310 || (sym->st_shndx >= shnum 1311 && sym->st_shndx != SHN_XINDEX)) 1312 { 1313 /* This is no section index, leave it alone 1314 unless it is moved. */ 1315 if (destidx != inner 1316 && gelf_update_symshndx (shdr_info[cnt].data, 1317 shndxdata, 1318 destidx, sym, 1319 xshndx) == 0) 1320 INTERNAL_ERROR (fname); 1321 1322 shdr_info[cnt].newsymidx[inner] = destidx++; 1323 1324 if (last_was_local 1325 && GELF_ST_BIND (sym->st_info) != STB_LOCAL) 1326 { 1327 last_was_local = false; 1328 shdr_info[cnt].shdr.sh_info = destidx - 1; 1329 } 1330 1331 continue; 1332 } 1333 1334 /* Get the full section index, if necessary from the 1335 XINDEX table. */ 1336 if (sym->st_shndx != SHN_XINDEX) 1337 sec = shdr_info[sym->st_shndx].idx; 1338 else 1339 { 1340 elf_assert (shndxdata != NULL 1341 && shndxdata->d_buf != NULL); 1342 1343 sec = shdr_info[xshndx].idx; 1344 } 1345 1346 if (sec != 0) 1347 { 1348 GElf_Section nshndx; 1349 Elf32_Word nxshndx; 1350 1351 if (sec < SHN_LORESERVE) 1352 { 1353 nshndx = sec; 1354 nxshndx = 0; 1355 } 1356 else 1357 { 1358 nshndx = SHN_XINDEX; 1359 nxshndx = sec; 1360 } 1361 1362 elf_assert (sec < SHN_LORESERVE || shndxdata != NULL); 1363 1364 if ((inner != destidx || nshndx != sym->st_shndx 1365 || (shndxdata != NULL && nxshndx != xshndx)) 1366 && (sym->st_shndx = nshndx, 1367 gelf_update_symshndx (shdr_info[cnt].data, 1368 shndxdata, 1369 destidx, sym, 1370 nxshndx) == 0)) 1371 INTERNAL_ERROR (fname); 1372 1373 shdr_info[cnt].newsymidx[inner] = destidx++; 1374 1375 if (last_was_local 1376 && GELF_ST_BIND (sym->st_info) != STB_LOCAL) 1377 { 1378 last_was_local = false; 1379 shdr_info[cnt].shdr.sh_info = destidx - 1; 1380 } 1381 } 1382 else if (debug_fname != NULL 1383 && shdr_info[cnt].debug_data == NULL) 1384 /* The symbol points to a section that is discarded 1385 but isn't preserved in the debug file. Check that 1386 this is a section or group signature symbol 1387 for a section which has been removed. */ 1388 { 1389 size_t sidx = (sym->st_shndx != SHN_XINDEX 1390 ? sym->st_shndx : xshndx); 1391 elf_assert (GELF_ST_TYPE (sym->st_info) == STT_SECTION 1392 || ((shdr_info[sidx].shdr.sh_type 1393 == SHT_GROUP) 1394 && (shdr_info[sidx].shdr.sh_info 1395 == inner))); 1396 } 1397 } 1398 1399 if (destidx != inner) 1400 { 1401 /* The size of the symbol table changed. */ 1402 shdr_info[cnt].shdr.sh_size = newdata->d_size 1403 = destidx * elsize; 1404 any_symtab_changes = true; 1405 } 1406 else 1407 { 1408 /* The symbol table didn't really change. */ 1409 free (shdr_info[cnt].newsymidx); 1410 shdr_info[cnt].newsymidx = NULL; 1411 } 1412 } 1413 } 1414 1415 /* If we have to, compute the offset of the section. */ 1416 if (shdr_info[cnt].shdr.sh_offset == 0) 1417 shdr_info[cnt].shdr.sh_offset 1418 = ((lastoffset + shdr_info[cnt].shdr.sh_addralign - 1) 1419 & ~((GElf_Off) (shdr_info[cnt].shdr.sh_addralign - 1))); 1420 1421 /* Set the section header in the new file. */ 1422 if (unlikely (gelf_update_shdr (scn, &shdr_info[cnt].shdr) == 0)) 1423 /* There cannot be any overflows. */ 1424 INTERNAL_ERROR (fname); 1425 1426 /* Remember the last section written so far. */ 1427 GElf_Off filesz = (shdr_info[cnt].shdr.sh_type != SHT_NOBITS 1428 ? shdr_info[cnt].shdr.sh_size : 0); 1429 if (lastoffset < shdr_info[cnt].shdr.sh_offset + filesz) 1430 lastoffset = shdr_info[cnt].shdr.sh_offset + filesz; 1431 } 1432 1433 /* Adjust symbol references if symbol tables changed. */ 1434 if (any_symtab_changes) 1435 /* Find all relocation sections which use this symbol table. */ 1436 for (cnt = 1; cnt <= shdridx; ++cnt) 1437 { 1438 /* Update section headers when the data size has changed. 1439 We also update the SHT_NOBITS section in the debug 1440 file so that the section headers match in sh_size. */ 1441 inline void update_section_size (const Elf_Data *newdata) 1442 { 1443 GElf_Shdr shdr_mem; 1444 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 1445 shdr->sh_size = newdata->d_size; 1446 (void) gelf_update_shdr (scn, shdr); 1447 if (debugelf != NULL) 1448 { 1449 /* libelf will use d_size to set sh_size. */ 1450 Elf_Data *debugdata = elf_getdata (elf_getscn (debugelf, 1451 cnt), NULL); 1452 if (debugdata == NULL) 1453 INTERNAL_ERROR (fname); 1454 debugdata->d_size = newdata->d_size; 1455 } 1456 } 1457 1458 if (shdr_info[cnt].idx == 0 && debug_fname == NULL) 1459 /* Ignore sections which are discarded. When we are saving a 1460 relocation section in a separate debug file, we must fix up 1461 the symbol table references. */ 1462 continue; 1463 1464 const Elf32_Word symtabidx = shdr_info[cnt].old_sh_link; 1465 elf_assert (symtabidx < shnum + 2); 1466 const Elf32_Word *const newsymidx = shdr_info[symtabidx].newsymidx; 1467 switch (shdr_info[cnt].shdr.sh_type) 1468 { 1469 inline bool no_symtab_updates (void) 1470 { 1471 /* If the symbol table hasn't changed, do not do anything. */ 1472 if (shdr_info[symtabidx].newsymidx == NULL) 1473 return true; 1474 1475 /* If the symbol table is not discarded, but additionally 1476 duplicated in the separate debug file and this section 1477 is discarded, don't adjust anything. */ 1478 return (shdr_info[cnt].idx == 0 1479 && shdr_info[symtabidx].debug_data != NULL); 1480 } 1481 1482 case SHT_REL: 1483 case SHT_RELA: 1484 if (no_symtab_updates ()) 1485 break; 1486 1487 Elf_Data *d = elf_getdata (shdr_info[cnt].idx == 0 1488 ? elf_getscn (debugelf, cnt) 1489 : elf_getscn (newelf, 1490 shdr_info[cnt].idx), 1491 NULL); 1492 elf_assert (d != NULL && d->d_buf != NULL 1493 && shdr_info[cnt].shdr.sh_entsize != 0); 1494 size_t nrels = (shdr_info[cnt].shdr.sh_size 1495 / shdr_info[cnt].shdr.sh_entsize); 1496 1497 size_t symsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT); 1498 const Elf32_Word symidxn = (shdr_info[symtabidx].data->d_size 1499 / symsize); 1500 if (shdr_info[cnt].shdr.sh_type == SHT_REL) 1501 for (size_t relidx = 0; relidx < nrels; ++relidx) 1502 { 1503 GElf_Rel rel_mem; 1504 if (gelf_getrel (d, relidx, &rel_mem) == NULL) 1505 INTERNAL_ERROR (fname); 1506 1507 size_t symidx = GELF_R_SYM (rel_mem.r_info); 1508 elf_assert (symidx < symidxn); 1509 if (newsymidx[symidx] != symidx) 1510 { 1511 rel_mem.r_info 1512 = GELF_R_INFO (newsymidx[symidx], 1513 GELF_R_TYPE (rel_mem.r_info)); 1514 1515 if (gelf_update_rel (d, relidx, &rel_mem) == 0) 1516 INTERNAL_ERROR (fname); 1517 } 1518 } 1519 else 1520 for (size_t relidx = 0; relidx < nrels; ++relidx) 1521 { 1522 GElf_Rela rel_mem; 1523 if (gelf_getrela (d, relidx, &rel_mem) == NULL) 1524 INTERNAL_ERROR (fname); 1525 1526 size_t symidx = GELF_R_SYM (rel_mem.r_info); 1527 elf_assert (symidx < symidxn); 1528 if (newsymidx[symidx] != symidx) 1529 { 1530 rel_mem.r_info 1531 = GELF_R_INFO (newsymidx[symidx], 1532 GELF_R_TYPE (rel_mem.r_info)); 1533 1534 if (gelf_update_rela (d, relidx, &rel_mem) == 0) 1535 INTERNAL_ERROR (fname); 1536 } 1537 } 1538 break; 1539 1540 case SHT_HASH: 1541 if (no_symtab_updates ()) 1542 break; 1543 1544 /* We have to recompute the hash table. */ 1545 1546 elf_assert (shdr_info[cnt].idx > 0); 1547 1548 /* The hash section in the new file. */ 1549 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1550 1551 /* The symbol table data. */ 1552 Elf_Data *symd = elf_getdata (elf_getscn (newelf, 1553 shdr_info[symtabidx].idx), 1554 NULL); 1555 elf_assert (symd != NULL && symd->d_buf != NULL); 1556 1557 /* The hash table data. */ 1558 Elf_Data *hashd = elf_getdata (scn, NULL); 1559 elf_assert (hashd != NULL && hashd->d_buf != NULL); 1560 1561 if (shdr_info[cnt].shdr.sh_entsize == sizeof (Elf32_Word)) 1562 { 1563 /* Sane arches first. */ 1564 elf_assert (hashd->d_size >= 2 * sizeof (Elf32_Word)); 1565 Elf32_Word *bucket = (Elf32_Word *) hashd->d_buf; 1566 1567 size_t strshndx = shdr_info[symtabidx].old_sh_link; 1568 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT); 1569 1570 Elf32_Word nchain = bucket[1]; 1571 Elf32_Word nbucket = bucket[0]; 1572 uint64_t used_buf = ((2ULL + nchain + nbucket) 1573 * sizeof (Elf32_Word)); 1574 elf_assert (used_buf <= hashd->d_size); 1575 1576 /* Adjust the nchain value. The symbol table size 1577 changed. We keep the same size for the bucket array. */ 1578 bucket[1] = symd->d_size / elsize; 1579 bucket += 2; 1580 Elf32_Word *chain = bucket + nbucket; 1581 1582 /* New size of the section. */ 1583 size_t n_size = ((2 + symd->d_size / elsize + nbucket) 1584 * sizeof (Elf32_Word)); 1585 elf_assert (n_size <= hashd->d_size); 1586 hashd->d_size = n_size; 1587 update_section_size (hashd); 1588 1589 /* Clear the arrays. */ 1590 memset (bucket, '\0', 1591 (symd->d_size / elsize + nbucket) 1592 * sizeof (Elf32_Word)); 1593 1594 for (size_t inner = shdr_info[symtabidx].shdr.sh_info; 1595 inner < symd->d_size / elsize; ++inner) 1596 { 1597 GElf_Sym sym_mem; 1598 GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem); 1599 elf_assert (sym != NULL); 1600 1601 const char *name = elf_strptr (elf, strshndx, 1602 sym->st_name); 1603 elf_assert (name != NULL && nbucket != 0); 1604 size_t hidx = elf_hash (name) % nbucket; 1605 1606 if (bucket[hidx] == 0) 1607 bucket[hidx] = inner; 1608 else 1609 { 1610 hidx = bucket[hidx]; 1611 1612 while (chain[hidx] != 0 && chain[hidx] < nchain) 1613 hidx = chain[hidx]; 1614 1615 chain[hidx] = inner; 1616 } 1617 } 1618 } 1619 else 1620 { 1621 /* Alpha and S390 64-bit use 64-bit SHT_HASH entries. */ 1622 elf_assert (shdr_info[cnt].shdr.sh_entsize 1623 == sizeof (Elf64_Xword)); 1624 1625 Elf64_Xword *bucket = (Elf64_Xword *) hashd->d_buf; 1626 1627 size_t strshndx = shdr_info[symtabidx].old_sh_link; 1628 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT); 1629 1630 elf_assert (symd->d_size >= 2 * sizeof (Elf64_Xword)); 1631 Elf64_Xword nbucket = bucket[0]; 1632 Elf64_Xword nchain = bucket[1]; 1633 uint64_t maxwords = hashd->d_size / sizeof (Elf64_Xword); 1634 elf_assert (maxwords >= 2 1635 && maxwords - 2 >= nbucket 1636 && maxwords - 2 - nbucket >= nchain); 1637 1638 /* Adjust the nchain value. The symbol table size 1639 changed. We keep the same size for the bucket array. */ 1640 bucket[1] = symd->d_size / elsize; 1641 bucket += 2; 1642 Elf64_Xword *chain = bucket + nbucket; 1643 1644 /* New size of the section. */ 1645 size_t n_size = ((2 + symd->d_size / elsize + nbucket) 1646 * sizeof (Elf64_Xword)); 1647 elf_assert (n_size <= hashd->d_size); 1648 hashd->d_size = n_size; 1649 update_section_size (hashd); 1650 1651 /* Clear the arrays. */ 1652 memset (bucket, '\0', 1653 (symd->d_size / elsize + nbucket) 1654 * sizeof (Elf64_Xword)); 1655 1656 for (size_t inner = shdr_info[symtabidx].shdr.sh_info; 1657 inner < symd->d_size / elsize; ++inner) 1658 { 1659 GElf_Sym sym_mem; 1660 GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem); 1661 elf_assert (sym != NULL); 1662 1663 const char *name = elf_strptr (elf, strshndx, 1664 sym->st_name); 1665 elf_assert (name != NULL && nbucket != 0); 1666 size_t hidx = elf_hash (name) % nbucket; 1667 1668 if (bucket[hidx] == 0) 1669 bucket[hidx] = inner; 1670 else 1671 { 1672 hidx = bucket[hidx]; 1673 1674 while (chain[hidx] != 0 && chain[hidx] < nchain) 1675 hidx = chain[hidx]; 1676 1677 chain[hidx] = inner; 1678 } 1679 } 1680 } 1681 break; 1682 1683 case SHT_GNU_versym: 1684 /* If the symbol table changed we have to adjust the entries. */ 1685 if (no_symtab_updates ()) 1686 break; 1687 1688 elf_assert (shdr_info[cnt].idx > 0); 1689 1690 /* The symbol version section in the new file. */ 1691 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1692 1693 /* The symbol table data. */ 1694 symd = elf_getdata (elf_getscn (newelf, shdr_info[symtabidx].idx), 1695 NULL); 1696 elf_assert (symd != NULL && symd->d_buf != NULL); 1697 size_t symz = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT); 1698 const Elf32_Word syms = (shdr_info[symtabidx].data->d_size / symz); 1699 1700 /* The version symbol data. */ 1701 Elf_Data *verd = elf_getdata (scn, NULL); 1702 elf_assert (verd != NULL && verd->d_buf != NULL); 1703 1704 /* The symbol version array. */ 1705 GElf_Half *verstab = (GElf_Half *) verd->d_buf; 1706 1707 /* Walk through the list and */ 1708 size_t elsize = gelf_fsize (elf, verd->d_type, 1, EV_CURRENT); 1709 Elf32_Word vers = verd->d_size / elsize; 1710 for (size_t inner = 1; inner < vers && inner < syms; ++inner) 1711 if (newsymidx[inner] != 0 && newsymidx[inner] < vers) 1712 /* Overwriting the same array works since the 1713 reordering can only move entries to lower indices 1714 in the array. */ 1715 verstab[newsymidx[inner]] = verstab[inner]; 1716 1717 /* New size of the section. */ 1718 verd->d_size = gelf_fsize (newelf, verd->d_type, 1719 symd->d_size 1720 / gelf_fsize (elf, symd->d_type, 1, 1721 EV_CURRENT), 1722 EV_CURRENT); 1723 update_section_size (verd); 1724 break; 1725 1726 case SHT_GROUP: 1727 if (no_symtab_updates ()) 1728 break; 1729 1730 /* Yes, the symbol table changed. 1731 Update the section header of the section group. */ 1732 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1733 GElf_Shdr shdr_mem; 1734 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 1735 elf_assert (shdr != NULL); 1736 1737 size_t symsz = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT); 1738 const Elf32_Word symn = (shdr_info[symtabidx].data->d_size 1739 / symsz); 1740 elf_assert (shdr->sh_info < symn); 1741 shdr->sh_info = newsymidx[shdr->sh_info]; 1742 1743 (void) gelf_update_shdr (scn, shdr); 1744 break; 1745 } 1746 } 1747 1748 /* Remove any relocations between debug sections in ET_REL 1749 for the debug file when requested. These relocations are always 1750 zero based between the unallocated sections. */ 1751 if (debug_fname != NULL && reloc_debug && ehdr->e_type == ET_REL) 1752 { 1753 scn = NULL; 1754 cnt = 0; 1755 while ((scn = elf_nextscn (debugelf, scn)) != NULL) 1756 { 1757 cnt++; 1758 /* We need the actual section and header from the debugelf 1759 not just the cached original in shdr_info because we 1760 might want to change the size. */ 1761 GElf_Shdr shdr_mem; 1762 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 1763 if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA) 1764 { 1765 /* Make sure that this relocation section points to a 1766 section to relocate with contents, that isn't 1767 allocated and that is a debug section. */ 1768 Elf_Scn *tscn = elf_getscn (debugelf, shdr->sh_info); 1769 GElf_Shdr tshdr_mem; 1770 GElf_Shdr *tshdr = gelf_getshdr (tscn, &tshdr_mem); 1771 if (tshdr->sh_type == SHT_NOBITS 1772 || tshdr->sh_size == 0 1773 || (tshdr->sh_flags & SHF_ALLOC) != 0) 1774 continue; 1775 1776 const char *tname = elf_strptr (debugelf, shstrndx, 1777 tshdr->sh_name); 1778 if (! tname || ! ebl_debugscn_p (ebl, tname)) 1779 continue; 1780 1781 /* OK, lets relocate all trivial cross debug section 1782 relocations. */ 1783 Elf_Data *reldata = elf_getdata (scn, NULL); 1784 if (reldata == NULL || reldata->d_buf == NULL) 1785 INTERNAL_ERROR (fname); 1786 /* We actually wanted the rawdata, but since we already 1787 accessed it earlier as elf_getdata () that won't 1788 work. But debug sections are all ELF_T_BYTE, so it 1789 doesn't really matter. */ 1790 Elf_Data *tdata = elf_getdata (tscn, NULL); 1791 if (tdata == NULL || tdata->d_buf == NULL 1792 || tdata->d_type != ELF_T_BYTE) 1793 INTERNAL_ERROR (fname); 1794 1795 /* Pick up the symbol table and shndx table to 1796 resolve relocation symbol indexes. */ 1797 Elf64_Word symt = shdr->sh_link; 1798 Elf_Data *symdata, *xndxdata; 1799 elf_assert (symt < shnum + 2); 1800 elf_assert (shdr_info[symt].symtab_idx < shnum + 2); 1801 symdata = (shdr_info[symt].debug_data 1802 ?: shdr_info[symt].data); 1803 xndxdata = (shdr_info[shdr_info[symt].symtab_idx].debug_data 1804 ?: shdr_info[shdr_info[symt].symtab_idx].data); 1805 1806 /* Apply one relocation. Returns true when trivial 1807 relocation actually done. */ 1808 bool relocate (GElf_Addr offset, const GElf_Sxword addend, 1809 bool is_rela, int rtype, int symndx) 1810 { 1811 /* R_*_NONE relocs can always just be removed. */ 1812 if (rtype == 0) 1813 return true; 1814 1815 /* We only do simple absolute relocations. */ 1816 Elf_Type type = ebl_reloc_simple_type (ebl, rtype); 1817 if (type == ELF_T_NUM) 1818 return false; 1819 1820 /* These are the types we can relocate. */ 1821 #define TYPES DO_TYPE (BYTE, Byte); DO_TYPE (HALF, Half); \ 1822 DO_TYPE (WORD, Word); DO_TYPE (SWORD, Sword); \ 1823 DO_TYPE (XWORD, Xword); DO_TYPE (SXWORD, Sxword) 1824 1825 /* And only for relocations against other debug sections. */ 1826 GElf_Sym sym_mem; 1827 Elf32_Word xndx; 1828 GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata, 1829 symndx, &sym_mem, 1830 &xndx); 1831 Elf32_Word sec = (sym->st_shndx == SHN_XINDEX 1832 ? xndx : sym->st_shndx); 1833 if (sec >= shnum + 2) 1834 INTERNAL_ERROR (fname); 1835 1836 if (ebl_debugscn_p (ebl, shdr_info[sec].name)) 1837 { 1838 size_t size; 1839 1840 #define DO_TYPE(NAME, Name) GElf_##Name Name; 1841 union { TYPES; } tmpbuf; 1842 #undef DO_TYPE 1843 1844 switch (type) 1845 { 1846 #define DO_TYPE(NAME, Name) \ 1847 case ELF_T_##NAME: \ 1848 size = sizeof (GElf_##Name); \ 1849 tmpbuf.Name = 0; \ 1850 break; 1851 TYPES; 1852 #undef DO_TYPE 1853 default: 1854 return false; 1855 } 1856 1857 if (offset > tdata->d_size 1858 || tdata->d_size - offset < size) 1859 { 1860 cleanup_debug (); 1861 error (EXIT_FAILURE, 0, gettext ("bad relocation")); 1862 } 1863 1864 /* When the symbol value is zero then for SHT_REL 1865 sections this is all that needs to be checked. 1866 The addend is contained in the original data at 1867 the offset already. So if the (section) symbol 1868 address is zero and the given addend is zero 1869 just remove the relocation, it isn't needed 1870 anymore. */ 1871 if (addend == 0 && sym->st_value == 0) 1872 return true; 1873 1874 Elf_Data tmpdata = 1875 { 1876 .d_type = type, 1877 .d_buf = &tmpbuf, 1878 .d_size = size, 1879 .d_version = EV_CURRENT, 1880 }; 1881 Elf_Data rdata = 1882 { 1883 .d_type = type, 1884 .d_buf = tdata->d_buf + offset, 1885 .d_size = size, 1886 .d_version = EV_CURRENT, 1887 }; 1888 1889 GElf_Addr value = sym->st_value; 1890 if (is_rela) 1891 { 1892 /* For SHT_RELA sections we just take the 1893 given addend and add it to the value. */ 1894 value += addend; 1895 } 1896 else 1897 { 1898 /* For SHT_REL sections we have to peek at 1899 what is already in the section at the given 1900 offset to get the addend. */ 1901 Elf_Data *d = gelf_xlatetom (debugelf, &tmpdata, 1902 &rdata, 1903 ehdr->e_ident[EI_DATA]); 1904 if (d == NULL) 1905 INTERNAL_ERROR (fname); 1906 assert (d == &tmpdata); 1907 } 1908 1909 switch (type) 1910 { 1911 #define DO_TYPE(NAME, Name) \ 1912 case ELF_T_##NAME: \ 1913 tmpbuf.Name += (GElf_##Name) value; \ 1914 break; 1915 TYPES; 1916 #undef DO_TYPE 1917 default: 1918 abort (); 1919 } 1920 1921 /* Now finally put in the new value. */ 1922 Elf_Data *s = gelf_xlatetof (debugelf, &rdata, 1923 &tmpdata, 1924 ehdr->e_ident[EI_DATA]); 1925 if (s == NULL) 1926 INTERNAL_ERROR (fname); 1927 assert (s == &rdata); 1928 1929 return true; 1930 } 1931 return false; 1932 } 1933 1934 if (shdr->sh_entsize == 0) 1935 INTERNAL_ERROR (fname); 1936 1937 size_t nrels = shdr->sh_size / shdr->sh_entsize; 1938 size_t next = 0; 1939 if (shdr->sh_type == SHT_REL) 1940 for (size_t relidx = 0; relidx < nrels; ++relidx) 1941 { 1942 GElf_Rel rel_mem; 1943 GElf_Rel *r = gelf_getrel (reldata, relidx, &rel_mem); 1944 if (! relocate (r->r_offset, 0, false, 1945 GELF_R_TYPE (r->r_info), 1946 GELF_R_SYM (r->r_info))) 1947 { 1948 if (relidx != next) 1949 gelf_update_rel (reldata, next, r); 1950 ++next; 1951 } 1952 } 1953 else 1954 for (size_t relidx = 0; relidx < nrels; ++relidx) 1955 { 1956 GElf_Rela rela_mem; 1957 GElf_Rela *r = gelf_getrela (reldata, relidx, &rela_mem); 1958 if (! relocate (r->r_offset, r->r_addend, true, 1959 GELF_R_TYPE (r->r_info), 1960 GELF_R_SYM (r->r_info))) 1961 { 1962 if (relidx != next) 1963 gelf_update_rela (reldata, next, r); 1964 ++next; 1965 } 1966 } 1967 1968 nrels = next; 1969 shdr->sh_size = reldata->d_size = nrels * shdr->sh_entsize; 1970 gelf_update_shdr (scn, shdr); 1971 } 1972 } 1973 } 1974 1975 /* Now that we have done all adjustments to the data, 1976 we can actually write out the debug file. */ 1977 if (debug_fname != NULL) 1978 { 1979 /* Finally write the file. */ 1980 if (unlikely (elf_update (debugelf, ELF_C_WRITE) == -1)) 1981 { 1982 error (0, 0, gettext ("while writing '%s': %s"), 1983 tmp_debug_fname, elf_errmsg (-1)); 1984 result = 1; 1985 goto fail_close; 1986 } 1987 1988 /* Create the real output file. First rename, then change the 1989 mode. */ 1990 if (rename (tmp_debug_fname, debug_fname) != 0 1991 || fchmod (debug_fd, mode) != 0) 1992 { 1993 error (0, errno, gettext ("while creating '%s'"), debug_fname); 1994 result = 1; 1995 goto fail_close; 1996 } 1997 1998 /* The temporary file does not exist anymore. */ 1999 free (tmp_debug_fname); 2000 tmp_debug_fname = NULL; 2001 2002 if (!remove_shdrs) 2003 { 2004 uint32_t debug_crc; 2005 Elf_Data debug_crc_data = 2006 { 2007 .d_type = ELF_T_WORD, 2008 .d_buf = &debug_crc, 2009 .d_size = sizeof (debug_crc), 2010 .d_version = EV_CURRENT 2011 }; 2012 2013 /* Compute the checksum which we will add to the executable. */ 2014 if (crc32_file (debug_fd, &debug_crc) != 0) 2015 { 2016 error (0, errno, gettext ("\ 2017 while computing checksum for debug information")); 2018 unlink (debug_fname); 2019 result = 1; 2020 goto fail_close; 2021 } 2022 2023 /* Store it in the debuglink section data. */ 2024 if (unlikely (gelf_xlatetof (newelf, &debuglink_crc_data, 2025 &debug_crc_data, ehdr->e_ident[EI_DATA]) 2026 != &debuglink_crc_data)) 2027 INTERNAL_ERROR (fname); 2028 } 2029 } 2030 2031 /* Finally finish the ELF header. Fill in the fields not handled by 2032 libelf from the old file. */ 2033 newehdr = gelf_getehdr (newelf, &newehdr_mem); 2034 if (newehdr == NULL) 2035 INTERNAL_ERROR (fname); 2036 2037 memcpy (newehdr->e_ident, ehdr->e_ident, EI_NIDENT); 2038 newehdr->e_type = ehdr->e_type; 2039 newehdr->e_machine = ehdr->e_machine; 2040 newehdr->e_version = ehdr->e_version; 2041 newehdr->e_entry = ehdr->e_entry; 2042 newehdr->e_flags = ehdr->e_flags; 2043 newehdr->e_phoff = ehdr->e_phoff; 2044 2045 /* We need to position the section header table. */ 2046 const size_t offsize = gelf_fsize (elf, ELF_T_OFF, 1, EV_CURRENT); 2047 newehdr->e_shoff = ((shdr_info[shdridx].shdr.sh_offset 2048 + shdr_info[shdridx].shdr.sh_size + offsize - 1) 2049 & ~((GElf_Off) (offsize - 1))); 2050 newehdr->e_shentsize = gelf_fsize (elf, ELF_T_SHDR, 1, EV_CURRENT); 2051 2052 /* The new section header string table index. */ 2053 if (likely (idx < SHN_HIRESERVE) && likely (idx != SHN_XINDEX)) 2054 newehdr->e_shstrndx = idx; 2055 else 2056 { 2057 /* The index does not fit in the ELF header field. */ 2058 shdr_info[0].scn = elf_getscn (elf, 0); 2059 2060 if (gelf_getshdr (shdr_info[0].scn, &shdr_info[0].shdr) == NULL) 2061 INTERNAL_ERROR (fname); 2062 2063 shdr_info[0].shdr.sh_link = idx; 2064 (void) gelf_update_shdr (shdr_info[0].scn, &shdr_info[0].shdr); 2065 2066 newehdr->e_shstrndx = SHN_XINDEX; 2067 } 2068 2069 if (gelf_update_ehdr (newelf, newehdr) == 0) 2070 { 2071 error (0, 0, gettext ("%s: error while creating ELF header: %s"), 2072 output_fname ?: fname, elf_errmsg (-1)); 2073 cleanup_debug (); 2074 return 1; 2075 } 2076 2077 /* We have everything from the old file. */ 2078 if (elf_cntl (elf, ELF_C_FDDONE) != 0) 2079 { 2080 error (0, 0, gettext ("%s: error while reading the file: %s"), 2081 fname, elf_errmsg (-1)); 2082 cleanup_debug (); 2083 return 1; 2084 } 2085 2086 /* The ELF library better follows our layout when this is not a 2087 relocatable object file. */ 2088 elf_flagelf (newelf, ELF_C_SET, 2089 (ehdr->e_type != ET_REL ? ELF_F_LAYOUT : 0) 2090 | (permissive ? ELF_F_PERMISSIVE : 0)); 2091 2092 /* Finally write the file. */ 2093 if (elf_update (newelf, ELF_C_WRITE) == -1) 2094 { 2095 error (0, 0, gettext ("while writing '%s': %s"), 2096 output_fname ?: fname, elf_errmsg (-1)); 2097 result = 1; 2098 } 2099 2100 if (remove_shdrs) 2101 { 2102 /* libelf can't cope without the section headers being properly intact. 2103 So we just let it write them normally, and then we nuke them later. */ 2104 2105 if (newehdr->e_ident[EI_CLASS] == ELFCLASS32) 2106 { 2107 assert (offsetof (Elf32_Ehdr, e_shentsize) + sizeof (Elf32_Half) 2108 == offsetof (Elf32_Ehdr, e_shnum)); 2109 assert (offsetof (Elf32_Ehdr, e_shnum) + sizeof (Elf32_Half) 2110 == offsetof (Elf32_Ehdr, e_shstrndx)); 2111 const Elf32_Off zero_off = 0; 2112 const Elf32_Half zero[3] = { 0, 0, SHN_UNDEF }; 2113 if (pwrite_retry (fd, &zero_off, sizeof zero_off, 2114 offsetof (Elf32_Ehdr, e_shoff)) != sizeof zero_off 2115 || (pwrite_retry (fd, zero, sizeof zero, 2116 offsetof (Elf32_Ehdr, e_shentsize)) 2117 != sizeof zero) 2118 || ftruncate (fd, shdr_info[shdridx].shdr.sh_offset) < 0) 2119 { 2120 error (0, errno, gettext ("while writing '%s'"), 2121 output_fname ?: fname); 2122 result = 1; 2123 } 2124 } 2125 else 2126 { 2127 assert (offsetof (Elf64_Ehdr, e_shentsize) + sizeof (Elf64_Half) 2128 == offsetof (Elf64_Ehdr, e_shnum)); 2129 assert (offsetof (Elf64_Ehdr, e_shnum) + sizeof (Elf64_Half) 2130 == offsetof (Elf64_Ehdr, e_shstrndx)); 2131 const Elf64_Off zero_off = 0; 2132 const Elf64_Half zero[3] = { 0, 0, SHN_UNDEF }; 2133 if (pwrite_retry (fd, &zero_off, sizeof zero_off, 2134 offsetof (Elf64_Ehdr, e_shoff)) != sizeof zero_off 2135 || (pwrite_retry (fd, zero, sizeof zero, 2136 offsetof (Elf64_Ehdr, e_shentsize)) 2137 != sizeof zero) 2138 || ftruncate (fd, shdr_info[shdridx].shdr.sh_offset) < 0) 2139 { 2140 error (0, errno, gettext ("while writing '%s'"), 2141 output_fname ?: fname); 2142 result = 1; 2143 } 2144 } 2145 } 2146 2147 fail_close: 2148 if (shdr_info != NULL) 2149 { 2150 /* For some sections we might have created an table to map symbol 2151 table indices. */ 2152 if (any_symtab_changes) 2153 for (cnt = 1; cnt <= shdridx; ++cnt) 2154 { 2155 free (shdr_info[cnt].newsymidx); 2156 if (shdr_info[cnt].debug_data != NULL) 2157 free (shdr_info[cnt].debug_data->d_buf); 2158 } 2159 2160 /* Free data we allocated for the .gnu_debuglink section. */ 2161 free (debuglink_buf); 2162 2163 /* Free the memory. */ 2164 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC) 2165 free (shdr_info); 2166 } 2167 2168 /* Free other resources. */ 2169 if (shstrtab_data != NULL) 2170 free (shstrtab_data->d_buf); 2171 if (shst != NULL) 2172 ebl_strtabfree (shst); 2173 2174 /* That was it. Close the descriptors. */ 2175 if (elf_end (newelf) != 0) 2176 { 2177 error (0, 0, gettext ("error while finishing '%s': %s"), 2178 output_fname ?: fname, elf_errmsg (-1)); 2179 result = 1; 2180 } 2181 2182 if (debugelf != NULL && elf_end (debugelf) != 0) 2183 { 2184 error (0, 0, gettext ("error while finishing '%s': %s"), debug_fname, 2185 elf_errmsg (-1)); 2186 result = 1; 2187 } 2188 2189 fail: 2190 /* Close the EBL backend. */ 2191 if (ebl != NULL) 2192 ebl_closebackend (ebl); 2193 2194 cleanup_debug (); 2195 2196 /* If requested, preserve the timestamp. */ 2197 if (tvp != NULL) 2198 { 2199 if (futimens (fd, tvp) != 0) 2200 { 2201 error (0, errno, gettext ("\ 2202 cannot set access and modification date of '%s'"), 2203 output_fname ?: fname); 2204 result = 1; 2205 } 2206 } 2207 2208 /* Close the file descriptor if we created a new file. */ 2209 if (output_fname != NULL) 2210 close (fd); 2211 2212 return result; 2213 } 2214 2215 static void 2216 cleanup_debug (void) 2217 { 2218 if (debug_fd >= 0) 2219 { 2220 if (tmp_debug_fname != NULL) 2221 { 2222 unlink (tmp_debug_fname); 2223 free (tmp_debug_fname); 2224 tmp_debug_fname = NULL; 2225 } 2226 close (debug_fd); 2227 debug_fd = -1; 2228 } 2229 } 2230 2231 static int 2232 handle_ar (int fd, Elf *elf, const char *prefix, const char *fname, 2233 struct timespec tvp[2]) 2234 { 2235 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix); 2236 size_t fname_len = strlen (fname) + 1; 2237 char new_prefix[prefix_len + 1 + fname_len]; 2238 char *cp = new_prefix; 2239 2240 /* Create the full name of the file. */ 2241 if (prefix != NULL) 2242 { 2243 cp = mempcpy (cp, prefix, prefix_len); 2244 *cp++ = ':'; 2245 } 2246 memcpy (cp, fname, fname_len); 2247 2248 2249 /* Process all the files contained in the archive. */ 2250 Elf *subelf; 2251 Elf_Cmd cmd = ELF_C_RDWR; 2252 int result = 0; 2253 while ((subelf = elf_begin (fd, cmd, elf)) != NULL) 2254 { 2255 /* The the header for this element. */ 2256 Elf_Arhdr *arhdr = elf_getarhdr (subelf); 2257 2258 if (elf_kind (subelf) == ELF_K_ELF) 2259 result |= handle_elf (fd, subelf, new_prefix, arhdr->ar_name, 0, NULL); 2260 else if (elf_kind (subelf) == ELF_K_AR) 2261 result |= handle_ar (fd, subelf, new_prefix, arhdr->ar_name, NULL); 2262 2263 /* Get next archive element. */ 2264 cmd = elf_next (subelf); 2265 if (unlikely (elf_end (subelf) != 0)) 2266 INTERNAL_ERROR (fname); 2267 } 2268 2269 if (tvp != NULL) 2270 { 2271 if (unlikely (futimens (fd, tvp) != 0)) 2272 { 2273 error (0, errno, gettext ("\ 2274 cannot set access and modification date of '%s'"), fname); 2275 result = 1; 2276 } 2277 } 2278 2279 if (unlikely (close (fd) != 0)) 2280 error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname); 2281 2282 return result; 2283 } 2284 2285 2286 #include "debugpred.h" 2287
