src/strip.c

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