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 3758 2019-06-28 01:16:50Z 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 static int
 883 section_type_alignment(int sht, int class)
 884 {
 885         switch (sht)
 886         {
 887         case SHT_DYNAMIC:
 888         case SHT_DYNSYM:
 889         case SHT_FINI_ARRAY:
 890         case SHT_GNU_HASH:
 891         case SHT_INIT_ARRAY:
 892         case SHT_PREINIT_ARRAY:
 893         case SHT_REL:
 894         case SHT_RELA:
 895         case SHT_SYMTAB:
 896                 return (class == ELFCLASS64 ? 8 : 4);
 897         case SHT_SUNW_move:
 898                 return (8);
 899         case SHT_GNU_LIBLIST:
 900         case SHT_GROUP:
 901         case SHT_HASH:
 902         case SHT_NOTE:
 903         case SHT_SUNW_verdef:   /* == SHT_GNU_verdef */
 904         case SHT_SUNW_verneed:  /* == SHT_GNU_verneed */
 905         case SHT_SYMTAB_SHNDX:
 906                 return (4);
 907         case SHT_SUNW_syminfo:
 908         case SHT_SUNW_versym:   /* == SHT_GNU_versym */
 909                 return (2);
 910         case SHT_NOBITS:
 911         case SHT_PROGBITS:
 912         case SHT_STRTAB:
 913         case SHT_SUNW_dof:
 914                 return (1);
 915         }
 916         return (1);
 917 }
 918
 919 void
 920 resync_sections(struct elfcopy *ecp)
 921 {
 922         struct section  *s, *ps;
 923         GElf_Shdr        osh;
 924         uint64_t         off;
 925         int              first;
 926         int              min_alignment;
 927
 928         ps = NULL;
 929         first = 1;
 930         off = 0;
 931         TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
 932                 if (first) {
 933                         off = s->off;
 934                         first = 0;
 935                 }
 936
 937                 /*
 938                  * Ignore TLS sections with load address 0 and without
 939                  * content. We don't need to adjust their file offset or
 940                  * VMA, only the size matters.
 941                  */
 942                 if (s->seg_tls != NULL && s->type == SHT_NOBITS &&
 943                     s->off == 0)
 944                         continue;
 945
 946                 /* Align section offset. */
 947                 if (s->align == 0)
 948                         s->align = 1;
 949                 min_alignment = section_type_alignment(s->type, ecp->oec);
 950                 if (s->align < INT_MAX && (int)s->align < min_alignment) {
 951                         warnx("section %s alignment %d increased to %d",
 952                             s->name, (int)s->align, min_alignment);
 953                         s->align = min_alignment;
 954                 }
 955                 if (off <= s->off) {
 956                         if (!s->loadable || (ecp->flags & RELOCATABLE))
 957                                 s->off = roundup(off, s->align);
 958                 } else {
 959                         if (s->loadable && (ecp->flags & RELOCATABLE) == 0)
 960                                 warnx("moving loadable section %s, "
 961                                     "is this intentional?", s->name);
 962                         s->off = roundup(off, s->align);
 963                 }
 964
 965                 /* Calculate next section offset. */
 966                 off = s->off;
 967                 if (s->pseudo || (s->type != SHT_NOBITS && s->type != SHT_NULL))
 968                         off += s->sz;
 969
 970                 if (s->pseudo) {
 971                         ps = NULL;
 972                         continue;
 973                 }
 974
 975                 /* Count padding bytes added through --pad-to. */
 976                 if (s->pad_sz > 0)
 977                         off += s->pad_sz;
 978
 979                 /* Update section header accordingly. */
 980                 if (gelf_getshdr(s->os, &osh) == NULL)
 981                         errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
 982                             elf_errmsg(-1));
 983                 osh.sh_addr = s->vma;
 984                 osh.sh_addralign = s->align;
 985                 osh.sh_offset = s->off;
 986                 osh.sh_size = s->sz;
 987                 if (!gelf_update_shdr(s->os, &osh))
 988                         errx(EXIT_FAILURE, "elf_update_shdr failed: %s",
 989                             elf_errmsg(-1));
 990
 991                 /* Add padding for previous section, if need. */
 992                 if (ps != NULL) {
 993                         if (ps->pad_sz > 0) {
 994                                 /* Apply padding added by --pad-to. */
 995                                 pad_section(ecp, ps);
 996                         } else if ((ecp->flags & GAP_FILL) &&
 997                             (ps->off + ps->sz < s->off)) {
 998                                 /*
 999                                  * Fill the gap between sections by padding
1000                                  * the section with lower address.
1001                                  */
1002                                 ps->pad_sz = s->off - (ps->off + ps->sz);
1003                                 pad_section(ecp, ps);
1004                         }
1005                 }
1006
1007                 ps = s;
1008         }
1009
1010         /* Pad the last section, if need. */
1011         if (ps != NULL && ps->pad_sz > 0)
1012                 pad_section(ecp, ps);
1013 }
1014
1015 static void
1016 modify_section(struct elfcopy *ecp, struct section *s)
1017 {
1018         struct sec_action       *sac;
1019         size_t                   srcsz, dstsz, p, len;
1020         char                    *b, *c, *d, *src, *end;
1021         int                      dupe;
1022
1023         src = read_section(s, &srcsz);
1024         if (src == NULL || srcsz == 0) {
1025                 /* For empty section, we proceed if we need to append. */
1026                 if (!is_append_section(ecp, s->name))
1027                         return;
1028         }
1029
1030         /* Allocate buffer needed for new section data. */
1031         dstsz = srcsz;
1032         if (is_append_section(ecp, s->name)) {
1033                 sac = lookup_sec_act(ecp, s->name, 0);
1034                 dstsz += strlen(sac->string) + 1;
1035         }
1036         if ((b = malloc(dstsz)) == NULL)
1037                 err(EXIT_FAILURE, "malloc failed");
1038         s->buf = b;
1039
1040         /* Compress section. */
1041         p = 0;
1042         if (is_compress_section(ecp, s->name)) {
1043                 end = src + srcsz;
1044                 for(c = src; c < end;) {
1045                         len = 0;
1046                         while(c + len < end && c[len] != '\0')
1047                                 len++;
1048                         if (c + len == end) {
1049                                 /* XXX should we warn here? */
1050                                 strncpy(&b[p], c, len);
1051                                 p += len;
1052                                 break;
1053                         }
1054                         dupe = 0;
1055                         for (d = b; d < b + p; ) {
1056                                 if (strcmp(d, c) == 0) {
1057                                         dupe = 1;
1058                                         break;
1059                                 }
1060                                 d += strlen(d) + 1;
1061                         }
1062                         if (!dupe) {
1063                                 strncpy(&b[p], c, len);
1064                                 b[p + len] = '\0';
1065                                 p += len + 1;
1066                         }
1067                         c += len + 1;
1068                 }
1069         } else {
1070                 memcpy(b, src, srcsz);
1071                 p += srcsz;
1072         }
1073
1074         /* Append section. */
1075         if (is_append_section(ecp, s->name)) {
1076                 sac = lookup_sec_act(ecp, s->name, 0);
1077                 len = strlen(sac->string);
1078                 strncpy(&b[p], sac->string, len);
1079                 b[p + len] = '\0';
1080                 p += len + 1;
1081         }
1082
1083         s->sz = p;
1084         s->nocopy = 1;
1085 }
1086
1087 static void
1088 print_data(const char *d, size_t sz)
1089 {
1090         const char *c;
1091
1092         for (c = d; c < d + sz; c++) {
1093                 if (*c == '\0')
1094                         putchar('\n');
1095                 else
1096                         putchar(*c);
1097         }
1098 }
1099
1100 static void
1101 print_section(struct section *s)
1102 {
1103         Elf_Data        *id;
1104         int              elferr;
1105
1106         if (s->buf != NULL && s->sz > 0) {
1107                 print_data(s->buf, s->sz);
1108         } else {
1109                 id = NULL;
1110                 while ((id = elf_getdata(s->is, id)) != NULL ||
1111                     (id = elf_rawdata(s->is, id)) != NULL) {
1112                         (void) elf_errno();
1113                         print_data(id->d_buf, id->d_size);
1114                 }
1115                 elferr = elf_errno();
1116                 if (elferr != 0)
1117                         errx(EXIT_FAILURE, "elf_getdata() failed: %s",
1118                             elf_errmsg(elferr));
1119         }
1120         putchar('\n');
1121 }
1122
1123 static void *
1124 read_section(struct section *s, size_t *size)
1125 {
1126         Elf_Data        *id;
1127         char            *b;
1128         size_t           sz;
1129         int              elferr;
1130
1131         sz = 0;
1132         b = NULL;
1133         id = NULL;
1134         while ((id = elf_getdata(s->is, id)) != NULL ||
1135             (id = elf_rawdata(s->is, id)) != NULL) {
1136                 (void) elf_errno();
1137                 if (b == NULL)
1138                         b = malloc(id->d_size);
1139                 else
1140                         b = malloc(sz + id->d_size);
1141                 if (b == NULL)
1142                         err(EXIT_FAILURE, "malloc or realloc failed");
1143
1144                 memcpy(&b[sz], id->d_buf, id->d_size);
1145                 sz += id->d_size;
1146         }
1147         elferr = elf_errno();
1148         if (elferr != 0)
1149                 errx(EXIT_FAILURE, "elf_getdata() failed: %s",
1150                     elf_errmsg(elferr));
1151
1152         *size = sz;
1153
1154         return (b);
1155 }
1156
1157 void
1158 copy_shdr(struct elfcopy *ecp, struct section *s, const char *name, int copy,
1159     int sec_flags)
1160 {
1161         GElf_Shdr ish, osh;
1162
1163         if (gelf_getshdr(s->is, &ish) == NULL)
1164                 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1165                     elf_errmsg(-1));
1166         if (gelf_getshdr(s->os, &osh) == NULL)
1167                 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1168                     elf_errmsg(-1));
1169
1170         if (copy)
1171                 (void) memcpy(&osh, &ish, sizeof(ish));
1172         else {
1173                 osh.sh_type             = s->type;
1174                 osh.sh_addr             = s->vma;
1175                 osh.sh_offset           = s->off;
1176                 osh.sh_size             = s->sz;
1177                 osh.sh_link             = ish.sh_link;
1178                 osh.sh_info             = ish.sh_info;
1179                 osh.sh_addralign        = s->align;
1180                 osh.sh_entsize          = ish.sh_entsize;
1181
1182                 if (sec_flags) {
1183                         osh.sh_flags = 0;
1184                         if (sec_flags & SF_ALLOC)
1185                                 osh.sh_flags |= SHF_ALLOC;
1186                         if ((sec_flags & SF_READONLY) == 0)
1187                                 osh.sh_flags |= SHF_WRITE;
1188                         if (sec_flags & SF_CODE)
1189                                 osh.sh_flags |= SHF_EXECINSTR;
1190                         if ((sec_flags & SF_CONTENTS) &&
1191                             s->type == SHT_NOBITS && s->sz > 0) {
1192                                 /*
1193                                  * Convert SHT_NOBITS section to section with
1194                                  * (zero'ed) content on file.
1195                                  */
1196                                 osh.sh_type = s->type = SHT_PROGBITS;
1197                                 if ((s->buf = calloc(1, s->sz)) == NULL)
1198                                         err(EXIT_FAILURE, "malloc failed");
1199                                 s->nocopy = 1;
1200                         }
1201                 } else {
1202                         osh.sh_flags = ish.sh_flags;
1203                         /*
1204                          * Newer binutils as(1) emits the section flag
1205                          * SHF_INFO_LINK for relocation sections. elfcopy
1206                          * emits this flag in the output section if it's
1207                          * missing in the input section, to remain compatible
1208                          * with binutils.
1209                          */
1210                         if (ish.sh_type == SHT_REL || ish.sh_type == SHT_RELA)
1211                                 osh.sh_flags |= SHF_INFO_LINK;
1212                 }
1213         }
1214
1215         if (name == NULL)
1216                 add_to_shstrtab(ecp, s->name);
1217         else
1218                 add_to_shstrtab(ecp, name);
1219
1220         if (!gelf_update_shdr(s->os, &osh))
1221                 errx(EXIT_FAILURE, "elf_update_shdr failed: %s",
1222                     elf_errmsg(-1));
1223 }
1224
1225 void
1226 copy_data(struct section *s)
1227 {
1228         Elf_Data        *id, *od;
1229         int              elferr;
1230
1231         if (s->nocopy && s->buf == NULL)
1232                 return;
1233
1234         if ((id = elf_getdata(s->is, NULL)) == NULL) {
1235                 (void) elf_errno();
1236                 if ((id = elf_rawdata(s->is, NULL)) == NULL) {
1237                         elferr = elf_errno();
1238                         if (elferr != 0)
1239                                 errx(EXIT_FAILURE, "failed to read section:"
1240                                     " %s", s->name);
1241                         return;
1242                 }
1243         }
1244
1245         if ((od = elf_newdata(s->os)) == NULL)
1246                 errx(EXIT_FAILURE, "elf_newdata() failed: %s",
1247                     elf_errmsg(-1));
1248
1249         if (s->nocopy) {
1250                 /* Use s->buf as content if s->nocopy is set. */
1251                 od->d_align     = id->d_align;
1252                 od->d_off       = 0;
1253                 od->d_buf       = s->buf;
1254                 od->d_type      = id->d_type;
1255                 od->d_size      = s->sz;
1256                 od->d_version   = id->d_version;
1257         } else {
1258                 od->d_align     = id->d_align;
1259                 od->d_off       = id->d_off;
1260                 od->d_buf       = id->d_buf;
1261                 od->d_type      = id->d_type;
1262                 od->d_size      = id->d_size;
1263                 od->d_version   = id->d_version;
1264         }
1265
1266         /*
1267          * Alignment Fixup. libelf does not allow the alignment for
1268          * Elf_Data descriptor to be set to 0. In this case we workaround
1269          * it by setting the alignment to 1.
1270          *
1271          * According to the ELF ABI, alignment 0 and 1 has the same
1272          * meaning: the section has no alignment constraints.
1273          */
1274         if (od->d_align == 0)
1275                 od->d_align = 1;
1276 }
1277
1278 struct section *
1279 create_external_section(struct elfcopy *ecp, const char *name, char *newname,
1280     void *buf, uint64_t size, uint64_t off, uint64_t stype, Elf_Type dtype,
1281     uint64_t flags, uint64_t align, uint64_t vma, int loadable)
1282 {
1283         struct section  *s;
1284         Elf_Scn         *os;
1285         Elf_Data        *od;
1286         GElf_Shdr        osh;
1287
1288         if ((os = elf_newscn(ecp->eout)) == NULL)
1289                 errx(EXIT_FAILURE, "elf_newscn() failed: %s",
1290                     elf_errmsg(-1));
1291         if ((s = calloc(1, sizeof(*s))) == NULL)
1292                 err(EXIT_FAILURE, "calloc failed");
1293         s->name = name;
1294         s->newname = newname;   /* needs to be free()'ed */
1295         s->off = off;
1296         s->sz = size;
1297         s->vma = vma;
1298         s->align = align;
1299         s->loadable = loadable;
1300         s->is = NULL;
1301         s->os = os;
1302         s->type = stype;
1303         s->nocopy = 1;
1304         insert_to_sec_list(ecp, s, 1);
1305
1306         if (gelf_getshdr(os, &osh) == NULL)
1307                 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1308                     elf_errmsg(-1));
1309         osh.sh_flags = flags;
1310         osh.sh_type = s->type;
1311         osh.sh_addr = s->vma;
1312         osh.sh_addralign = s->align;
1313         if (!gelf_update_shdr(os, &osh))
1314                 errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s",
1315                     elf_errmsg(-1));
1316         add_to_shstrtab(ecp, name);
1317
1318         if (buf != NULL && size != 0) {
1319                 if ((od = elf_newdata(os)) == NULL)
1320                         errx(EXIT_FAILURE, "elf_newdata() failed: %s",
1321                             elf_errmsg(-1));
1322                 od->d_align = align;
1323                 od->d_off = 0;
1324                 od->d_buf = buf;
1325                 od->d_size = size;
1326                 od->d_type = dtype;
1327                 od->d_version = EV_CURRENT;
1328         }
1329
1330         /*
1331          * Clear SYMTAB_INTACT, as we probably need to update/add new
1332          * STT_SECTION symbols into the symbol table.
1333          */
1334         ecp->flags &= ~SYMTAB_INTACT;
1335
1336         return (s);
1337 }
1338
1339 /*
1340  * Insert sections specified by --add-section to the end of section list.
1341  */
1342 static void
1343 insert_sections(struct elfcopy *ecp)
1344 {
1345         struct sec_add  *sa;
1346         struct section  *s;
1347         size_t           off;
1348         uint64_t         stype;
1349
1350         /* Put these sections in the end of current list. */
1351         off = 0;
1352         TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
1353                 if (s->type != SHT_NOBITS && s->type != SHT_NULL)
1354                         off = s->off + s->sz;
1355                 else
1356                         off = s->off;
1357         }
1358
1359         STAILQ_FOREACH(sa, &ecp->v_sadd, sadd_list) {
1360
1361                 /* TODO: Add section header vma/lma, flag changes here */
1362
1363                 /*
1364                  * The default section type for user added section is
1365                  * SHT_PROGBITS. If the section name match certain patterns,
1366                  * elfcopy will try to set a more appropriate section type.
1367                  * However, data type is always set to ELF_T_BYTE and no
1368                  * translation is performed by libelf.
1369                  */
1370                 stype = SHT_PROGBITS;
1371                 if (strcmp(sa->name, ".note") == 0 ||
1372                     strncmp(sa->name, ".note.", strlen(".note.")) == 0)
1373                         stype = SHT_NOTE;
1374
1375                 (void) create_external_section(ecp, sa->name, NULL, sa->content,
1376                     sa->size, off, stype, ELF_T_BYTE, 0, 1, 0, 0);
1377         }
1378 }
1379
1380 void
1381 add_to_shstrtab(struct elfcopy *ecp, const char *name)
1382 {
1383
1384         if (elftc_string_table_insert(ecp->shstrtab->strtab, name) == 0)
1385                 errx(EXIT_FAILURE, "elftc_string_table_insert failed");
1386 }
1387
1388 void
1389 update_shdr(struct elfcopy *ecp, int update_link)
1390 {
1391         struct section  *s;
1392         GElf_Shdr        osh;
1393         int              elferr;
1394
1395         /* Finalize the section name string table (.shstrtab). */
1396         set_shstrtab(ecp);
1397
1398         TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
1399                 if (s->pseudo)
1400                         continue;
1401
1402                 if (gelf_getshdr(s->os, &osh) == NULL)
1403                         errx(EXIT_FAILURE, "gelf_getshdr failed: %s",
1404                             elf_errmsg(-1));
1405
1406                 /* Find section name in string table and set sh_name. */
1407                 osh.sh_name = elftc_string_table_lookup(ecp->shstrtab->strtab,
1408                     s->name);
1409
1410                 /*
1411                  * sh_link needs to be updated, since the index of the
1412                  * linked section might have changed.
1413                  */
1414                 if (update_link && osh.sh_link != 0)
1415                         osh.sh_link = ecp->secndx[osh.sh_link];
1416
1417                 /*
1418                  * sh_info of relocation section links to the section to which
1419                  * its relocation info applies. So it may need update as well.
1420                  */
1421                 if ((s->type == SHT_REL || s->type == SHT_RELA) &&
1422                     osh.sh_info != 0)
1423                         osh.sh_info = ecp->secndx[osh.sh_info];
1424
1425                 /*
1426                  * sh_info of SHT_GROUP section needs to point to the correct
1427                  * string in the symbol table.
1428                  */
1429                 if (s->type == SHT_GROUP && (ecp->flags & SYMTAB_EXIST) &&
1430                     (ecp->flags & SYMTAB_INTACT) == 0)
1431                         osh.sh_info = ecp->symndx[osh.sh_info];
1432
1433                 if (!gelf_update_shdr(s->os, &osh))
1434                         errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s",
1435                             elf_errmsg(-1));
1436         }
1437         elferr = elf_errno();
1438         if (elferr != 0)
1439                 errx(EXIT_FAILURE, "elf_nextscn failed: %s",
1440                     elf_errmsg(elferr));
1441 }
1442
1443 void
1444 init_shstrtab(struct elfcopy *ecp)
1445 {
1446         Elf_Scn *shstrtab;
1447         GElf_Shdr shdr;
1448         struct section *s;
1449         size_t indx, sizehint;
1450
1451         if (elf_getshdrstrndx(ecp->ein, &indx) == 0) {
1452                 shstrtab = elf_getscn(ecp->ein, indx);
1453                 if (shstrtab == NULL)
1454                         errx(EXIT_FAILURE, "elf_getscn failed: %s",
1455                             elf_errmsg(-1));
1456                 if (gelf_getshdr(shstrtab, &shdr) != &shdr)
1457                         errx(EXIT_FAILURE, "gelf_getshdr failed: %s",
1458                             elf_errmsg(-1));
1459                 sizehint = shdr.sh_size;
1460         } else {
1461                 /* Clear the error from elf_getshdrstrndx(3). */
1462                 (void)elf_errno();
1463                 sizehint = 0;
1464         }
1465
1466         if ((ecp->shstrtab = calloc(1, sizeof(*ecp->shstrtab))) == NULL)
1467                 err(EXIT_FAILURE, "calloc failed");
1468         s = ecp->shstrtab;
1469         s->name = ".shstrtab";
1470         s->is = NULL;
1471         s->sz = 0;
1472         s->align = 1;
1473         s->loadable = 0;
1474         s->type = SHT_STRTAB;
1475         s->vma = 0;
1476         s->strtab = elftc_string_table_create(sizehint);
1477
1478         add_to_shstrtab(ecp, "");
1479         add_to_shstrtab(ecp, ".symtab");
1480         add_to_shstrtab(ecp, ".strtab");
1481         add_to_shstrtab(ecp, ".shstrtab");
1482 }
1483
1484 static void
1485 set_shstrtab(struct elfcopy *ecp)
1486 {
1487         struct section  *s;
1488         Elf_Data        *data;
1489         GElf_Shdr        sh;
1490         const char      *image;
1491         size_t           sz;
1492
1493         s = ecp->shstrtab;
1494
1495         if (s->os == NULL) {
1496                 /* Input object does not contain .shstrtab section */
1497                 if ((s->os = elf_newscn(ecp->eout)) == NULL)
1498                         errx(EXIT_FAILURE, "elf_newscn failed: %s",
1499                             elf_errmsg(-1));
1500                 insert_to_sec_list(ecp, s, 1);
1501         }
1502
1503         if (gelf_getshdr(s->os, &sh) == NULL)
1504                 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1505                     elf_errmsg(-1));
1506         sh.sh_addr      = 0;
1507         sh.sh_addralign = 1;
1508         sh.sh_offset    = s->off;
1509         sh.sh_type      = SHT_STRTAB;
1510         sh.sh_flags     = 0;
1511         sh.sh_entsize   = 0;
1512         sh.sh_info      = 0;
1513         sh.sh_link      = 0;
1514
1515         if ((data = elf_newdata(s->os)) == NULL)
1516                 errx(EXIT_FAILURE, "elf_newdata() failed: %s",
1517                     elf_errmsg(-1));
1518
1519         /*
1520          * If we don't have a symbol table, skip those a few bytes
1521          * which are reserved for this in the beginning of shstrtab.
1522          */
1523         if (!(ecp->flags & SYMTAB_EXIST)) {
1524                 elftc_string_table_remove(s->strtab, ".symtab");
1525                 elftc_string_table_remove(s->strtab, ".strtab");
1526         }
1527
1528         image = elftc_string_table_image(s->strtab, &sz);
1529         s->sz = sz;
1530
1531         sh.sh_size      = sz;
1532         if (!gelf_update_shdr(s->os, &sh))
1533                 errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s",
1534                     elf_errmsg(-1));
1535
1536         data->d_align   = 1;
1537         data->d_buf     = (void *)(uintptr_t)image;
1538         data->d_size    = sz;
1539         data->d_off     = 0;
1540         data->d_type    = ELF_T_BYTE;
1541         data->d_version = EV_CURRENT;
1542
1543         if (!elf_setshstrndx(ecp->eout, elf_ndxscn(s->os)))
1544                 errx(EXIT_FAILURE, "elf_setshstrndx() failed: %s",
1545                      elf_errmsg(-1));
1546 }
1547
1548 void
1549 add_section(struct elfcopy *ecp, const char *arg)
1550 {
1551         struct sec_add  *sa;
1552         struct stat      sb;
1553         const char      *s, *fn;
1554         FILE            *fp;
1555         int              len;
1556
1557         if ((s = strchr(arg, '=')) == NULL)
1558                 errx(EXIT_FAILURE,
1559                     "illegal format for --add-section option");
1560         if ((sa = malloc(sizeof(*sa))) == NULL)
1561                 err(EXIT_FAILURE, "malloc failed");
1562
1563         len = s - arg;
1564         if ((sa->name = malloc(len + 1)) == NULL)
1565                 err(EXIT_FAILURE, "malloc failed");
1566         strncpy(sa->name, arg, len);
1567         sa->name[len] = '\0';
1568
1569         fn = s + 1;
1570         if (stat(fn, &sb) == -1)
1571                 err(EXIT_FAILURE, "stat failed");
1572         sa->size = sb.st_size;
1573         if (sa->size > 0) {
1574                 if ((sa->content = malloc(sa->size)) == NULL)
1575                         err(EXIT_FAILURE, "malloc failed");
1576                 if ((fp = fopen(fn, "r")) == NULL)
1577                         err(EXIT_FAILURE, "can not open %s", fn);
1578                 if (fread(sa->content, 1, sa->size, fp) == 0 ||
1579                     ferror(fp))
1580                         err(EXIT_FAILURE, "fread failed");
1581                 fclose(fp);
1582         } else
1583                 sa->content = NULL;
1584
1585         STAILQ_INSERT_TAIL(&ecp->v_sadd, sa, sadd_list);
1586         ecp->flags |= SEC_ADD;
1587 }
1588
1589 void
1590 free_sec_add(struct elfcopy *ecp)
1591 {
1592         struct sec_add *sa, *sa_temp;
1593
1594         STAILQ_FOREACH_SAFE(sa, &ecp->v_sadd, sadd_list, sa_temp) {
1595                 STAILQ_REMOVE(&ecp->v_sadd, sa, sec_add, sadd_list);
1596                 free(sa->name);
1597                 free(sa->content);
1598                 free(sa);
1599         }
1600 }
1601
1602 static void
1603 add_gnu_debuglink(struct elfcopy *ecp)
1604 {
1605         struct sec_add  *sa;
1606         struct stat      sb;
1607         FILE            *fp;
1608         char            *fnbase, *buf;
1609         int              crc_off;
1610         int              crc;
1611
1612         if (ecp->debuglink == NULL)
1613                 return;
1614
1615         /* Read debug file content. */
1616         if ((sa = malloc(sizeof(*sa))) == NULL)
1617                 err(EXIT_FAILURE, "malloc failed");
1618         if ((sa->name = strdup(".gnu_debuglink")) == NULL)
1619                 err(EXIT_FAILURE, "strdup failed");
1620         if (stat(ecp->debuglink, &sb) == -1)
1621                 err(EXIT_FAILURE, "stat failed");
1622         if (sb.st_size == 0)
1623                 errx(EXIT_FAILURE, "empty debug link target %s",
1624                     ecp->debuglink);
1625         if ((buf = malloc(sb.st_size)) == NULL)
1626                 err(EXIT_FAILURE, "malloc failed");
1627         if ((fp = fopen(ecp->debuglink, "r")) == NULL)
1628                 err(EXIT_FAILURE, "can not open %s", ecp->debuglink);
1629         if (fread(buf, 1, sb.st_size, fp) == 0 ||
1630             ferror(fp))
1631                 err(EXIT_FAILURE, "fread failed");
1632         fclose(fp);
1633
1634         /* Calculate crc checksum.  */
1635         crc = calc_crc32(buf, sb.st_size, 0xFFFFFFFF);
1636         free(buf);
1637
1638         /* Calculate section size and the offset to store crc checksum. */
1639         if ((fnbase = basename(ecp->debuglink)) == NULL)
1640                 err(EXIT_FAILURE, "basename failed");
1641         crc_off = roundup(strlen(fnbase) + 1, 4);
1642         sa->size = crc_off + 4;
1643
1644         /* Section content. */
1645         if ((sa->content = calloc(1, sa->size)) == NULL)
1646                 err(EXIT_FAILURE, "malloc failed");
1647         strncpy(sa->content, fnbase, strlen(fnbase));
1648         if (ecp->oed == ELFDATA2LSB) {
1649                 sa->content[crc_off] = crc & 0xFF;
1650                 sa->content[crc_off + 1] = (crc >> 8) & 0xFF;
1651                 sa->content[crc_off + 2] = (crc >> 16) & 0xFF;
1652                 sa->content[crc_off + 3] = crc >> 24;
1653         } else {
1654                 sa->content[crc_off] = crc >> 24;
1655                 sa->content[crc_off + 1] = (crc >> 16) & 0xFF;
1656                 sa->content[crc_off + 2] = (crc >> 8) & 0xFF;
1657                 sa->content[crc_off + 3] = crc & 0xFF;
1658         }
1659
1660         STAILQ_INSERT_TAIL(&ecp->v_sadd, sa, sadd_list);
1661         ecp->flags |= SEC_ADD;
1662 }
1663
1664 static uint32_t crctable[256] =
1665 {
1666         0x00000000L, 0x77073096L, 0xEE0E612CL, 0x990951BAL,
1667         0x076DC419L, 0x706AF48FL, 0xE963A535L, 0x9E6495A3L,
1668         0x0EDB8832L, 0x79DCB8A4L, 0xE0D5E91EL, 0x97D2D988L,
1669         0x09B64C2BL, 0x7EB17CBDL, 0xE7B82D07L, 0x90BF1D91L,
1670         0x1DB71064L, 0x6AB020F2L, 0xF3B97148L, 0x84BE41DEL,
1671         0x1ADAD47DL, 0x6DDDE4EBL, 0xF4D4B551L, 0x83D385C7L,
1672         0x136C9856L, 0x646BA8C0L, 0xFD62F97AL, 0x8A65C9ECL,
1673         0x14015C4FL, 0x63066CD9L, 0xFA0F3D63L, 0x8D080DF5L,
1674         0x3B6E20C8L, 0x4C69105EL, 0xD56041E4L, 0xA2677172L,
1675         0x3C03E4D1L, 0x4B04D447L, 0xD20D85FDL, 0xA50AB56BL,
1676         0x35B5A8FAL, 0x42B2986CL, 0xDBBBC9D6L, 0xACBCF940L,
1677         0x32D86CE3L, 0x45DF5C75L, 0xDCD60DCFL, 0xABD13D59L,
1678         0x26D930ACL, 0x51DE003AL, 0xC8D75180L, 0xBFD06116L,
1679         0x21B4F4B5L, 0x56B3C423L, 0xCFBA9599L, 0xB8BDA50FL,
1680         0x2802B89EL, 0x5F058808L, 0xC60CD9B2L, 0xB10BE924L,
1681         0x2F6F7C87L, 0x58684C11L, 0xC1611DABL, 0xB6662D3DL,
1682         0x76DC4190L, 0x01DB7106L, 0x98D220BCL, 0xEFD5102AL,
1683         0x71B18589L, 0x06B6B51FL, 0x9FBFE4A5L, 0xE8B8D433L,
1684         0x7807C9A2L, 0x0F00F934L, 0x9609A88EL, 0xE10E9818L,
1685         0x7F6A0DBBL, 0x086D3D2DL, 0x91646C97L, 0xE6635C01L,
1686         0x6B6B51F4L, 0x1C6C6162L, 0x856530D8L, 0xF262004EL,
1687         0x6C0695EDL, 0x1B01A57BL, 0x8208F4C1L, 0xF50FC457L,
1688         0x65B0D9C6L, 0x12B7E950L, 0x8BBEB8EAL, 0xFCB9887CL,
1689         0x62DD1DDFL, 0x15DA2D49L, 0x8CD37CF3L, 0xFBD44C65L,
1690         0x4DB26158L, 0x3AB551CEL, 0xA3BC0074L, 0xD4BB30E2L,
1691         0x4ADFA541L, 0x3DD895D7L, 0xA4D1C46DL, 0xD3D6F4FBL,
1692         0x4369E96AL, 0x346ED9FCL, 0xAD678846L, 0xDA60B8D0L,
1693         0x44042D73L, 0x33031DE5L, 0xAA0A4C5FL, 0xDD0D7CC9L,
1694         0x5005713CL, 0x270241AAL, 0xBE0B1010L, 0xC90C2086L,
1695         0x5768B525L, 0x206F85B3L, 0xB966D409L, 0xCE61E49FL,
1696         0x5EDEF90EL, 0x29D9C998L, 0xB0D09822L, 0xC7D7A8B4L,
1697         0x59B33D17L, 0x2EB40D81L, 0xB7BD5C3BL, 0xC0BA6CADL,
1698         0xEDB88320L, 0x9ABFB3B6L, 0x03B6E20CL, 0x74B1D29AL,
1699         0xEAD54739L, 0x9DD277AFL, 0x04DB2615L, 0x73DC1683L,
1700         0xE3630B12L, 0x94643B84L, 0x0D6D6A3EL, 0x7A6A5AA8L,
1701         0xE40ECF0BL, 0x9309FF9DL, 0x0A00AE27L, 0x7D079EB1L,
1702         0xF00F9344L, 0x8708A3D2L, 0x1E01F268L, 0x6906C2FEL,
1703         0xF762575DL, 0x806567CBL, 0x196C3671L, 0x6E6B06E7L,
1704         0xFED41B76L, 0x89D32BE0L, 0x10DA7A5AL, 0x67DD4ACCL,
1705         0xF9B9DF6FL, 0x8EBEEFF9L, 0x17B7BE43L, 0x60B08ED5L,
1706         0xD6D6A3E8L, 0xA1D1937EL, 0x38D8C2C4L, 0x4FDFF252L,
1707         0xD1BB67F1L, 0xA6BC5767L, 0x3FB506DDL, 0x48B2364BL,
1708         0xD80D2BDAL, 0xAF0A1B4CL, 0x36034AF6L, 0x41047A60L,
1709         0xDF60EFC3L, 0xA867DF55L, 0x316E8EEFL, 0x4669BE79L,
1710         0xCB61B38CL, 0xBC66831AL, 0x256FD2A0L, 0x5268E236L,
1711         0xCC0C7795L, 0xBB0B4703L, 0x220216B9L, 0x5505262FL,
1712         0xC5BA3BBEL, 0xB2BD0B28L, 0x2BB45A92L, 0x5CB36A04L,
1713         0xC2D7FFA7L, 0xB5D0CF31L, 0x2CD99E8BL, 0x5BDEAE1DL,
1714         0x9B64C2B0L, 0xEC63F226L, 0x756AA39CL, 0x026D930AL,
1715         0x9C0906A9L, 0xEB0E363FL, 0x72076785L, 0x05005713L,
1716         0x95BF4A82L, 0xE2B87A14L, 0x7BB12BAEL, 0x0CB61B38L,
1717         0x92D28E9BL, 0xE5D5BE0DL, 0x7CDCEFB7L, 0x0BDBDF21L,
1718         0x86D3D2D4L, 0xF1D4E242L, 0x68DDB3F8L, 0x1FDA836EL,
1719         0x81BE16CDL, 0xF6B9265BL, 0x6FB077E1L, 0x18B74777L,
1720         0x88085AE6L, 0xFF0F6A70L, 0x66063BCAL, 0x11010B5CL,
1721         0x8F659EFFL, 0xF862AE69L, 0x616BFFD3L, 0x166CCF45L,
1722         0xA00AE278L, 0xD70DD2EEL, 0x4E048354L, 0x3903B3C2L,
1723         0xA7672661L, 0xD06016F7L, 0x4969474DL, 0x3E6E77DBL,
1724         0xAED16A4AL, 0xD9D65ADCL, 0x40DF0B66L, 0x37D83BF0L,
1725         0xA9BCAE53L, 0xDEBB9EC5L, 0x47B2CF7FL, 0x30B5FFE9L,
1726         0xBDBDF21CL, 0xCABAC28AL, 0x53B39330L, 0x24B4A3A6L,
1727         0xBAD03605L, 0xCDD70693L, 0x54DE5729L, 0x23D967BFL,
1728         0xB3667A2EL, 0xC4614AB8L, 0x5D681B02L, 0x2A6F2B94L,
1729         0xB40BBE37L, 0xC30C8EA1L, 0x5A05DF1BL, 0x2D02EF8DL
1730 };
1731
1732 static uint32_t
1733 calc_crc32(const char *p, size_t len, uint32_t crc)
1734 {
1735         uint32_t i;
1736
1737         for (i = 0; i < len; i++) {
1738                 crc = crctable[(crc ^ *p++) & 0xFFL] ^ (crc >> 8);
1739         }
1740
1741         return (crc ^ 0xFFFFFFFF);
1742 }