contrib/elftoolchain/elfcopy/sections.c

   1 /*-
   2  * Copyright (c) 2007-2011,2014 Kai Wang
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/param.h>
  28 #include <sys/stat.h>
  29 #include <err.h>
  30 #include <libgen.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include "elfcopy.h"
  36
  37 ELFTC_VCSID("$Id: sections.c 3646 2018-10-27 02:25:39Z emaste $");
  38
  39 static void     add_gnu_debuglink(struct elfcopy *ecp);
  40 static uint32_t calc_crc32(const char *p, size_t len, uint32_t crc);
  41 static void     check_section_rename(struct elfcopy *ecp, struct section *s);
  42 static void     filter_reloc(struct elfcopy *ecp, struct section *s);
  43 static int      get_section_flags(struct elfcopy *ecp, const char *name);
  44 static void     insert_sections(struct elfcopy *ecp);
  45 static int      is_append_section(struct elfcopy *ecp, const char *name);
  46 static int      is_compress_section(struct elfcopy *ecp, const char *name);
  47 static int      is_debug_section(const char *name);
  48 static int      is_dwo_section(const char *name);
  49 static int      is_modify_section(struct elfcopy *ecp, const char *name);
  50 static int      is_print_section(struct elfcopy *ecp, const char *name);
  51 static void     modify_section(struct elfcopy *ecp, struct section *s);
  52 static void     pad_section(struct elfcopy *ecp, struct section *s);
  53 static void     print_data(const char *d, size_t sz);
  54 static void     print_section(struct section *s);
  55 static void     *read_section(struct section *s, size_t *size);
  56 static void     set_shstrtab(struct elfcopy *ecp);
  57 static void     update_reloc(struct elfcopy *ecp, struct section *s);
  58 static void     update_section_group(struct elfcopy *ecp, struct section *s);
  59
  60 int
  61 is_remove_section(struct elfcopy *ecp, const char *name)
  62 {
  63
  64         /* Always keep section name table */
  65         if (strcmp(name, ".shstrtab") == 0)
  66                 return 0;
  67         if (strcmp(name, ".symtab") == 0 ||
  68             strcmp(name, ".strtab") == 0) {
  69                 if (ecp->strip == STRIP_ALL && lookup_symop_list(
  70                     ecp, NULL, SYMOP_KEEP) == NULL)
  71                         return (1);
  72                 else
  73                         return (0);
  74         }
  75
  76         if (ecp->strip == STRIP_DWO && is_dwo_section(name))
  77                 return (1);
  78         if (ecp->strip == STRIP_NONDWO && !is_dwo_section(name))
  79                 return (1);
  80
  81         if (is_debug_section(name)) {
  82                 if (ecp->strip == STRIP_ALL ||
  83                     ecp->strip == STRIP_DEBUG ||
  84                     ecp->strip == STRIP_UNNEEDED ||
  85                     (ecp->flags & DISCARD_LOCAL))
  86                         return (1);
  87                 if (ecp->strip == STRIP_NONDEBUG)
  88                         return (0);
  89         }
  90
  91         if ((ecp->flags & SEC_REMOVE) || (ecp->flags & SEC_COPY)) {
  92                 struct sec_action *sac;
  93
  94                 sac = lookup_sec_act(ecp, name, 0);
  95                 if ((ecp->flags & SEC_REMOVE) && sac != NULL && sac->remove)
  96                         return (1);
  97                 if ((ecp->flags & SEC_COPY) && (sac == NULL || !sac->copy))
  98                         return (1);
  99         }
 100
 101         return (0);
 102 }
 103
 104 /*
 105  * Relocation section needs to be removed if the section it applies to
 106  * will be removed.
 107  */
 108 int
 109 is_remove_reloc_sec(struct elfcopy *ecp, uint32_t sh_info)
 110 {
 111         const char      *name;
 112         GElf_Shdr        ish;
 113         Elf_Scn         *is;
 114         size_t           indx;
 115         int              elferr;
 116
 117         if (elf_getshstrndx(ecp->ein, &indx) == 0)
 118                 errx(EXIT_FAILURE, "elf_getshstrndx failed: %s",
 119                     elf_errmsg(-1));
 120
 121         is = elf_getscn(ecp->ein, sh_info);
 122         if (is != NULL) {
 123                 if (gelf_getshdr(is, &ish) == NULL)
 124                         errx(EXIT_FAILURE, "gelf_getshdr failed: %s",
 125                             elf_errmsg(-1));
 126                 if ((name = elf_strptr(ecp->ein, indx, ish.sh_name)) ==
 127                     NULL)
 128                         errx(EXIT_FAILURE, "elf_strptr failed: %s",
 129                             elf_errmsg(-1));
 130                 if (is_remove_section(ecp, name))
 131                         return (1);
 132                 else
 133                         return (0);
 134         }
 135         elferr = elf_errno();
 136         if (elferr != 0)
 137                 errx(EXIT_FAILURE, "elf_nextscn failed: %s",
 138                     elf_errmsg(elferr));
 139
 140         /* Remove reloc section if we can't find the target section. */
 141         return (1);
 142 }
 143
 144 static int
 145 is_append_section(struct elfcopy *ecp, const char *name)
 146 {
 147         struct sec_action *sac;
 148
 149         sac = lookup_sec_act(ecp, name, 0);
 150         if (sac != NULL && sac->append != 0 && sac->string != NULL)
 151                 return (1);
 152
 153         return (0);
 154 }
 155
 156 static int
 157 is_compress_section(struct elfcopy *ecp, const char *name)
 158 {
 159         struct sec_action *sac;
 160
 161         sac = lookup_sec_act(ecp, name, 0);
 162         if (sac != NULL && sac->compress != 0)
 163                 return (1);
 164
 165         return (0);
 166 }
 167
 168 static void
 169 check_section_rename(struct elfcopy *ecp, struct section *s)
 170 {
 171         struct sec_action *sac;
 172         char *prefix;
 173         size_t namelen;
 174
 175         if (s->pseudo)
 176                 return;
 177
 178         sac = lookup_sec_act(ecp, s->name, 0);
 179         if (sac != NULL && sac->rename)
 180                 s->name = sac->newname;
 181
 182         if (!strcmp(s->name, ".symtab") ||
 183             !strcmp(s->name, ".strtab") ||
 184             !strcmp(s->name, ".shstrtab"))
 185                 return;
 186
 187         prefix = NULL;
 188         if (s->loadable && ecp->prefix_alloc != NULL)
 189                 prefix = ecp->prefix_alloc;
 190         else if (ecp->prefix_sec != NULL)
 191                 prefix = ecp->prefix_sec;
 192
 193         if (prefix != NULL) {
 194                 namelen = strlen(s->name) + strlen(prefix) + 1;
 195                 if ((s->newname = malloc(namelen)) == NULL)
 196                         err(EXIT_FAILURE, "malloc failed");
 197                 snprintf(s->newname, namelen, "%s%s", prefix, s->name);
 198                 s->name = s->newname;
 199         }
 200 }
 201
 202 static int
 203 get_section_flags(struct elfcopy *ecp, const char *name)
 204 {
 205         struct sec_action *sac;
 206
 207         sac = lookup_sec_act(ecp, name, 0);
 208         if (sac != NULL && sac->flags)
 209                 return sac->flags;
 210
 211         return (0);
 212 }
 213
 214 /*
 215  * Determine whether the section are debugging section.
 216  * According to libbfd, debugging sections are recognized
 217  * only by name.
 218  */
 219 static int
 220 is_debug_section(const char *name)
 221 {
 222         const char *dbg_sec[] = {
 223                 ".apple_",
 224                 ".debug",
 225                 ".gnu.linkonce.wi.",
 226                 ".line",
 227                 ".stab",
 228                 NULL
 229         };
 230         const char **p;
 231
 232         for(p = dbg_sec; *p; p++) {
 233                 if (strncmp(name, *p, strlen(*p)) == 0)
 234                         return (1);
 235         }
 236
 237         return (0);
 238 }
 239
 240 static int
 241 is_dwo_section(const char *name)
 242 {
 243         size_t len;
 244
 245         if ((len = strlen(name)) > 4 && strcmp(name + len - 4, ".dwo") == 0)
 246                 return (1);
 247         return (0);
 248 }
 249
 250 static int
 251 is_print_section(struct elfcopy *ecp, const char *name)
 252 {
 253         struct sec_action *sac;
 254
 255         sac = lookup_sec_act(ecp, name, 0);
 256         if (sac != NULL && sac->print != 0)
 257                 return (1);
 258
 259         return (0);
 260 }
 261
 262 static int
 263 is_modify_section(struct elfcopy *ecp, const char *name)
 264 {
 265
 266         if (is_append_section(ecp, name) ||
 267             is_compress_section(ecp, name))
 268                 return (1);
 269
 270         return (0);
 271 }
 272
 273 struct sec_action*
 274 lookup_sec_act(struct elfcopy *ecp, const char *name, int add)
 275 {
 276         struct sec_action *sac;
 277
 278         if (name == NULL)
 279                 return NULL;
 280
 281         STAILQ_FOREACH(sac, &ecp->v_sac, sac_list) {
 282                 if (strcmp(name, sac->name) == 0)
 283                         return sac;
 284         }
 285
 286         if (add == 0)
 287                 return NULL;
 288
 289         if ((sac = malloc(sizeof(*sac))) == NULL)
 290                 errx(EXIT_FAILURE, "not enough memory");
 291         memset(sac, 0, sizeof(*sac));
 292         sac->name = name;
 293         STAILQ_INSERT_TAIL(&ecp->v_sac, sac, sac_list);
 294
 295         return (sac);
 296 }
 297
 298 void
 299 free_sec_act(struct elfcopy *ecp)
 300 {
 301         struct sec_action *sac, *sac_temp;
 302
 303         STAILQ_FOREACH_SAFE(sac, &ecp->v_sac, sac_list, sac_temp) {
 304                 STAILQ_REMOVE(&ecp->v_sac, sac, sec_action, sac_list);
 305                 free(sac);
 306         }
 307 }
 308
 309 void
 310 insert_to_sec_list(struct elfcopy *ecp, struct section *sec, int tail)
 311 {
 312         struct section *s;
 313
 314         if (tail || TAILQ_EMPTY(&ecp->v_sec) ||
 315             TAILQ_LAST(&ecp->v_sec, sectionlist)->off <= sec->off) {
 316                 TAILQ_INSERT_TAIL(&ecp->v_sec, sec, sec_list);
 317         } else {
 318                 TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
 319                         if (sec->off < s->off) {
 320                                 TAILQ_INSERT_BEFORE(s, sec, sec_list);
 321                                 break;
 322                         }
 323                 }
 324         }
 325
 326         if (sec->pseudo == 0)
 327                 ecp->nos++;
 328 }
 329
 330 /*
 331  * First step of section creation: create scn and internal section
 332  * structure, discard sections to be removed.
 333  */
 334 void
 335 create_scn(struct elfcopy *ecp)
 336 {
 337         struct section  *s;
 338         const char      *name;
 339         Elf_Scn         *is;
 340         GElf_Shdr        ish;
 341         size_t           indx;
 342         uint64_t         oldndx, newndx;
 343         int              elferr, sec_flags, reorder;
 344
 345         /*
 346          * Insert a pseudo section that contains the ELF header
 347          * and program header. Used as reference for section offset
 348          * or load address adjustment.
 349          */
 350         if ((s = calloc(1, sizeof(*s))) == NULL)
 351                 err(EXIT_FAILURE, "calloc failed");
 352         s->off = 0;
 353         s->sz = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT) +
 354             gelf_fsize(ecp->eout, ELF_T_PHDR, ecp->ophnum, EV_CURRENT);
 355         s->align = 1;
 356         s->pseudo = 1;
 357         s->loadable = add_to_inseg_list(ecp, s);
 358         insert_to_sec_list(ecp, s, 0);
 359
 360         /* Create internal .shstrtab section. */
 361         init_shstrtab(ecp);
 362
 363         if (elf_getshstrndx(ecp->ein, &indx) == 0)
 364                 errx(EXIT_FAILURE, "elf_getshstrndx failed: %s",
 365                     elf_errmsg(-1));
 366
 367         reorder = 0;
 368         is = NULL;
 369         while ((is = elf_nextscn(ecp->ein, is)) != NULL) {
 370                 if (gelf_getshdr(is, &ish) == NULL)
 371                         errx(EXIT_FAILURE, "gelf_getshdr failed: %s",
 372                             elf_errmsg(-1));
 373                 if ((name = elf_strptr(ecp->ein, indx, ish.sh_name)) == NULL)
 374                         errx(EXIT_FAILURE, "elf_strptr failed: %s",
 375                             elf_errmsg(-1));
 376
 377                 /* Skip sections to be removed. */
 378                 if (is_remove_section(ecp, name))
 379                         continue;
 380
 381                 /*
 382                  * Relocation section need to be remove if the section
 383                  * it applies will be removed.
 384                  */
 385                 if (ish.sh_type == SHT_REL || ish.sh_type == SHT_RELA)
 386                         if (ish.sh_info != 0 &&
 387                             is_remove_reloc_sec(ecp, ish.sh_info))
 388                                 continue;
 389
 390                 /*
 391                  * Section groups should be removed if symbol table will
 392                  * be removed. (section group's signature stored in symbol
 393                  * table)
 394                  */
 395                 if (ish.sh_type == SHT_GROUP && ecp->strip == STRIP_ALL)
 396                         continue;
 397
 398                 /* Get section flags set by user. */
 399                 sec_flags = get_section_flags(ecp, name);
 400
 401                 /* Create internal section object. */
 402                 if (strcmp(name, ".shstrtab") != 0) {
 403                         if ((s = calloc(1, sizeof(*s))) == NULL)
 404                                 err(EXIT_FAILURE, "calloc failed");
 405                         s->name         = name;
 406                         s->is           = is;
 407                         s->off          = ish.sh_offset;
 408                         s->sz           = ish.sh_size;
 409                         s->align        = ish.sh_addralign;
 410                         s->type         = ish.sh_type;
 411                         s->flags        = ish.sh_flags;
 412                         s->vma          = ish.sh_addr;
 413
 414                         /*
 415                          * Search program headers to determine whether section
 416                          * is loadable, but if user explicitly set section flags
 417                          * while neither "load" nor "alloc" is set, we make the
 418                          * section unloadable.
 419                          *
 420                          * Sections in relocatable object is loadable if
 421                          * section flag SHF_ALLOC is set.
 422                          */
 423                         if (sec_flags &&
 424                             (sec_flags & (SF_LOAD | SF_ALLOC)) == 0)
 425                                 s->loadable = 0;
 426                         else {
 427                                 s->loadable = add_to_inseg_list(ecp, s);
 428                                 if ((ecp->flags & RELOCATABLE) &&
 429                                     (ish.sh_flags & SHF_ALLOC))
 430                                         s->loadable = 1;
 431                         }
 432                 } else {
 433                         /* Assuming .shstrtab is "unloadable". */
 434                         s               = ecp->shstrtab;
 435                         s->off          = ish.sh_offset;
 436                 }
 437
 438                 oldndx = newndx = SHN_UNDEF;
 439                 if (strcmp(name, ".symtab") != 0 &&
 440                     strcmp(name, ".strtab") != 0) {
 441                         if (!strcmp(name, ".shstrtab")) {
 442                                 /*
 443                                  * Add sections specified by --add-section and
 444                                  * gnu debuglink. we want these sections have
 445                                  * smaller index than .shstrtab section.
 446                                  */
 447                                 if (ecp->debuglink != NULL)
 448                                         add_gnu_debuglink(ecp);
 449                                 if (ecp->flags & SEC_ADD)
 450                                         insert_sections(ecp);
 451                         }
 452                         if ((s->os = elf_newscn(ecp->eout)) == NULL)
 453                                 errx(EXIT_FAILURE, "elf_newscn failed: %s",
 454                                     elf_errmsg(-1));
 455                         if ((newndx = elf_ndxscn(s->os)) == SHN_UNDEF)
 456                                 errx(EXIT_FAILURE, "elf_ndxscn failed: %s",
 457                                     elf_errmsg(-1));
 458                 }
 459                 if ((oldndx = elf_ndxscn(is)) == SHN_UNDEF)
 460                         errx(EXIT_FAILURE, "elf_ndxscn failed: %s",
 461                             elf_errmsg(-1));
 462                 if (oldndx != SHN_UNDEF && newndx != SHN_UNDEF)
 463                         ecp->secndx[oldndx] = newndx;
 464
 465                 /*
 466                  * If strip action is STRIP_NONDEBUG(only keep debug),
 467                  * change sections type of loadable sections and section
 468                  * groups to SHT_NOBITS, and the content of those sections
 469                  * will be discarded. However, SHT_NOTE sections should
 470                  * be kept.
 471                  */
 472                 if (ecp->strip == STRIP_NONDEBUG) {
 473                         if (((ish.sh_flags & SHF_ALLOC) ||
 474                             (ish.sh_flags & SHF_GROUP)) &&
 475                             ish.sh_type != SHT_NOTE)
 476                                 s->type = SHT_NOBITS;
 477                 }
 478
 479                 check_section_rename(ecp, s);
 480
 481                 /* create section header based on input object. */
 482                 if (strcmp(name, ".symtab") != 0 &&
 483                     strcmp(name, ".strtab") != 0 &&
 484                     strcmp(name, ".shstrtab") != 0) {
 485                         copy_shdr(ecp, s, NULL, 0, sec_flags);
 486                         /*
 487                          * elfcopy puts .symtab, .strtab and .shstrtab
 488                          * sections in the end of the output object.
 489                          * If the input objects have more sections
 490                          * after any of these 3 sections, the section
 491                          * table will be reordered. section symbols
 492                          * should be regenerated for relocations.
 493                          */
 494                         if (reorder)
 495                                 ecp->flags &= ~SYMTAB_INTACT;
 496                 } else
 497                         reorder = 1;
 498
 499                 if (strcmp(name, ".symtab") == 0) {
 500                         ecp->flags |= SYMTAB_EXIST;
 501                         ecp->symtab = s;
 502                 }
 503                 if (strcmp(name, ".strtab") == 0)
 504                         ecp->strtab = s;
 505
 506                 insert_to_sec_list(ecp, s, 0);
 507         }
 508         elferr = elf_errno();
 509         if (elferr != 0)
 510                 errx(EXIT_FAILURE, "elf_nextscn failed: %s",
 511                     elf_errmsg(elferr));
 512 }
 513
 514 struct section *
 515 insert_shtab(struct elfcopy *ecp, int tail)
 516 {
 517         struct section  *s, *shtab;
 518         GElf_Ehdr        ieh;
 519         int              nsecs;
 520
 521         /*
 522          * Treat section header table as a "pseudo" section, insert it
 523          * into section list, so later it will get sorted and resynced
 524          * just as normal sections.
 525          */
 526         if ((shtab = calloc(1, sizeof(*shtab))) == NULL)
 527                 errx(EXIT_FAILURE, "calloc failed");
 528         if (!tail) {
 529                 /*
 530                  * "shoff" of input object is used as a hint for section
 531                  * resync later.
 532                  */
 533                 if (gelf_getehdr(ecp->ein, &ieh) == NULL)
 534                         errx(EXIT_FAILURE, "gelf_getehdr() failed: %s",
 535                             elf_errmsg(-1));
 536                 shtab->off = ieh.e_shoff;
 537         } else
 538                 shtab->off = 0;
 539         /* Calculate number of sections in the output object. */
 540         nsecs = 0;
 541         TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
 542                 if (!s->pseudo)
 543                         nsecs++;
 544         }
 545         /* Remember there is always a null section, so we +1 here. */
 546         shtab->sz = gelf_fsize(ecp->eout, ELF_T_SHDR, nsecs + 1, EV_CURRENT);
 547         if (shtab->sz == 0)
 548                 errx(EXIT_FAILURE, "gelf_fsize() failed: %s", elf_errmsg(-1));
 549         shtab->align = (ecp->oec == ELFCLASS32 ? 4 : 8);
 550         shtab->loadable = 0;
 551         shtab->pseudo = 1;
 552         insert_to_sec_list(ecp, shtab, tail);
 553
 554         return (shtab);
 555 }
 556
 557 void
 558 copy_content(struct elfcopy *ecp)
 559 {
 560         struct section *s;
 561
 562         TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
 563                 /* Skip pseudo section. */
 564                 if (s->pseudo)
 565                         continue;
 566
 567                 /* Skip special sections. */
 568                 if (strcmp(s->name, ".symtab") == 0 ||
 569                     strcmp(s->name, ".strtab") == 0 ||
 570                     strcmp(s->name, ".shstrtab") == 0)
 571                         continue;
 572
 573                 /*
 574                  * If strip action is STRIP_ALL, relocation info need
 575                  * to be stripped. Skip filtering otherwisw.
 576                  */
 577                 if (ecp->strip == STRIP_ALL &&
 578                     (s->type == SHT_REL || s->type == SHT_RELA))
 579                         filter_reloc(ecp, s);
 580
 581                 /*
 582                  * The section indices in the SHT_GROUP section needs
 583                  * to be updated since we might have stripped some
 584                  * sections and changed section numbering.
 585                  */
 586                 if (s->type == SHT_GROUP)
 587                         update_section_group(ecp, s);
 588
 589                 if (is_modify_section(ecp, s->name))
 590                         modify_section(ecp, s);
 591
 592                 copy_data(s);
 593
 594                 /*
 595                  * If symbol table is modified, relocation info might
 596                  * need update, as symbol index may have changed.
 597                  */
 598                 if ((ecp->flags & SYMTAB_INTACT) == 0 &&
 599                     (ecp->flags & SYMTAB_EXIST) &&
 600                     (s->type == SHT_REL || s->type == SHT_RELA))
 601                         update_reloc(ecp, s);
 602
 603                 if (is_print_section(ecp, s->name))
 604                         print_section(s);
 605         }
 606 }
 607
 608
 609 /*
 610  * Update section group section. The section indices in the SHT_GROUP
 611  * section need update after section numbering changed.
 612  */
 613 static void
 614 update_section_group(struct elfcopy *ecp, struct section *s)
 615 {
 616         GElf_Shdr        ish;
 617         Elf_Data        *id;
 618         uint32_t        *ws, *wd;
 619         uint64_t         n;
 620         size_t           ishnum;
 621         int              i, j;
 622
 623         if (!elf_getshnum(ecp->ein, &ishnum))
 624                 errx(EXIT_FAILURE, "elf_getshnum failed: %s",
 625                     elf_errmsg(-1));
 626
 627         if (gelf_getshdr(s->is, &ish) == NULL)
 628                 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s",
 629                     elf_errmsg(-1));
 630
 631         if ((id = elf_getdata(s->is, NULL)) == NULL)
 632                 errx(EXIT_FAILURE, "elf_getdata() failed: %s",
 633                     elf_errmsg(-1));
 634
 635         if (ish.sh_size == 0)
 636                 return;
 637
 638         if (ish.sh_entsize == 0)
 639                 ish.sh_entsize = 4;
 640
 641         ws = id->d_buf;
 642
 643         /* We only support COMDAT section. */
 644 #ifndef GRP_COMDAT
 645 #define GRP_COMDAT 0x1
 646 #endif
 647         if ((*ws & GRP_COMDAT) == 0)
 648                 return;
 649
 650         if ((s->buf = malloc(ish.sh_size)) == NULL)
 651                 err(EXIT_FAILURE, "malloc failed");
 652
 653         s->sz = ish.sh_size;
 654
 655         wd = s->buf;
 656
 657         /* Copy the flag word as-is. */
 658         *wd = *ws;
 659
 660         /* Update the section indices. */
 661         n = ish.sh_size / ish.sh_entsize;
 662         for(i = 1, j = 1; (uint64_t)i < n; i++) {
 663                 if (ws[i] != SHN_UNDEF && ws[i] < ishnum &&
 664                     ecp->secndx[ws[i]] != 0)
 665                         wd[j++] = ecp->secndx[ws[i]];
 666                 else
 667                         s->sz -= 4;
 668         }
 669
 670         s->nocopy = 1;
 671 }
 672
 673 /*
 674  * Filter relocation entries, only keep those entries whose
 675  * symbol is in the keep list.
 676  */
 677 static void
 678 filter_reloc(struct elfcopy *ecp, struct section *s)
 679 {
 680         const char      *name;
 681         GElf_Shdr        ish;
 682         GElf_Rel         rel;
 683         GElf_Rela        rela;
 684         Elf32_Rel       *rel32;
 685         Elf64_Rel       *rel64;
 686         Elf32_Rela      *rela32;
 687         Elf64_Rela      *rela64;
 688         Elf_Data        *id;
 689         uint64_t         cap, n, nrels, sym;
 690         int              elferr, i;
 691
 692         if (gelf_getshdr(s->is, &ish) == NULL)
 693                 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s",
 694                     elf_errmsg(-1));
 695
 696         /* We don't want to touch relocation info for dynamic symbols. */
 697         if ((ecp->flags & SYMTAB_EXIST) == 0) {
 698                 /*
 699                  * No symbol table in output.  If sh_link points to a section
 700                  * that exists in the output object, this relocation section
 701                  * is for dynamic symbols.  Don't touch it.
 702                  */
 703                 if (ish.sh_link != 0 && ecp->secndx[ish.sh_link] != 0)
 704                         return;
 705         } else {
 706                 /* Symbol table exist, check if index equals. */
 707                 if (ish.sh_link != elf_ndxscn(ecp->symtab->is))
 708                         return;
 709         }
 710
 711 #define COPYREL(REL, SZ) do {                                   \
 712         if (nrels == 0) {                                       \
 713                 if ((REL##SZ = malloc(cap *                     \
 714                     sizeof(*REL##SZ))) == NULL)                 \
 715                         err(EXIT_FAILURE, "malloc failed");     \
 716         }                                                       \
 717         if (nrels >= cap) {                                     \
 718                 cap *= 2;                                       \
 719                 if ((REL##SZ = realloc(REL##SZ, cap *           \
 720                     sizeof(*REL##SZ))) == NULL)                 \
 721                         err(EXIT_FAILURE, "realloc failed");    \
 722         }                                                       \
 723         REL##SZ[nrels].r_offset = REL.r_offset;                 \
 724         REL##SZ[nrels].r_info   = REL.r_info;                   \
 725         if (s->type == SHT_RELA)                                \
 726                 rela##SZ[nrels].r_addend = rela.r_addend;       \
 727         nrels++;                                                \
 728 } while (0)
 729
 730         nrels = 0;
 731         cap = 4;                /* keep list is usually small. */
 732         rel32 = NULL;
 733         rel64 = NULL;
 734         rela32 = NULL;
 735         rela64 = NULL;
 736         if ((id = elf_getdata(s->is, NULL)) == NULL)
 737                 errx(EXIT_FAILURE, "elf_getdata() failed: %s",
 738                     elf_errmsg(-1));
 739         n = ish.sh_size / ish.sh_entsize;
 740         for(i = 0; (uint64_t)i < n; i++) {
 741                 if (s->type == SHT_REL) {
 742                         if (gelf_getrel(id, i, &rel) != &rel)
 743                                 errx(EXIT_FAILURE, "gelf_getrel failed: %s",
 744                                     elf_errmsg(-1));
 745                         sym = GELF_R_SYM(rel.r_info);
 746                 } else {
 747                         if (gelf_getrela(id, i, &rela) != &rela)
 748                                 errx(EXIT_FAILURE, "gelf_getrel failed: %s",
 749                                     elf_errmsg(-1));
 750                         sym = GELF_R_SYM(rela.r_info);
 751                 }
 752                 /*
 753                  * If a relocation references a symbol and we are omitting
 754                  * either that symbol or the entire symbol table we cannot
 755                  * produce valid output, and so just omit the relocation.
 756                  * Broken output like this is generally not useful, but some
 757                  * uses of elfcopy/strip rely on it - for example, GCC's build
 758                  * process uses it to check for build reproducibility by
 759                  * stripping objects and comparing them.
 760                  *
 761                  * Relocations that do not reference a symbol are retained.
 762                  */
 763                 if (sym != 0) {
 764                         if (ish.sh_link == 0 || ecp->secndx[ish.sh_link] == 0)
 765                                 continue;
 766                         name = elf_strptr(ecp->ein, elf_ndxscn(ecp->strtab->is),
 767                             sym);
 768                         if (name == NULL)
 769                                 errx(EXIT_FAILURE, "elf_strptr failed: %s",
 770                                     elf_errmsg(-1));
 771                         if (lookup_symop_list(ecp, name, SYMOP_KEEP) == NULL)
 772                                 continue;
 773                 }
 774                 if (ecp->oec == ELFCLASS32) {
 775                         if (s->type == SHT_REL)
 776                                 COPYREL(rel, 32);
 777                         else
 778                                 COPYREL(rela, 32);
 779                 } else {
 780                         if (s->type == SHT_REL)
 781                                 COPYREL(rel, 64);
 782                         else
 783                                 COPYREL(rela, 64);
 784                 }
 785         }
 786         elferr = elf_errno();
 787         if (elferr != 0)
 788                 errx(EXIT_FAILURE, "elf_getdata() failed: %s",
 789                     elf_errmsg(elferr));
 790
 791         if (ecp->oec == ELFCLASS32) {
 792                 if (s->type == SHT_REL)
 793                         s->buf = rel32;
 794                 else
 795                         s->buf = rela32;
 796         } else {
 797                 if (s->type == SHT_REL)
 798                         s->buf = rel64;
 799                 else
 800                         s->buf = rela64;
 801         }
 802         s->sz = gelf_fsize(ecp->eout, (s->type == SHT_REL ? ELF_T_REL :
 803             ELF_T_RELA), nrels, EV_CURRENT);
 804         s->nocopy = 1;
 805 }
 806
 807 static void
 808 update_reloc(struct elfcopy *ecp, struct section *s)
 809 {
 810         GElf_Shdr        osh;
 811         GElf_Rel         rel;
 812         GElf_Rela        rela;
 813         Elf_Data        *od;
 814         uint64_t         n;
 815         int              i;
 816
 817 #define UPDATEREL(REL) do {                                             \
 818         if (gelf_get##REL(od, i, &REL) != &REL)                         \
 819                 errx(EXIT_FAILURE, "gelf_get##REL failed: %s",          \
 820                     elf_errmsg(-1));                                    \
 821         REL.r_info = GELF_R_INFO(ecp->symndx[GELF_R_SYM(REL.r_info)],   \
 822             GELF_R_TYPE(REL.r_info));                                   \
 823         if (!gelf_update_##REL(od, i, &REL))                            \
 824                 errx(EXIT_FAILURE, "gelf_update_##REL failed: %s",      \
 825                     elf_errmsg(-1));                                    \
 826 } while(0)
 827
 828         if (s->sz == 0)
 829                 return;
 830         if (gelf_getshdr(s->os, &osh) == NULL)
 831                 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s",
 832                     elf_errmsg(-1));
 833         /* Only process .symtab reloc info. */
 834         if (osh.sh_link != elf_ndxscn(ecp->symtab->is))
 835                 return;
 836         if ((od = elf_getdata(s->os, NULL)) == NULL)
 837                 errx(EXIT_FAILURE, "elf_getdata() failed: %s",
 838                     elf_errmsg(-1));
 839         n = osh.sh_size / osh.sh_entsize;
 840         for(i = 0; (uint64_t)i < n; i++) {
 841                 if (s->type == SHT_REL)
 842                         UPDATEREL(rel);
 843                 else
 844                         UPDATEREL(rela);
 845         }
 846 }
 847
 848 static void
 849 pad_section(struct elfcopy *ecp, struct section *s)
 850 {
 851         GElf_Shdr        osh;
 852         Elf_Data        *od;
 853
 854         if (s == NULL || s->pad_sz == 0)
 855                 return;
 856
 857         if ((s->pad = malloc(s->pad_sz)) == NULL)
 858                 err(EXIT_FAILURE, "malloc failed");
 859         memset(s->pad, ecp->fill, s->pad_sz);
 860
 861         /* Create a new Elf_Data to contain the padding bytes. */
 862         if ((od = elf_newdata(s->os)) == NULL)
 863                 errx(EXIT_FAILURE, "elf_newdata() failed: %s",
 864                     elf_errmsg(-1));
 865         od->d_align = 1;
 866         od->d_off = s->sz;
 867         od->d_buf = s->pad;
 868         od->d_type = ELF_T_BYTE;
 869         od->d_size = s->pad_sz;
 870         od->d_version = EV_CURRENT;
 871
 872         /* Update section header. */
 873         if (gelf_getshdr(s->os, &osh) == NULL)
 874                 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
 875                     elf_errmsg(-1));
 876         osh.sh_size = s->sz + s->pad_sz;
 877         if (!gelf_update_shdr(s->os, &osh))
 878                 errx(EXIT_FAILURE, "elf_update_shdr failed: %s",
 879                     elf_errmsg(-1));
 880 }
 881
 882 void
 883 resync_sections(struct elfcopy *ecp)
 884 {
 885         struct section  *s, *ps;
 886         GElf_Shdr        osh;
 887         uint64_t         off;
 888         int              first;
 889
 890         ps = NULL;
 891         first = 1;
 892         off = 0;
 893         TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
 894                 if (first) {
 895                         off = s->off;
 896                         first = 0;
 897                 }
 898
 899                 /*
 900                  * Ignore TLS sections with load address 0 and without
 901                  * content. We don't need to adjust their file offset or
 902                  * VMA, only the size matters.
 903                  */
 904                 if (s->seg_tls != NULL && s->type == SHT_NOBITS &&
 905                     s->off == 0)
 906                         continue;
 907
 908                 /* Align section offset. */
 909                 if (s->align == 0)
 910                         s->align = 1;
 911                 if (off <= s->off) {
 912                         if (!s->loadable || (ecp->flags & RELOCATABLE))
 913                                 s->off = roundup(off, s->align);
 914                 } else {
 915                         if (s->loadable && (ecp->flags & RELOCATABLE) == 0)
 916                                 warnx("moving loadable section %s, "
 917                                     "is this intentional?", s->name);
 918                         s->off = roundup(off, s->align);
 919                 }
 920
 921                 /* Calculate next section offset. */
 922                 off = s->off;
 923                 if (s->pseudo || (s->type != SHT_NOBITS && s->type != SHT_NULL))
 924                         off += s->sz;
 925
 926                 if (s->pseudo) {
 927                         ps = NULL;
 928                         continue;
 929                 }
 930
 931                 /* Count padding bytes added through --pad-to. */
 932                 if (s->pad_sz > 0)
 933                         off += s->pad_sz;
 934
 935                 /* Update section header accordingly. */
 936                 if (gelf_getshdr(s->os, &osh) == NULL)
 937                         errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
 938                             elf_errmsg(-1));
 939                 osh.sh_addr = s->vma;
 940                 osh.sh_offset = s->off;
 941                 osh.sh_size = s->sz;
 942                 if (!gelf_update_shdr(s->os, &osh))
 943                         errx(EXIT_FAILURE, "elf_update_shdr failed: %s",
 944                             elf_errmsg(-1));
 945
 946                 /* Add padding for previous section, if need. */
 947                 if (ps != NULL) {
 948                         if (ps->pad_sz > 0) {
 949                                 /* Apply padding added by --pad-to. */
 950                                 pad_section(ecp, ps);
 951                         } else if ((ecp->flags & GAP_FILL) &&
 952                             (ps->off + ps->sz < s->off)) {
 953                                 /*
 954                                  * Fill the gap between sections by padding
 955                                  * the section with lower address.
 956                                  */
 957                                 ps->pad_sz = s->off - (ps->off + ps->sz);
 958                                 pad_section(ecp, ps);
 959                         }
 960                 }
 961
 962                 ps = s;
 963         }
 964
 965         /* Pad the last section, if need. */
 966         if (ps != NULL && ps->pad_sz > 0)
 967                 pad_section(ecp, ps);
 968 }
 969
 970 static void
 971 modify_section(struct elfcopy *ecp, struct section *s)
 972 {
 973         struct sec_action       *sac;
 974         size_t                   srcsz, dstsz, p, len;
 975         char                    *b, *c, *d, *src, *end;
 976         int                      dupe;
 977
 978         src = read_section(s, &srcsz);
 979         if (src == NULL || srcsz == 0) {
 980                 /* For empty section, we proceed if we need to append. */
 981                 if (!is_append_section(ecp, s->name))
 982                         return;
 983         }
 984
 985         /* Allocate buffer needed for new section data. */
 986         dstsz = srcsz;
 987         if (is_append_section(ecp, s->name)) {
 988                 sac = lookup_sec_act(ecp, s->name, 0);
 989                 dstsz += strlen(sac->string) + 1;
 990         }
 991         if ((b = malloc(dstsz)) == NULL)
 992                 err(EXIT_FAILURE, "malloc failed");
 993         s->buf = b;
 994
 995         /* Compress section. */
 996         p = 0;
 997         if (is_compress_section(ecp, s->name)) {
 998                 end = src + srcsz;
 999                 for(c = src; c < end;) {
1000                         len = 0;
1001                         while(c + len < end && c[len] != '\0')
1002                                 len++;
1003                         if (c + len == end) {
1004                                 /* XXX should we warn here? */
1005                                 strncpy(&b[p], c, len);
1006                                 p += len;
1007                                 break;
1008                         }
1009                         dupe = 0;
1010                         for (d = b; d < b + p; ) {
1011                                 if (strcmp(d, c) == 0) {
1012                                         dupe = 1;
1013                                         break;
1014                                 }
1015                                 d += strlen(d) + 1;
1016                         }
1017                         if (!dupe) {
1018                                 strncpy(&b[p], c, len);
1019                                 b[p + len] = '\0';
1020                                 p += len + 1;
1021                         }
1022                         c += len + 1;
1023                 }
1024         } else {
1025                 memcpy(b, src, srcsz);
1026                 p += srcsz;
1027         }
1028
1029         /* Append section. */
1030         if (is_append_section(ecp, s->name)) {
1031                 sac = lookup_sec_act(ecp, s->name, 0);
1032                 len = strlen(sac->string);
1033                 strncpy(&b[p], sac->string, len);
1034                 b[p + len] = '\0';
1035                 p += len + 1;
1036         }
1037
1038         s->sz = p;
1039         s->nocopy = 1;
1040 }
1041
1042 static void
1043 print_data(const char *d, size_t sz)
1044 {
1045         const char *c;
1046
1047         for (c = d; c < d + sz; c++) {
1048                 if (*c == '\0')
1049                         putchar('\n');
1050                 else
1051                         putchar(*c);
1052         }
1053 }
1054
1055 static void
1056 print_section(struct section *s)
1057 {
1058         Elf_Data        *id;
1059         int              elferr;
1060
1061         if (s->buf != NULL && s->sz > 0) {
1062                 print_data(s->buf, s->sz);
1063         } else {
1064                 id = NULL;
1065                 while ((id = elf_getdata(s->is, id)) != NULL ||
1066                     (id = elf_rawdata(s->is, id)) != NULL) {
1067                         (void) elf_errno();
1068                         print_data(id->d_buf, id->d_size);
1069                 }
1070                 elferr = elf_errno();
1071                 if (elferr != 0)
1072                         errx(EXIT_FAILURE, "elf_getdata() failed: %s",
1073                             elf_errmsg(elferr));
1074         }
1075         putchar('\n');
1076 }
1077
1078 static void *
1079 read_section(struct section *s, size_t *size)
1080 {
1081         Elf_Data        *id;
1082         char            *b;
1083         size_t           sz;
1084         int              elferr;
1085
1086         sz = 0;
1087         b = NULL;
1088         id = NULL;
1089         while ((id = elf_getdata(s->is, id)) != NULL ||
1090             (id = elf_rawdata(s->is, id)) != NULL) {
1091                 (void) elf_errno();
1092                 if (b == NULL)
1093                         b = malloc(id->d_size);
1094                 else
1095                         b = realloc(b, sz + id->d_size);
1096                 if (b == NULL)
1097                         err(EXIT_FAILURE, "malloc or realloc failed");
1098
1099                 memcpy(&b[sz], id->d_buf, id->d_size);
1100                 sz += id->d_size;
1101         }
1102         elferr = elf_errno();
1103         if (elferr != 0)
1104                 errx(EXIT_FAILURE, "elf_getdata() failed: %s",
1105                     elf_errmsg(elferr));
1106
1107         *size = sz;
1108
1109         return (b);
1110 }
1111
1112 void
1113 copy_shdr(struct elfcopy *ecp, struct section *s, const char *name, int copy,
1114     int sec_flags)
1115 {
1116         GElf_Shdr ish, osh;
1117
1118         if (gelf_getshdr(s->is, &ish) == NULL)
1119                 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1120                     elf_errmsg(-1));
1121         if (gelf_getshdr(s->os, &osh) == NULL)
1122                 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1123                     elf_errmsg(-1));
1124
1125         if (copy)
1126                 (void) memcpy(&osh, &ish, sizeof(ish));
1127         else {
1128                 osh.sh_type             = s->type;
1129                 osh.sh_addr             = s->vma;
1130                 osh.sh_offset           = s->off;
1131                 osh.sh_size             = s->sz;
1132                 osh.sh_link             = ish.sh_link;
1133                 osh.sh_info             = ish.sh_info;
1134                 osh.sh_addralign        = s->align;
1135                 osh.sh_entsize          = ish.sh_entsize;
1136
1137                 if (sec_flags) {
1138                         osh.sh_flags = 0;
1139                         if (sec_flags & SF_ALLOC)
1140                                 osh.sh_flags |= SHF_ALLOC;
1141                         if ((sec_flags & SF_READONLY) == 0)
1142                                 osh.sh_flags |= SHF_WRITE;
1143                         if (sec_flags & SF_CODE)
1144                                 osh.sh_flags |= SHF_EXECINSTR;
1145                         if ((sec_flags & SF_CONTENTS) &&
1146                             s->type == SHT_NOBITS && s->sz > 0) {
1147                                 /*
1148                                  * Convert SHT_NOBITS section to section with
1149                                  * (zero'ed) content on file.
1150                                  */
1151                                 osh.sh_type = s->type = SHT_PROGBITS;
1152                                 if ((s->buf = calloc(1, s->sz)) == NULL)
1153                                         err(EXIT_FAILURE, "malloc failed");
1154                                 s->nocopy = 1;
1155                         }
1156                 } else {
1157                         osh.sh_flags = ish.sh_flags;
1158                         /*
1159                          * Newer binutils as(1) emits the section flag
1160                          * SHF_INFO_LINK for relocation sections. elfcopy
1161                          * emits this flag in the output section if it's
1162                          * missing in the input section, to remain compatible
1163                          * with binutils.
1164                          */
1165                         if (ish.sh_type == SHT_REL || ish.sh_type == SHT_RELA)
1166                                 osh.sh_flags |= SHF_INFO_LINK;
1167                 }
1168         }
1169
1170         if (name == NULL)
1171                 add_to_shstrtab(ecp, s->name);
1172         else
1173                 add_to_shstrtab(ecp, name);
1174
1175         if (!gelf_update_shdr(s->os, &osh))
1176                 errx(EXIT_FAILURE, "elf_update_shdr failed: %s",
1177                     elf_errmsg(-1));
1178 }
1179
1180 void
1181 copy_data(struct section *s)
1182 {
1183         Elf_Data        *id, *od;
1184         int              elferr;
1185
1186         if (s->nocopy && s->buf == NULL)
1187                 return;
1188
1189         if ((id = elf_getdata(s->is, NULL)) == NULL) {
1190                 (void) elf_errno();
1191                 if ((id = elf_rawdata(s->is, NULL)) == NULL) {
1192                         elferr = elf_errno();
1193                         if (elferr != 0)
1194                                 errx(EXIT_FAILURE, "failed to read section:"
1195                                     " %s", s->name);
1196                         return;
1197                 }
1198         }
1199
1200         if ((od = elf_newdata(s->os)) == NULL)
1201                 errx(EXIT_FAILURE, "elf_newdata() failed: %s",
1202                     elf_errmsg(-1));
1203
1204         if (s->nocopy) {
1205                 /* Use s->buf as content if s->nocopy is set. */
1206                 od->d_align     = id->d_align;
1207                 od->d_off       = 0;
1208                 od->d_buf       = s->buf;
1209                 od->d_type      = id->d_type;
1210                 od->d_size      = s->sz;
1211                 od->d_version   = id->d_version;
1212         } else {
1213                 od->d_align     = id->d_align;
1214                 od->d_off       = id->d_off;
1215                 od->d_buf       = id->d_buf;
1216                 od->d_type      = id->d_type;
1217                 od->d_size      = id->d_size;
1218                 od->d_version   = id->d_version;
1219         }
1220
1221         /*
1222          * Alignment Fixup. libelf does not allow the alignment for
1223          * Elf_Data descriptor to be set to 0. In this case we workaround
1224          * it by setting the alignment to 1.
1225          *
1226          * According to the ELF ABI, alignment 0 and 1 has the same
1227          * meaning: the section has no alignment constraints.
1228          */
1229         if (od->d_align == 0)
1230                 od->d_align = 1;
1231 }
1232
1233 struct section *
1234 create_external_section(struct elfcopy *ecp, const char *name, char *newname,
1235     void *buf, uint64_t size, uint64_t off, uint64_t stype, Elf_Type dtype,
1236     uint64_t flags, uint64_t align, uint64_t vma, int loadable)
1237 {
1238         struct section  *s;
1239         Elf_Scn         *os;
1240         Elf_Data        *od;
1241         GElf_Shdr        osh;
1242
1243         if ((os = elf_newscn(ecp->eout)) == NULL)
1244                 errx(EXIT_FAILURE, "elf_newscn() failed: %s",
1245                     elf_errmsg(-1));
1246         if ((s = calloc(1, sizeof(*s))) == NULL)
1247                 err(EXIT_FAILURE, "calloc failed");
1248         s->name = name;
1249         s->newname = newname;   /* needs to be free()'ed */
1250         s->off = off;
1251         s->sz = size;
1252         s->vma = vma;
1253         s->align = align;
1254         s->loadable = loadable;
1255         s->is = NULL;
1256         s->os = os;
1257         s->type = stype;
1258         s->nocopy = 1;
1259         insert_to_sec_list(ecp, s, 1);
1260
1261         if (gelf_getshdr(os, &osh) == NULL)
1262                 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1263                     elf_errmsg(-1));
1264         osh.sh_flags = flags;
1265         osh.sh_type = s->type;
1266         osh.sh_addr = s->vma;
1267         osh.sh_addralign = s->align;
1268         if (!gelf_update_shdr(os, &osh))
1269                 errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s",
1270                     elf_errmsg(-1));
1271         add_to_shstrtab(ecp, name);
1272
1273         if (buf != NULL && size != 0) {
1274                 if ((od = elf_newdata(os)) == NULL)
1275                         errx(EXIT_FAILURE, "elf_newdata() failed: %s",
1276                             elf_errmsg(-1));
1277                 od->d_align = align;
1278                 od->d_off = 0;
1279                 od->d_buf = buf;
1280                 od->d_size = size;
1281                 od->d_type = dtype;
1282                 od->d_version = EV_CURRENT;
1283         }
1284
1285         /*
1286          * Clear SYMTAB_INTACT, as we probably need to update/add new
1287          * STT_SECTION symbols into the symbol table.
1288          */
1289         ecp->flags &= ~SYMTAB_INTACT;
1290
1291         return (s);
1292 }
1293
1294 /*
1295  * Insert sections specified by --add-section to the end of section list.
1296  */
1297 static void
1298 insert_sections(struct elfcopy *ecp)
1299 {
1300         struct sec_add  *sa;
1301         struct section  *s;
1302         size_t           off;
1303         uint64_t         stype;
1304
1305         /* Put these sections in the end of current list. */
1306         off = 0;
1307         TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
1308                 if (s->type != SHT_NOBITS && s->type != SHT_NULL)
1309                         off = s->off + s->sz;
1310                 else
1311                         off = s->off;
1312         }
1313
1314         STAILQ_FOREACH(sa, &ecp->v_sadd, sadd_list) {
1315
1316                 /* TODO: Add section header vma/lma, flag changes here */
1317
1318                 /*
1319                  * The default section type for user added section is
1320                  * SHT_PROGBITS. If the section name match certain patterns,
1321                  * elfcopy will try to set a more appropriate section type.
1322                  * However, data type is always set to ELF_T_BYTE and no
1323                  * translation is performed by libelf.
1324                  */
1325                 stype = SHT_PROGBITS;
1326                 if (strcmp(sa->name, ".note") == 0 ||
1327                     strncmp(sa->name, ".note.", strlen(".note.")) == 0)
1328                         stype = SHT_NOTE;
1329
1330                 (void) create_external_section(ecp, sa->name, NULL, sa->content,
1331                     sa->size, off, stype, ELF_T_BYTE, 0, 1, 0, 0);
1332         }
1333 }
1334
1335 void
1336 add_to_shstrtab(struct elfcopy *ecp, const char *name)
1337 {
1338
1339         if (elftc_string_table_insert(ecp->shstrtab->strtab, name) == 0)
1340                 errx(EXIT_FAILURE, "elftc_string_table_insert failed");
1341 }
1342
1343 void
1344 update_shdr(struct elfcopy *ecp, int update_link)
1345 {
1346         struct section  *s;
1347         GElf_Shdr        osh;
1348         int              elferr;
1349
1350         /* Finalize the section name string table (.shstrtab). */
1351         set_shstrtab(ecp);
1352
1353         TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
1354                 if (s->pseudo)
1355                         continue;
1356
1357                 if (gelf_getshdr(s->os, &osh) == NULL)
1358                         errx(EXIT_FAILURE, "gelf_getshdr failed: %s",
1359                             elf_errmsg(-1));
1360
1361                 /* Find section name in string table and set sh_name. */
1362                 osh.sh_name = elftc_string_table_lookup(ecp->shstrtab->strtab,
1363                     s->name);
1364
1365                 /*
1366                  * sh_link needs to be updated, since the index of the
1367                  * linked section might have changed.
1368                  */
1369                 if (update_link && osh.sh_link != 0)
1370                         osh.sh_link = ecp->secndx[osh.sh_link];
1371
1372                 /*
1373                  * sh_info of relocation section links to the section to which
1374                  * its relocation info applies. So it may need update as well.
1375                  */
1376                 if ((s->type == SHT_REL || s->type == SHT_RELA) &&
1377                     osh.sh_info != 0)
1378                         osh.sh_info = ecp->secndx[osh.sh_info];
1379
1380                 /*
1381                  * sh_info of SHT_GROUP section needs to point to the correct
1382                  * string in the symbol table.
1383                  */
1384                 if (s->type == SHT_GROUP && (ecp->flags & SYMTAB_EXIST) &&
1385                     (ecp->flags & SYMTAB_INTACT) == 0)
1386                         osh.sh_info = ecp->symndx[osh.sh_info];
1387
1388                 if (!gelf_update_shdr(s->os, &osh))
1389                         errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s",
1390                             elf_errmsg(-1));
1391         }
1392         elferr = elf_errno();
1393         if (elferr != 0)
1394                 errx(EXIT_FAILURE, "elf_nextscn failed: %s",
1395                     elf_errmsg(elferr));
1396 }
1397
1398 void
1399 init_shstrtab(struct elfcopy *ecp)
1400 {
1401         Elf_Scn *shstrtab;
1402         GElf_Shdr shdr;
1403         struct section *s;
1404         size_t indx, sizehint;
1405
1406         if (elf_getshdrstrndx(ecp->ein, &indx) == 0) {
1407                 shstrtab = elf_getscn(ecp->ein, indx);
1408                 if (shstrtab == NULL)
1409                         errx(EXIT_FAILURE, "elf_getscn failed: %s",
1410                             elf_errmsg(-1));
1411                 if (gelf_getshdr(shstrtab, &shdr) != &shdr)
1412                         errx(EXIT_FAILURE, "gelf_getshdr failed: %s",
1413                             elf_errmsg(-1));
1414                 sizehint = shdr.sh_size;
1415         } else {
1416                 /* Clear the error from elf_getshdrstrndx(3). */
1417                 (void)elf_errno();
1418                 sizehint = 0;
1419         }
1420
1421         if ((ecp->shstrtab = calloc(1, sizeof(*ecp->shstrtab))) == NULL)
1422                 err(EXIT_FAILURE, "calloc failed");
1423         s = ecp->shstrtab;
1424         s->name = ".shstrtab";
1425         s->is = NULL;
1426         s->sz = 0;
1427         s->align = 1;
1428         s->loadable = 0;
1429         s->type = SHT_STRTAB;
1430         s->vma = 0;
1431         s->strtab = elftc_string_table_create(sizehint);
1432
1433         add_to_shstrtab(ecp, "");
1434         add_to_shstrtab(ecp, ".symtab");
1435         add_to_shstrtab(ecp, ".strtab");
1436         add_to_shstrtab(ecp, ".shstrtab");
1437 }
1438
1439 static void
1440 set_shstrtab(struct elfcopy *ecp)
1441 {
1442         struct section  *s;
1443         Elf_Data        *data;
1444         GElf_Shdr        sh;
1445         const char      *image;
1446         size_t           sz;
1447
1448         s = ecp->shstrtab;
1449
1450         if (s->os == NULL) {
1451                 /* Input object does not contain .shstrtab section */
1452                 if ((s->os = elf_newscn(ecp->eout)) == NULL)
1453                         errx(EXIT_FAILURE, "elf_newscn failed: %s",
1454                             elf_errmsg(-1));
1455                 insert_to_sec_list(ecp, s, 1);
1456         }
1457
1458         if (gelf_getshdr(s->os, &sh) == NULL)
1459                 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1460                     elf_errmsg(-1));
1461         sh.sh_addr      = 0;
1462         sh.sh_addralign = 1;
1463         sh.sh_offset    = s->off;
1464         sh.sh_type      = SHT_STRTAB;
1465         sh.sh_flags     = 0;
1466         sh.sh_entsize   = 0;
1467         sh.sh_info      = 0;
1468         sh.sh_link      = 0;
1469
1470         if ((data = elf_newdata(s->os)) == NULL)
1471                 errx(EXIT_FAILURE, "elf_newdata() failed: %s",
1472                     elf_errmsg(-1));
1473
1474         /*
1475          * If we don't have a symbol table, skip those a few bytes
1476          * which are reserved for this in the beginning of shstrtab.
1477          */
1478         if (!(ecp->flags & SYMTAB_EXIST)) {
1479                 elftc_string_table_remove(s->strtab, ".symtab");
1480                 elftc_string_table_remove(s->strtab, ".strtab");
1481         }
1482
1483         image = elftc_string_table_image(s->strtab, &sz);
1484         s->sz = sz;
1485
1486         sh.sh_size      = sz;
1487         if (!gelf_update_shdr(s->os, &sh))
1488                 errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s",
1489                     elf_errmsg(-1));
1490
1491         data->d_align   = 1;
1492         data->d_buf     = (void *)(uintptr_t)image;
1493         data->d_size    = sz;
1494         data->d_off     = 0;
1495         data->d_type    = ELF_T_BYTE;
1496         data->d_version = EV_CURRENT;
1497
1498         if (!elf_setshstrndx(ecp->eout, elf_ndxscn(s->os)))
1499                 errx(EXIT_FAILURE, "elf_setshstrndx() failed: %s",
1500                      elf_errmsg(-1));
1501 }
1502
1503 void
1504 add_section(struct elfcopy *ecp, const char *arg)
1505 {
1506         struct sec_add  *sa;
1507         struct stat      sb;
1508         const char      *s, *fn;
1509         FILE            *fp;
1510         int              len;
1511
1512         if ((s = strchr(arg, '=')) == NULL)
1513                 errx(EXIT_FAILURE,
1514                     "illegal format for --add-section option");
1515         if ((sa = malloc(sizeof(*sa))) == NULL)
1516                 err(EXIT_FAILURE, "malloc failed");
1517
1518         len = s - arg;
1519         if ((sa->name = malloc(len + 1)) == NULL)
1520                 err(EXIT_FAILURE, "malloc failed");
1521         strncpy(sa->name, arg, len);
1522         sa->name[len] = '\0';
1523
1524         fn = s + 1;
1525         if (stat(fn, &sb) == -1)
1526                 err(EXIT_FAILURE, "stat failed");
1527         sa->size = sb.st_size;
1528         if (sa->size > 0) {
1529                 if ((sa->content = malloc(sa->size)) == NULL)
1530                         err(EXIT_FAILURE, "malloc failed");
1531                 if ((fp = fopen(fn, "r")) == NULL)
1532                         err(EXIT_FAILURE, "can not open %s", fn);
1533                 if (fread(sa->content, 1, sa->size, fp) == 0 ||
1534                     ferror(fp))
1535                         err(EXIT_FAILURE, "fread failed");
1536                 fclose(fp);
1537         } else
1538                 sa->content = NULL;
1539
1540         STAILQ_INSERT_TAIL(&ecp->v_sadd, sa, sadd_list);
1541         ecp->flags |= SEC_ADD;
1542 }
1543
1544 void
1545 free_sec_add(struct elfcopy *ecp)
1546 {
1547         struct sec_add *sa, *sa_temp;
1548
1549         STAILQ_FOREACH_SAFE(sa, &ecp->v_sadd, sadd_list, sa_temp) {
1550                 STAILQ_REMOVE(&ecp->v_sadd, sa, sec_add, sadd_list);
1551                 free(sa->name);
1552                 free(sa->content);
1553                 free(sa);
1554         }
1555 }
1556
1557 static void
1558 add_gnu_debuglink(struct elfcopy *ecp)
1559 {
1560         struct sec_add  *sa;
1561         struct stat      sb;
1562         FILE            *fp;
1563         char            *fnbase, *buf;
1564         int              crc_off;
1565         int              crc;
1566
1567         if (ecp->debuglink == NULL)
1568                 return;
1569
1570         /* Read debug file content. */
1571         if ((sa = malloc(sizeof(*sa))) == NULL)
1572                 err(EXIT_FAILURE, "malloc failed");
1573         if ((sa->name = strdup(".gnu_debuglink")) == NULL)
1574                 err(EXIT_FAILURE, "strdup failed");
1575         if (stat(ecp->debuglink, &sb) == -1)
1576                 err(EXIT_FAILURE, "stat failed");
1577         if (sb.st_size == 0)
1578                 errx(EXIT_FAILURE, "empty debug link target %s",
1579                     ecp->debuglink);
1580         if ((buf = malloc(sb.st_size)) == NULL)
1581                 err(EXIT_FAILURE, "malloc failed");
1582         if ((fp = fopen(ecp->debuglink, "r")) == NULL)
1583                 err(EXIT_FAILURE, "can not open %s", ecp->debuglink);
1584         if (fread(buf, 1, sb.st_size, fp) == 0 ||
1585             ferror(fp))
1586                 err(EXIT_FAILURE, "fread failed");
1587         fclose(fp);
1588
1589         /* Calculate crc checksum.  */
1590         crc = calc_crc32(buf, sb.st_size, 0xFFFFFFFF);
1591         free(buf);
1592
1593         /* Calculate section size and the offset to store crc checksum. */
1594         if ((fnbase = basename(ecp->debuglink)) == NULL)
1595                 err(EXIT_FAILURE, "basename failed");
1596         crc_off = roundup(strlen(fnbase) + 1, 4);
1597         sa->size = crc_off + 4;
1598
1599         /* Section content. */
1600         if ((sa->content = calloc(1, sa->size)) == NULL)
1601                 err(EXIT_FAILURE, "malloc failed");
1602         strncpy(sa->content, fnbase, strlen(fnbase));
1603         if (ecp->oed == ELFDATA2LSB) {
1604                 sa->content[crc_off] = crc & 0xFF;
1605                 sa->content[crc_off + 1] = (crc >> 8) & 0xFF;
1606                 sa->content[crc_off + 2] = (crc >> 16) & 0xFF;
1607                 sa->content[crc_off + 3] = crc >> 24;
1608         } else {
1609                 sa->content[crc_off] = crc >> 24;
1610                 sa->content[crc_off + 1] = (crc >> 16) & 0xFF;
1611                 sa->content[crc_off + 2] = (crc >> 8) & 0xFF;
1612                 sa->content[crc_off + 3] = crc & 0xFF;
1613         }
1614
1615         STAILQ_INSERT_TAIL(&ecp->v_sadd, sa, sadd_list);
1616         ecp->flags |= SEC_ADD;
1617 }
1618
1619 static uint32_t crctable[256] =
1620 {
1621         0x00000000L, 0x77073096L, 0xEE0E612CL, 0x990951BAL,
1622         0x076DC419L, 0x706AF48FL, 0xE963A535L, 0x9E6495A3L,
1623         0x0EDB8832L, 0x79DCB8A4L, 0xE0D5E91EL, 0x97D2D988L,
1624         0x09B64C2BL, 0x7EB17CBDL, 0xE7B82D07L, 0x90BF1D91L,
1625         0x1DB71064L, 0x6AB020F2L, 0xF3B97148L, 0x84BE41DEL,
1626         0x1ADAD47DL, 0x6DDDE4EBL, 0xF4D4B551L, 0x83D385C7L,
1627         0x136C9856L, 0x646BA8C0L, 0xFD62F97AL, 0x8A65C9ECL,
1628         0x14015C4FL, 0x63066CD9L, 0xFA0F3D63L, 0x8D080DF5L,
1629         0x3B6E20C8L, 0x4C69105EL, 0xD56041E4L, 0xA2677172L,
1630         0x3C03E4D1L, 0x4B04D447L, 0xD20D85FDL, 0xA50AB56BL,
1631         0x35B5A8FAL, 0x42B2986CL, 0xDBBBC9D6L, 0xACBCF940L,
1632         0x32D86CE3L, 0x45DF5C75L, 0xDCD60DCFL, 0xABD13D59L,
1633         0x26D930ACL, 0x51DE003AL, 0xC8D75180L, 0xBFD06116L,
1634         0x21B4F4B5L, 0x56B3C423L, 0xCFBA9599L, 0xB8BDA50FL,
1635         0x2802B89EL, 0x5F058808L, 0xC60CD9B2L, 0xB10BE924L,
1636         0x2F6F7C87L, 0x58684C11L, 0xC1611DABL, 0xB6662D3DL,
1637         0x76DC4190L, 0x01DB7106L, 0x98D220BCL, 0xEFD5102AL,
1638         0x71B18589L, 0x06B6B51FL, 0x9FBFE4A5L, 0xE8B8D433L,
1639         0x7807C9A2L, 0x0F00F934L, 0x9609A88EL, 0xE10E9818L,
1640         0x7F6A0DBBL, 0x086D3D2DL, 0x91646C97L, 0xE6635C01L,
1641         0x6B6B51F4L, 0x1C6C6162L, 0x856530D8L, 0xF262004EL,
1642         0x6C0695EDL, 0x1B01A57BL, 0x8208F4C1L, 0xF50FC457L,
1643         0x65B0D9C6L, 0x12B7E950L, 0x8BBEB8EAL, 0xFCB9887CL,
1644         0x62DD1DDFL, 0x15DA2D49L, 0x8CD37CF3L, 0xFBD44C65L,
1645         0x4DB26158L, 0x3AB551CEL, 0xA3BC0074L, 0xD4BB30E2L,
1646         0x4ADFA541L, 0x3DD895D7L, 0xA4D1C46DL, 0xD3D6F4FBL,
1647         0x4369E96AL, 0x346ED9FCL, 0xAD678846L, 0xDA60B8D0L,
1648         0x44042D73L, 0x33031DE5L, 0xAA0A4C5FL, 0xDD0D7CC9L,
1649         0x5005713CL, 0x270241AAL, 0xBE0B1010L, 0xC90C2086L,
1650         0x5768B525L, 0x206F85B3L, 0xB966D409L, 0xCE61E49FL,
1651         0x5EDEF90EL, 0x29D9C998L, 0xB0D09822L, 0xC7D7A8B4L,
1652         0x59B33D17L, 0x2EB40D81L, 0xB7BD5C3BL, 0xC0BA6CADL,
1653         0xEDB88320L, 0x9ABFB3B6L, 0x03B6E20CL, 0x74B1D29AL,
1654         0xEAD54739L, 0x9DD277AFL, 0x04DB2615L, 0x73DC1683L,
1655         0xE3630B12L, 0x94643B84L, 0x0D6D6A3EL, 0x7A6A5AA8L,
1656         0xE40ECF0BL, 0x9309FF9DL, 0x0A00AE27L, 0x7D079EB1L,
1657         0xF00F9344L, 0x8708A3D2L, 0x1E01F268L, 0x6906C2FEL,
1658         0xF762575DL, 0x806567CBL, 0x196C3671L, 0x6E6B06E7L,
1659         0xFED41B76L, 0x89D32BE0L, 0x10DA7A5AL, 0x67DD4ACCL,
1660         0xF9B9DF6FL, 0x8EBEEFF9L, 0x17B7BE43L, 0x60B08ED5L,
1661         0xD6D6A3E8L, 0xA1D1937EL, 0x38D8C2C4L, 0x4FDFF252L,
1662         0xD1BB67F1L, 0xA6BC5767L, 0x3FB506DDL, 0x48B2364BL,
1663         0xD80D2BDAL, 0xAF0A1B4CL, 0x36034AF6L, 0x41047A60L,
1664         0xDF60EFC3L, 0xA867DF55L, 0x316E8EEFL, 0x4669BE79L,
1665         0xCB61B38CL, 0xBC66831AL, 0x256FD2A0L, 0x5268E236L,
1666         0xCC0C7795L, 0xBB0B4703L, 0x220216B9L, 0x5505262FL,
1667         0xC5BA3BBEL, 0xB2BD0B28L, 0x2BB45A92L, 0x5CB36A04L,
1668         0xC2D7FFA7L, 0xB5D0CF31L, 0x2CD99E8BL, 0x5BDEAE1DL,
1669         0x9B64C2B0L, 0xEC63F226L, 0x756AA39CL, 0x026D930AL,
1670         0x9C0906A9L, 0xEB0E363FL, 0x72076785L, 0x05005713L,
1671         0x95BF4A82L, 0xE2B87A14L, 0x7BB12BAEL, 0x0CB61B38L,
1672         0x92D28E9BL, 0xE5D5BE0DL, 0x7CDCEFB7L, 0x0BDBDF21L,
1673         0x86D3D2D4L, 0xF1D4E242L, 0x68DDB3F8L, 0x1FDA836EL,
1674         0x81BE16CDL, 0xF6B9265BL, 0x6FB077E1L, 0x18B74777L,
1675         0x88085AE6L, 0xFF0F6A70L, 0x66063BCAL, 0x11010B5CL,
1676         0x8F659EFFL, 0xF862AE69L, 0x616BFFD3L, 0x166CCF45L,
1677         0xA00AE278L, 0xD70DD2EEL, 0x4E048354L, 0x3903B3C2L,
1678         0xA7672661L, 0xD06016F7L, 0x4969474DL, 0x3E6E77DBL,
1679         0xAED16A4AL, 0xD9D65ADCL, 0x40DF0B66L, 0x37D83BF0L,
1680         0xA9BCAE53L, 0xDEBB9EC5L, 0x47B2CF7FL, 0x30B5FFE9L,
1681         0xBDBDF21CL, 0xCABAC28AL, 0x53B39330L, 0x24B4A3A6L,
1682         0xBAD03605L, 0xCDD70693L, 0x54DE5729L, 0x23D967BFL,
1683         0xB3667A2EL, 0xC4614AB8L, 0x5D681B02L, 0x2A6F2B94L,
1684         0xB40BBE37L, 0xC30C8EA1L, 0x5A05DF1BL, 0x2D02EF8DL
1685 };
1686
1687 static uint32_t
1688 calc_crc32(const char *p, size_t len, uint32_t crc)
1689 {
1690         uint32_t i;
1691
1692         for (i = 0; i < len; i++) {
1693                 crc = crctable[(crc ^ *p++) & 0xFFL] ^ (crc >> 8);
1694         }
1695
1696         return (crc ^ 0xFFFFFFFF);
1697 }