contrib/elftoolchain/elfcopy/main.c

   1 /*-
   2  * Copyright (c) 2007-2013 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
  30 #include <err.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <getopt.h>
  34 #include <libelftc.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <unistd.h>
  39
  40 #include "elfcopy.h"
  41
  42 ELFTC_VCSID("$Id: main.c 3446 2016-05-03 01:31:17Z emaste $");
  43
  44 /* Backwards compatability for older FreeBSD releases. */
  45 #ifndef ELFOSABI_CLOUDABI
  46 #define ELFOSABI_CLOUDABI 17
  47 #endif
  48
  49 enum options
  50 {
  51         ECP_ADD_GNU_DEBUGLINK,
  52         ECP_ADD_SECTION,
  53         ECP_CHANGE_ADDR,
  54         ECP_CHANGE_SEC_ADDR,
  55         ECP_CHANGE_SEC_LMA,
  56         ECP_CHANGE_SEC_VMA,
  57         ECP_CHANGE_START,
  58         ECP_CHANGE_WARN,
  59         ECP_GAP_FILL,
  60         ECP_GLOBALIZE_SYMBOL,
  61         ECP_GLOBALIZE_SYMBOLS,
  62         ECP_KEEP_SYMBOLS,
  63         ECP_KEEP_GLOBAL_SYMBOLS,
  64         ECP_LOCALIZE_HIDDEN,
  65         ECP_LOCALIZE_SYMBOLS,
  66         ECP_NO_CHANGE_WARN,
  67         ECP_ONLY_DEBUG,
  68         ECP_ONLY_DWO,
  69         ECP_PAD_TO,
  70         ECP_PREFIX_ALLOC,
  71         ECP_PREFIX_SEC,
  72         ECP_PREFIX_SYM,
  73         ECP_REDEF_SYMBOL,
  74         ECP_REDEF_SYMBOLS,
  75         ECP_RENAME_SECTION,
  76         ECP_SET_OSABI,
  77         ECP_SET_SEC_FLAGS,
  78         ECP_SET_START,
  79         ECP_SREC_FORCE_S3,
  80         ECP_SREC_LEN,
  81         ECP_STRIP_DWO,
  82         ECP_STRIP_SYMBOLS,
  83         ECP_STRIP_UNNEEDED,
  84         ECP_WEAKEN_ALL,
  85         ECP_WEAKEN_SYMBOLS
  86 };
  87
  88 static struct option mcs_longopts[] =
  89 {
  90         { "help", no_argument, NULL, 'h' },
  91         { "version", no_argument, NULL, 'V' },
  92         { NULL, 0, NULL, 0 }
  93 };
  94
  95 static struct option strip_longopts[] =
  96 {
  97         {"discard-all", no_argument, NULL, 'x'},
  98         {"discard-locals", no_argument, NULL, 'X'},
  99         {"help", no_argument, NULL, 'h'},
 100         {"input-target", required_argument, NULL, 'I'},
 101         {"keep-symbol", required_argument, NULL, 'K'},
 102         {"only-keep-debug", no_argument, NULL, ECP_ONLY_DEBUG},
 103         {"output-file", required_argument, NULL, 'o'},
 104         {"output-target", required_argument, NULL, 'O'},
 105         {"preserve-dates", no_argument, NULL, 'p'},
 106         {"remove-section", required_argument, NULL, 'R'},
 107         {"strip-all", no_argument, NULL, 's'},
 108         {"strip-debug", no_argument, NULL, 'S'},
 109         {"strip-symbol", required_argument, NULL, 'N'},
 110         {"strip-unneeded", no_argument, NULL, ECP_STRIP_UNNEEDED},
 111         {"version", no_argument, NULL, 'V'},
 112         {"wildcard", no_argument, NULL, 'w'},
 113         {NULL, 0, NULL, 0}
 114 };
 115
 116 static struct option elfcopy_longopts[] =
 117 {
 118         {"add-gnu-debuglink", required_argument, NULL, ECP_ADD_GNU_DEBUGLINK},
 119         {"add-section", required_argument, NULL, ECP_ADD_SECTION},
 120         {"adjust-section-vma", required_argument, NULL, ECP_CHANGE_SEC_ADDR},
 121         {"adjust-vma", required_argument, NULL, ECP_CHANGE_ADDR},
 122         {"adjust-start", required_argument, NULL, ECP_CHANGE_START},
 123         {"adjust-warnings", no_argument, NULL, ECP_CHANGE_WARN},
 124         {"binary-architecture", required_argument, NULL, 'B'},
 125         {"change-addresses", required_argument, NULL, ECP_CHANGE_ADDR},
 126         {"change-section-address", required_argument, NULL,
 127          ECP_CHANGE_SEC_ADDR},
 128         {"change-section-lma", required_argument, NULL, ECP_CHANGE_SEC_LMA},
 129         {"change-section-vma", required_argument, NULL, ECP_CHANGE_SEC_VMA},
 130         {"change-start", required_argument, NULL, ECP_CHANGE_START},
 131         {"change-warnings", no_argument, NULL, ECP_CHANGE_WARN},
 132         {"discard-all", no_argument, NULL, 'x'},
 133         {"discard-locals", no_argument, NULL, 'X'},
 134         {"extract-dwo", no_argument, NULL, ECP_ONLY_DWO},
 135         {"gap-fill", required_argument, NULL, ECP_GAP_FILL},
 136         {"globalize-symbol", required_argument, NULL, ECP_GLOBALIZE_SYMBOL},
 137         {"globalize-symbols", required_argument, NULL, ECP_GLOBALIZE_SYMBOLS},
 138         {"help", no_argument, NULL, 'h'},
 139         {"input-target", required_argument, NULL, 'I'},
 140         {"keep-symbol", required_argument, NULL, 'K'},
 141         {"keep-symbols", required_argument, NULL, ECP_KEEP_SYMBOLS},
 142         {"keep-global-symbol", required_argument, NULL, 'G'},
 143         {"keep-global-symbols", required_argument, NULL,
 144          ECP_KEEP_GLOBAL_SYMBOLS},
 145         {"localize-hidden", no_argument, NULL, ECP_LOCALIZE_HIDDEN},
 146         {"localize-symbol", required_argument, NULL, 'L'},
 147         {"localize-symbols", required_argument, NULL, ECP_LOCALIZE_SYMBOLS},
 148         {"no-adjust-warnings", no_argument, NULL, ECP_NO_CHANGE_WARN},
 149         {"no-change-warnings", no_argument, NULL, ECP_NO_CHANGE_WARN},
 150         {"only-keep-debug", no_argument, NULL, ECP_ONLY_DEBUG},
 151         {"only-section", required_argument, NULL, 'j'},
 152         {"osabi", required_argument, NULL, ECP_SET_OSABI},
 153         {"output-target", required_argument, NULL, 'O'},
 154         {"pad-to", required_argument, NULL, ECP_PAD_TO},
 155         {"preserve-dates", no_argument, NULL, 'p'},
 156         {"prefix-alloc-sections", required_argument, NULL, ECP_PREFIX_ALLOC},
 157         {"prefix-sections", required_argument, NULL, ECP_PREFIX_SEC},
 158         {"prefix-symbols", required_argument, NULL, ECP_PREFIX_SYM},
 159         {"redefine-sym", required_argument, NULL, ECP_REDEF_SYMBOL},
 160         {"redefine-syms", required_argument, NULL, ECP_REDEF_SYMBOLS},
 161         {"remove-section", required_argument, NULL, 'R'},
 162         {"rename-section", required_argument, NULL, ECP_RENAME_SECTION},
 163         {"set-section-flags", required_argument, NULL, ECP_SET_SEC_FLAGS},
 164         {"set-start", required_argument, NULL, ECP_SET_START},
 165         {"srec-forceS3", no_argument, NULL, ECP_SREC_FORCE_S3},
 166         {"srec-len", required_argument, NULL, ECP_SREC_LEN},
 167         {"strip-all", no_argument, NULL, 'S'},
 168         {"strip-debug", no_argument, 0, 'g'},
 169         {"strip-dwo", no_argument, NULL, ECP_STRIP_DWO},
 170         {"strip-symbol", required_argument, NULL, 'N'},
 171         {"strip-symbols", required_argument, NULL, ECP_STRIP_SYMBOLS},
 172         {"strip-unneeded", no_argument, NULL, ECP_STRIP_UNNEEDED},
 173         {"version", no_argument, NULL, 'V'},
 174         {"weaken", no_argument, NULL, ECP_WEAKEN_ALL},
 175         {"weaken-symbol", required_argument, NULL, 'W'},
 176         {"weaken-symbols", required_argument, NULL, ECP_WEAKEN_SYMBOLS},
 177         {"wildcard", no_argument, NULL, 'w'},
 178         {NULL, 0, NULL, 0}
 179 };
 180
 181 static struct {
 182         const char *name;
 183         int value;
 184 } sec_flags[] = {
 185         {"alloc", SF_ALLOC},
 186         {"load", SF_LOAD},
 187         {"noload", SF_NOLOAD},
 188         {"readonly", SF_READONLY},
 189         {"debug", SF_DEBUG},
 190         {"code", SF_CODE},
 191         {"data", SF_DATA},
 192         {"rom", SF_ROM},
 193         {"share", SF_SHARED},
 194         {"contents", SF_CONTENTS},
 195         {NULL, 0}
 196 };
 197
 198 static struct {
 199         const char *name;
 200         int abi;
 201 } osabis[] = {
 202         {"sysv", ELFOSABI_SYSV},
 203         {"hpus", ELFOSABI_HPUX},
 204         {"netbsd", ELFOSABI_NETBSD},
 205         {"linux", ELFOSABI_LINUX},
 206         {"hurd", ELFOSABI_HURD},
 207         {"86open", ELFOSABI_86OPEN},
 208         {"solaris", ELFOSABI_SOLARIS},
 209         {"aix", ELFOSABI_AIX},
 210         {"irix", ELFOSABI_IRIX},
 211         {"freebsd", ELFOSABI_FREEBSD},
 212         {"tru64", ELFOSABI_TRU64},
 213         {"modesto", ELFOSABI_MODESTO},
 214         {"openbsd", ELFOSABI_OPENBSD},
 215         {"openvms", ELFOSABI_OPENVMS},
 216         {"nsk", ELFOSABI_NSK},
 217         {"cloudabi", ELFOSABI_CLOUDABI},
 218         {"arm", ELFOSABI_ARM},
 219         {"standalone", ELFOSABI_STANDALONE},
 220         {NULL, 0}
 221 };
 222
 223 static int      copy_from_tempfile(const char *src, const char *dst,
 224     int infd, int *outfd, int in_place);
 225 static void     create_file(struct elfcopy *ecp, const char *src,
 226     const char *dst);
 227 static void     elfcopy_main(struct elfcopy *ecp, int argc, char **argv);
 228 static void     elfcopy_usage(void);
 229 static void     mcs_main(struct elfcopy *ecp, int argc, char **argv);
 230 static void     mcs_usage(void);
 231 static void     parse_sec_address_op(struct elfcopy *ecp, int optnum,
 232     const char *optname, char *s);
 233 static void     parse_sec_flags(struct sec_action *sac, char *s);
 234 static void     parse_symlist_file(struct elfcopy *ecp, const char *fn,
 235     unsigned int op);
 236 static void     print_version(void);
 237 static void     set_input_target(struct elfcopy *ecp, const char *target_name);
 238 static void     set_osabi(struct elfcopy *ecp, const char *abi);
 239 static void     set_output_target(struct elfcopy *ecp, const char *target_name);
 240 static void     strip_main(struct elfcopy *ecp, int argc, char **argv);
 241 static void     strip_usage(void);
 242
 243 /*
 244  * An ELF object usually has a structure described by the
 245  * diagram below.
 246  *  _____________
 247  * |             |
 248  * |     NULL    | <- always a SHT_NULL section
 249  * |_____________|
 250  * |             |
 251  * |   .interp   |
 252  * |_____________|
 253  * |             |
 254  * |     ...     |
 255  * |_____________|
 256  * |             |
 257  * |    .text    |
 258  * |_____________|
 259  * |             |
 260  * |     ...     |
 261  * |_____________|
 262  * |             |
 263  * |  .comment   | <- above(include) this: normal sections
 264  * |_____________|
 265  * |             |
 266  * | add sections| <- unloadable sections added by --add-section
 267  * |_____________|
 268  * |             |
 269  * |  .shstrtab  | <- section name string table
 270  * |_____________|
 271  * |             |
 272  * |    shdrs    | <- section header table
 273  * |_____________|
 274  * |             |
 275  * |   .symtab   | <- symbol table, if any
 276  * |_____________|
 277  * |             |
 278  * |   .strtab   | <- symbol name string table, if any
 279  * |_____________|
 280  * |             |
 281  * |  .rel.text  | <- relocation info for .o files.
 282  * |_____________|
 283  */
 284 void
 285 create_elf(struct elfcopy *ecp)
 286 {
 287         struct section  *shtab;
 288         GElf_Ehdr        ieh;
 289         GElf_Ehdr        oeh;
 290         size_t           ishnum;
 291
 292         ecp->flags |= SYMTAB_INTACT;
 293
 294         /* Create EHDR. */
 295         if (gelf_getehdr(ecp->ein, &ieh) == NULL)
 296                 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s",
 297                     elf_errmsg(-1));
 298         if ((ecp->iec = gelf_getclass(ecp->ein)) == ELFCLASSNONE)
 299                 errx(EXIT_FAILURE, "getclass() failed: %s",
 300                     elf_errmsg(-1));
 301
 302         if (ecp->oec == ELFCLASSNONE)
 303                 ecp->oec = ecp->iec;
 304         if (ecp->oed == ELFDATANONE)
 305                 ecp->oed = ieh.e_ident[EI_DATA];
 306
 307         if (gelf_newehdr(ecp->eout, ecp->oec) == NULL)
 308                 errx(EXIT_FAILURE, "gelf_newehdr failed: %s",
 309                     elf_errmsg(-1));
 310         if (gelf_getehdr(ecp->eout, &oeh) == NULL)
 311                 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s",
 312                     elf_errmsg(-1));
 313
 314         memcpy(oeh.e_ident, ieh.e_ident, sizeof(ieh.e_ident));
 315         oeh.e_ident[EI_CLASS] = ecp->oec;
 316         oeh.e_ident[EI_DATA]  = ecp->oed;
 317         if (ecp->abi != -1)
 318                 oeh.e_ident[EI_OSABI] = ecp->abi;
 319         oeh.e_flags           = ieh.e_flags;
 320         oeh.e_machine         = ieh.e_machine;
 321         oeh.e_type            = ieh.e_type;
 322         oeh.e_entry           = ieh.e_entry;
 323         oeh.e_version         = ieh.e_version;
 324
 325         ecp->flags &= ~(EXECUTABLE | DYNAMIC | RELOCATABLE);
 326         if (ieh.e_type == ET_EXEC)
 327                 ecp->flags |= EXECUTABLE;
 328         else if (ieh.e_type == ET_DYN)
 329                 ecp->flags |= DYNAMIC;
 330         else if (ieh.e_type == ET_REL)
 331                 ecp->flags |= RELOCATABLE;
 332         else
 333                 errx(EXIT_FAILURE, "unsupported e_type");
 334
 335         if (!elf_getshnum(ecp->ein, &ishnum))
 336                 errx(EXIT_FAILURE, "elf_getshnum failed: %s",
 337                     elf_errmsg(-1));
 338         if (ishnum > 0 && (ecp->secndx = calloc(ishnum,
 339             sizeof(*ecp->secndx))) == NULL)
 340                 err(EXIT_FAILURE, "calloc failed");
 341
 342         /* Read input object program header. */
 343         setup_phdr(ecp);
 344
 345         /*
 346          * Scan of input sections: we iterate through sections from input
 347          * object, skip sections need to be stripped, allot Elf_Scn and
 348          * create internal section structure for sections we want.
 349          * (i.e., determine output sections)
 350          */
 351         create_scn(ecp);
 352
 353         /* Apply section address changes, if any. */
 354         adjust_addr(ecp);
 355
 356         /*
 357          * Determine if the symbol table needs to be changed based on
 358          * command line options.
 359          */
 360         if (ecp->strip == STRIP_DEBUG ||
 361             ecp->strip == STRIP_UNNEEDED ||
 362             ecp->flags & WEAKEN_ALL ||
 363             ecp->flags & LOCALIZE_HIDDEN ||
 364             ecp->flags & DISCARD_LOCAL ||
 365             ecp->flags & DISCARD_LLABEL ||
 366             ecp->prefix_sym != NULL ||
 367             !STAILQ_EMPTY(&ecp->v_symop))
 368                 ecp->flags &= ~SYMTAB_INTACT;
 369
 370         /*
 371          * Create symbol table. Symbols are filtered or stripped according to
 372          * command line args specified by user, and later updated for the new
 373          * layout of sections in the output object.
 374          */
 375         if ((ecp->flags & SYMTAB_EXIST) != 0)
 376                 create_symtab(ecp);
 377
 378         /*
 379          * First processing of output sections: at this stage we copy the
 380          * content of each section from input to output object.  Section
 381          * content will be modified and printed (mcs) if need. Also content of
 382          * relocation section probably will be filtered and updated according
 383          * to symbol table changes.
 384          */
 385         copy_content(ecp);
 386
 387         /*
 388          * Write the underlying ehdr. Note that it should be called
 389          * before elf_setshstrndx() since it will overwrite e->e_shstrndx.
 390          */
 391         if (gelf_update_ehdr(ecp->eout, &oeh) == 0)
 392                 errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s",
 393                     elf_errmsg(-1));
 394
 395         /* Generate section name string table (.shstrtab). */
 396         set_shstrtab(ecp);
 397
 398         /*
 399          * Second processing of output sections: Update section headers.
 400          * At this stage we set name string index, update st_link and st_info
 401          * for output sections.
 402          */
 403         update_shdr(ecp, 1);
 404
 405         /* Renew oeh to get the updated e_shstrndx. */
 406         if (gelf_getehdr(ecp->eout, &oeh) == NULL)
 407                 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s",
 408                     elf_errmsg(-1));
 409
 410         /*
 411          * Insert SHDR table into the internal section list as a "pseudo"
 412          * section, so later it will get sorted and resynced just as "normal"
 413          * sections.
 414          *
 415          * Under FreeBSD, Binutils objcopy always put the section header
 416          * at the end of all the sections. We want to do the same here.
 417          *
 418          * However, note that the behaviour is still different with Binutils:
 419          * elfcopy checks the FreeBSD OSABI tag to tell whether it needs to
 420          * move the section headers, while Binutils is probably configured
 421          * this way when it's compiled on FreeBSD.
 422          */
 423         if (oeh.e_ident[EI_OSABI] == ELFOSABI_FREEBSD)
 424                 shtab = insert_shtab(ecp, 1);
 425         else
 426                 shtab = insert_shtab(ecp, 0);
 427
 428         /*
 429          * Resync section offsets in the output object. This is needed
 430          * because probably sections are modified or new sections are added,
 431          * as a result overlap/gap might appears.
 432          */
 433         resync_sections(ecp);
 434
 435         /* Store SHDR offset in EHDR. */
 436         oeh.e_shoff = shtab->off;
 437
 438         /* Put program header table immediately after the Elf header. */
 439         if (ecp->ophnum > 0) {
 440                 oeh.e_phoff = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT);
 441                 if (oeh.e_phoff == 0)
 442                         errx(EXIT_FAILURE, "gelf_fsize() failed: %s",
 443                             elf_errmsg(-1));
 444         }
 445
 446         /*
 447          * Update ELF object entry point if requested.
 448          */
 449         if (ecp->change_addr != 0)
 450                 oeh.e_entry += ecp->change_addr;
 451         if (ecp->flags & SET_START)
 452                 oeh.e_entry = ecp->set_start;
 453         if (ecp->change_start != 0)
 454                 oeh.e_entry += ecp->change_start;
 455
 456         /*
 457          * Update ehdr again before we call elf_update(), since we
 458          * modified e_shoff and e_phoff.
 459          */
 460         if (gelf_update_ehdr(ecp->eout, &oeh) == 0)
 461                 errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s",
 462                     elf_errmsg(-1));
 463
 464         if (ecp->ophnum > 0)
 465                 copy_phdr(ecp);
 466
 467         /* Write out the output elf object. */
 468         if (elf_update(ecp->eout, ELF_C_WRITE) < 0)
 469                 errx(EXIT_FAILURE, "elf_update() failed: %s",
 470                     elf_errmsg(-1));
 471
 472         /* Release allocated resource. */
 473         free_elf(ecp);
 474 }
 475
 476 void
 477 free_elf(struct elfcopy *ecp)
 478 {
 479         struct segment  *seg, *seg_temp;
 480         struct section  *sec, *sec_temp;
 481
 482         /* Free internal segment list. */
 483         if (!STAILQ_EMPTY(&ecp->v_seg)) {
 484                 STAILQ_FOREACH_SAFE(seg, &ecp->v_seg, seg_list, seg_temp) {
 485                         STAILQ_REMOVE(&ecp->v_seg, seg, segment, seg_list);
 486                         free(seg);
 487                 }
 488         }
 489
 490         /* Free symbol table buffers. */
 491         free_symtab(ecp);
 492
 493         /* Free internal section list. */
 494         if (!TAILQ_EMPTY(&ecp->v_sec)) {
 495                 TAILQ_FOREACH_SAFE(sec, &ecp->v_sec, sec_list, sec_temp) {
 496                         TAILQ_REMOVE(&ecp->v_sec, sec, sec_list);
 497                         if (sec->buf != NULL)
 498                                 free(sec->buf);
 499                         if (sec->newname != NULL)
 500                                 free(sec->newname);
 501                         if (sec->pad != NULL)
 502                                 free(sec->pad);
 503                         free(sec);
 504                 }
 505         }
 506
 507         if (ecp->secndx != NULL) {
 508                 free(ecp->secndx);
 509                 ecp->secndx = NULL;
 510         }
 511 }
 512
 513 /* Create a temporary file. */
 514 void
 515 create_tempfile(char **fn, int *fd)
 516 {
 517         const char      *tmpdir;
 518         char            *cp, *tmpf;
 519         size_t           tlen, plen;
 520
 521 #define _TEMPFILE "ecp.XXXXXXXX"
 522 #define _TEMPFILEPATH "/tmp/ecp.XXXXXXXX"
 523
 524         if (fn == NULL || fd == NULL)
 525                 return;
 526         /* Repect TMPDIR environment variable. */
 527         tmpdir = getenv("TMPDIR");
 528         if (tmpdir != NULL && *tmpdir != '\0') {
 529                 tlen = strlen(tmpdir);
 530                 plen = strlen(_TEMPFILE);
 531                 tmpf = malloc(tlen + plen + 2);
 532                 if (tmpf == NULL)
 533                         err(EXIT_FAILURE, "malloc failed");
 534                 strncpy(tmpf, tmpdir, tlen);
 535                 cp = &tmpf[tlen - 1];
 536                 if (*cp++ != '/')
 537                         *cp++ = '/';
 538                 strncpy(cp, _TEMPFILE, plen);
 539                 cp[plen] = '\0';
 540         } else {
 541                 tmpf = strdup(_TEMPFILEPATH);
 542                 if (tmpf == NULL)
 543                         err(EXIT_FAILURE, "strdup failed");
 544         }
 545         if ((*fd = mkstemp(tmpf)) == -1)
 546                 err(EXIT_FAILURE, "mkstemp %s failed", tmpf);
 547         if (fchmod(*fd, 0644) == -1)
 548                 err(EXIT_FAILURE, "fchmod %s failed", tmpf);
 549         *fn = tmpf;
 550
 551 #undef _TEMPFILE
 552 #undef _TEMPFILEPATH
 553 }
 554
 555 /*
 556  * Copy temporary file with path src and file descriptor infd to path dst.
 557  * If in_place is set act as if editing the file in place, avoiding rename()
 558  * to preserve hard and symbolic links. Output file remains open, with file
 559  * descriptor returned in outfd.
 560  */
 561 static int
 562 copy_from_tempfile(const char *src, const char *dst, int infd, int *outfd,
 563     int in_place)
 564 {
 565         int tmpfd;
 566
 567         /*
 568          * First, check if we can use rename().
 569          */
 570         if (in_place == 0) {
 571                 if (rename(src, dst) >= 0) {
 572                         *outfd = infd;
 573                         return (0);
 574                 } else if (errno != EXDEV)
 575                         return (-1);
 576
 577                 /*
 578                  * If the rename() failed due to 'src' and 'dst' residing in
 579                  * two different file systems, invoke a helper function in
 580                  * libelftc to do the copy.
 581                  */
 582
 583                 if (unlink(dst) < 0)
 584                         return (-1);
 585         }
 586
 587         if ((tmpfd = open(dst, O_CREAT | O_TRUNC | O_WRONLY, 0755)) < 0)
 588                 return (-1);
 589
 590         if (elftc_copyfile(infd, tmpfd) < 0)
 591                 return (-1);
 592
 593         /*
 594          * Remove the temporary file from the file system
 595          * namespace, and close its file descriptor.
 596          */
 597         if (unlink(src) < 0)
 598                 return (-1);
 599
 600         (void) close(infd);
 601
 602         /*
 603          * Return the file descriptor for the destination.
 604          */
 605         *outfd = tmpfd;
 606
 607         return (0);
 608 }
 609
 610 static void
 611 create_file(struct elfcopy *ecp, const char *src, const char *dst)
 612 {
 613         struct stat      sb;
 614         char            *tempfile, *elftemp;
 615         int              efd, ifd, ofd, ofd0, tfd;
 616         int              in_place;
 617
 618         tempfile = NULL;
 619
 620         if (src == NULL)
 621                 errx(EXIT_FAILURE, "internal: src == NULL");
 622         if ((ifd = open(src, O_RDONLY)) == -1)
 623                 err(EXIT_FAILURE, "open %s failed", src);
 624
 625         if (fstat(ifd, &sb) == -1)
 626                 err(EXIT_FAILURE, "fstat %s failed", src);
 627
 628         if (dst == NULL)
 629                 create_tempfile(&tempfile, &ofd);
 630         else
 631                 if ((ofd = open(dst, O_RDWR|O_CREAT, 0755)) == -1)
 632                         err(EXIT_FAILURE, "open %s failed", dst);
 633
 634 #ifndef LIBELF_AR
 635         /* Detect and process ar(1) archive using libarchive. */
 636         if (ac_detect_ar(ifd)) {
 637                 ac_create_ar(ecp, ifd, ofd);
 638                 goto copy_done;
 639         }
 640 #endif
 641
 642         if (lseek(ifd, 0, SEEK_SET) < 0)
 643                 err(EXIT_FAILURE, "lseek failed");
 644
 645         /*
 646          * If input object is not ELF file, convert it to an intermediate
 647          * ELF object before processing.
 648          */
 649         if (ecp->itf != ETF_ELF) {
 650                 /*
 651                  * If the output object is not an ELF file, choose an arbitrary
 652                  * ELF format for the intermediate file. srec, ihex and binary
 653                  * formats are independent of class, endianness and machine
 654                  * type so these choices do not affect the output.
 655                  */
 656                 if (ecp->otf != ETF_ELF) {
 657                         if (ecp->oec == ELFCLASSNONE)
 658                                 ecp->oec = ELFCLASS64;
 659                         if (ecp->oed == ELFDATANONE)
 660                                 ecp->oed = ELFDATA2LSB;
 661                 }
 662                 create_tempfile(&elftemp, &efd);
 663                 if ((ecp->eout = elf_begin(efd, ELF_C_WRITE, NULL)) == NULL)
 664                         errx(EXIT_FAILURE, "elf_begin() failed: %s",
 665                             elf_errmsg(-1));
 666                 elf_flagelf(ecp->eout, ELF_C_SET, ELF_F_LAYOUT);
 667                 if (ecp->itf == ETF_BINARY)
 668                         create_elf_from_binary(ecp, ifd, src);
 669                 else if (ecp->itf == ETF_IHEX)
 670                         create_elf_from_ihex(ecp, ifd);
 671                 else if (ecp->itf == ETF_SREC)
 672                         create_elf_from_srec(ecp, ifd);
 673                 else
 674                         errx(EXIT_FAILURE, "Internal: invalid target flavour");
 675                 elf_end(ecp->eout);
 676
 677                 /* Open intermediate ELF object as new input object. */
 678                 close(ifd);
 679                 if ((ifd = open(elftemp, O_RDONLY)) == -1)
 680                         err(EXIT_FAILURE, "open %s failed", src);
 681                 close(efd);
 682                 free(elftemp);
 683         }
 684
 685         if ((ecp->ein = elf_begin(ifd, ELF_C_READ, NULL)) == NULL)
 686                 errx(EXIT_FAILURE, "elf_begin() failed: %s",
 687                     elf_errmsg(-1));
 688
 689         switch (elf_kind(ecp->ein)) {
 690         case ELF_K_NONE:
 691                 errx(EXIT_FAILURE, "file format not recognized");
 692         case ELF_K_ELF:
 693                 if ((ecp->eout = elf_begin(ofd, ELF_C_WRITE, NULL)) == NULL)
 694                         errx(EXIT_FAILURE, "elf_begin() failed: %s",
 695                             elf_errmsg(-1));
 696
 697                 /* elfcopy(1) manage ELF layout by itself. */
 698                 elf_flagelf(ecp->eout, ELF_C_SET, ELF_F_LAYOUT);
 699
 700                 /*
 701                  * Create output ELF object.
 702                  */
 703                 create_elf(ecp);
 704                 elf_end(ecp->eout);
 705
 706                 /*
 707                  * Convert the output ELF object to binary/srec/ihex if need.
 708                  */
 709                 if (ecp->otf != ETF_ELF) {
 710                         /*
 711                          * Create (another) tempfile for binary/srec/ihex
 712                          * output object.
 713                          */
 714                         if (tempfile != NULL) {
 715                                 if (unlink(tempfile) < 0)
 716                                         err(EXIT_FAILURE, "unlink %s failed",
 717                                             tempfile);
 718                                 free(tempfile);
 719                         }
 720                         create_tempfile(&tempfile, &ofd0);
 721
 722
 723                         /*
 724                          * Rewind the file descriptor being processed.
 725                          */
 726                         if (lseek(ofd, 0, SEEK_SET) < 0)
 727                                 err(EXIT_FAILURE,
 728                                     "lseek failed for the output object");
 729
 730                         /*
 731                          * Call flavour-specific conversion routine.
 732                          */
 733                         switch (ecp->otf) {
 734                         case ETF_BINARY:
 735                                 create_binary(ofd, ofd0);
 736                                 break;
 737                         case ETF_IHEX:
 738                                 create_ihex(ofd, ofd0);
 739                                 break;
 740                         case ETF_SREC:
 741                                 create_srec(ecp, ofd, ofd0,
 742                                     dst != NULL ? dst : src);
 743                                 break;
 744                         case ETF_PE:
 745                         case ETF_EFI:
 746 #if     WITH_PE
 747                                 create_pe(ecp, ofd, ofd0);
 748 #else
 749                                 errx(EXIT_FAILURE, "PE/EFI support not enabled"
 750                                     " at compile time");
 751 #endif
 752                                 break;
 753                         default:
 754                                 errx(EXIT_FAILURE, "Internal: unsupported"
 755                                     " output flavour %d", ecp->oec);
 756                         }
 757
 758                         close(ofd);
 759                         ofd = ofd0;
 760                 }
 761
 762                 break;
 763
 764         case ELF_K_AR:
 765                 /* XXX: Not yet supported. */
 766                 break;
 767         default:
 768                 errx(EXIT_FAILURE, "file format not supported");
 769         }
 770
 771         elf_end(ecp->ein);
 772
 773 #ifndef LIBELF_AR
 774 copy_done:
 775 #endif
 776
 777         if (tempfile != NULL) {
 778                 in_place = 0;
 779                 if (dst == NULL) {
 780                         dst = src;
 781                         if (lstat(dst, &sb) != -1 &&
 782                             (sb.st_nlink > 1 || S_ISLNK(sb.st_mode)))
 783                                 in_place = 1;
 784                 }
 785
 786                 if (copy_from_tempfile(tempfile, dst, ofd, &tfd, in_place) < 0)
 787                         err(EXIT_FAILURE, "creation of %s failed", dst);
 788
 789                 free(tempfile);
 790                 tempfile = NULL;
 791
 792                 ofd = tfd;
 793         }
 794
 795         if (strcmp(dst, "/dev/null") && fchmod(ofd, sb.st_mode) == -1)
 796                 err(EXIT_FAILURE, "fchmod %s failed", dst);
 797
 798         if ((ecp->flags & PRESERVE_DATE) &&
 799             elftc_set_timestamps(dst, &sb) < 0)
 800                 err(EXIT_FAILURE, "setting timestamps failed");
 801
 802         close(ifd);
 803         close(ofd);
 804 }
 805
 806 static void
 807 elfcopy_main(struct elfcopy *ecp, int argc, char **argv)
 808 {
 809         struct sec_action       *sac;
 810         const char              *infile, *outfile;
 811         char                    *fn, *s;
 812         int                      opt;
 813
 814         while ((opt = getopt_long(argc, argv, "dB:gG:I:j:K:L:N:O:pR:s:SwW:xXV",
 815             elfcopy_longopts, NULL)) != -1) {
 816                 switch(opt) {
 817                 case 'B':
 818                         /* ignored */
 819                         break;
 820                 case 'R':
 821                         sac = lookup_sec_act(ecp, optarg, 1);
 822                         if (sac->copy != 0)
 823                                 errx(EXIT_FAILURE,
 824                                     "both copy and remove specified");
 825                         sac->remove = 1;
 826                         ecp->flags |= SEC_REMOVE;
 827                         break;
 828                 case 'S':
 829                         ecp->strip = STRIP_ALL;
 830                         break;
 831                 case 'g':
 832                         ecp->strip = STRIP_DEBUG;
 833                         break;
 834                 case 'G':
 835                         ecp->flags |= KEEP_GLOBAL;
 836                         add_to_symop_list(ecp, optarg, NULL, SYMOP_KEEPG);
 837                         break;
 838                 case 'I':
 839                 case 's':
 840                         set_input_target(ecp, optarg);
 841                         break;
 842                 case 'j':
 843                         sac = lookup_sec_act(ecp, optarg, 1);
 844                         if (sac->remove != 0)
 845                                 errx(EXIT_FAILURE,
 846                                     "both copy and remove specified");
 847                         sac->copy = 1;
 848                         ecp->flags |= SEC_COPY;
 849                         break;
 850                 case 'K':
 851                         add_to_symop_list(ecp, optarg, NULL, SYMOP_KEEP);
 852                         break;
 853                 case 'L':
 854                         add_to_symop_list(ecp, optarg, NULL, SYMOP_LOCALIZE);
 855                         break;
 856                 case 'N':
 857                         add_to_symop_list(ecp, optarg, NULL, SYMOP_STRIP);
 858                         break;
 859                 case 'O':
 860                         set_output_target(ecp, optarg);
 861                         break;
 862                 case 'p':
 863                         ecp->flags |= PRESERVE_DATE;
 864                         break;
 865                 case 'V':
 866                         print_version();
 867                         break;
 868                 case 'w':
 869                         ecp->flags |= WILDCARD;
 870                         break;
 871                 case 'W':
 872                         add_to_symop_list(ecp, optarg, NULL, SYMOP_WEAKEN);
 873                         break;
 874                 case 'x':
 875                         ecp->flags |= DISCARD_LOCAL;
 876                         break;
 877                 case 'X':
 878                         ecp->flags |= DISCARD_LLABEL;
 879                         break;
 880                 case ECP_ADD_GNU_DEBUGLINK:
 881                         ecp->debuglink = optarg;
 882                         break;
 883                 case ECP_ADD_SECTION:
 884                         add_section(ecp, optarg);
 885                         break;
 886                 case ECP_CHANGE_ADDR:
 887                         ecp->change_addr = (int64_t) strtoll(optarg, NULL, 0);
 888                         break;
 889                 case ECP_CHANGE_SEC_ADDR:
 890                         parse_sec_address_op(ecp, opt, "--change-section-addr",
 891                             optarg);
 892                         break;
 893                 case ECP_CHANGE_SEC_LMA:
 894                         parse_sec_address_op(ecp, opt, "--change-section-lma",
 895                             optarg);
 896                         break;
 897                 case ECP_CHANGE_SEC_VMA:
 898                         parse_sec_address_op(ecp, opt, "--change-section-vma",
 899                             optarg);
 900                         break;
 901                 case ECP_CHANGE_START:
 902                         ecp->change_start = (int64_t) strtoll(optarg, NULL, 0);
 903                         break;
 904                 case ECP_CHANGE_WARN:
 905                         /* default */
 906                         break;
 907                 case ECP_GAP_FILL:
 908                         ecp->fill = (uint8_t) strtoul(optarg, NULL, 0);
 909                         ecp->flags |= GAP_FILL;
 910                         break;
 911                 case ECP_GLOBALIZE_SYMBOL:
 912                         add_to_symop_list(ecp, optarg, NULL, SYMOP_GLOBALIZE);
 913                         break;
 914                 case ECP_GLOBALIZE_SYMBOLS:
 915                         parse_symlist_file(ecp, optarg, SYMOP_GLOBALIZE);
 916                         break;
 917                 case ECP_KEEP_SYMBOLS:
 918                         parse_symlist_file(ecp, optarg, SYMOP_KEEP);
 919                         break;
 920                 case ECP_KEEP_GLOBAL_SYMBOLS:
 921                         parse_symlist_file(ecp, optarg, SYMOP_KEEPG);
 922                         break;
 923                 case ECP_LOCALIZE_HIDDEN:
 924                         ecp->flags |= LOCALIZE_HIDDEN;
 925                         break;
 926                 case ECP_LOCALIZE_SYMBOLS:
 927                         parse_symlist_file(ecp, optarg, SYMOP_LOCALIZE);
 928                         break;
 929                 case ECP_NO_CHANGE_WARN:
 930                         ecp->flags |= NO_CHANGE_WARN;
 931                         break;
 932                 case ECP_ONLY_DEBUG:
 933                         ecp->strip = STRIP_NONDEBUG;
 934                         break;
 935                 case ECP_ONLY_DWO:
 936                         ecp->strip = STRIP_NONDWO;
 937                         break;
 938                 case ECP_PAD_TO:
 939                         ecp->pad_to = (uint64_t) strtoull(optarg, NULL, 0);
 940                         break;
 941                 case ECP_PREFIX_ALLOC:
 942                         ecp->prefix_alloc = optarg;
 943                         break;
 944                 case ECP_PREFIX_SEC:
 945                         ecp->prefix_sec = optarg;
 946                         break;
 947                 case ECP_PREFIX_SYM:
 948                         ecp->prefix_sym = optarg;
 949                         break;
 950                 case ECP_REDEF_SYMBOL:
 951                         if ((s = strchr(optarg, '=')) == NULL)
 952                                 errx(EXIT_FAILURE,
 953                                     "illegal format for --redefine-sym");
 954                         *s++ = '\0';
 955                         add_to_symop_list(ecp, optarg, s, SYMOP_REDEF);
 956                         break;
 957                 case ECP_REDEF_SYMBOLS:
 958                         parse_symlist_file(ecp, optarg, SYMOP_REDEF);
 959                         break;
 960                 case ECP_RENAME_SECTION:
 961                         if ((fn = strchr(optarg, '=')) == NULL)
 962                                 errx(EXIT_FAILURE,
 963                                     "illegal format for --rename-section");
 964                         *fn++ = '\0';
 965
 966                         /* Check for optional flags. */
 967                         if ((s = strchr(fn, ',')) != NULL)
 968                                 *s++ = '\0';
 969
 970                         sac = lookup_sec_act(ecp, optarg, 1);
 971                         sac->rename = 1;
 972                         sac->newname = fn;
 973                         if (s != NULL)
 974                                 parse_sec_flags(sac, s);
 975                         break;
 976                 case ECP_SET_OSABI:
 977                         set_osabi(ecp, optarg);
 978                         break;
 979                 case ECP_SET_SEC_FLAGS:
 980                         if ((s = strchr(optarg, '=')) == NULL)
 981                                 errx(EXIT_FAILURE,
 982                                     "illegal format for --set-section-flags");
 983                         *s++ = '\0';
 984                         sac = lookup_sec_act(ecp, optarg, 1);
 985                         parse_sec_flags(sac, s);
 986                         break;
 987                 case ECP_SET_START:
 988                         ecp->flags |= SET_START;
 989                         ecp->set_start = (uint64_t) strtoull(optarg, NULL, 0);
 990                         break;
 991                 case ECP_SREC_FORCE_S3:
 992                         ecp->flags |= SREC_FORCE_S3;
 993                         break;
 994                 case ECP_SREC_LEN:
 995                         ecp->flags |= SREC_FORCE_LEN;
 996                         ecp->srec_len = strtoul(optarg, NULL, 0);
 997                         break;
 998                 case ECP_STRIP_DWO:
 999                         ecp->strip = STRIP_DWO;
1000                         break;
1001                 case ECP_STRIP_SYMBOLS:
1002                         parse_symlist_file(ecp, optarg, SYMOP_STRIP);
1003                         break;
1004                 case ECP_STRIP_UNNEEDED:
1005                         ecp->strip = STRIP_UNNEEDED;
1006                         break;
1007                 case ECP_WEAKEN_ALL:
1008                         ecp->flags |= WEAKEN_ALL;
1009                         break;
1010                 case ECP_WEAKEN_SYMBOLS:
1011                         parse_symlist_file(ecp, optarg, SYMOP_WEAKEN);
1012                         break;
1013                 default:
1014                         elfcopy_usage();
1015                 }
1016         }
1017
1018         if (optind == argc || optind + 2 < argc)
1019                 elfcopy_usage();
1020
1021         infile = argv[optind];
1022         outfile = NULL;
1023         if (optind + 1 < argc)
1024                 outfile = argv[optind + 1];
1025
1026         create_file(ecp, infile, outfile);
1027 }
1028
1029 static void
1030 mcs_main(struct elfcopy *ecp, int argc, char **argv)
1031 {
1032         struct sec_action       *sac;
1033         const char              *string;
1034         int                      append, delete, compress, name, print;
1035         int                      opt, i;
1036
1037         append = delete = compress = name = print = 0;
1038         string = NULL;
1039         while ((opt = getopt_long(argc, argv, "a:cdhn:pV", mcs_longopts,
1040                 NULL)) != -1) {
1041                 switch(opt) {
1042                 case 'a':
1043                         append = 1;
1044                         string = optarg; /* XXX multiple -a not supported */
1045                         break;
1046                 case 'c':
1047                         compress = 1;
1048                         break;
1049                 case 'd':
1050                         delete = 1;
1051                         break;
1052                 case 'n':
1053                         name = 1;
1054                         (void)lookup_sec_act(ecp, optarg, 1);
1055                         break;
1056                 case 'p':
1057                         print = 1;
1058                         break;
1059                 case 'V':
1060                         print_version();
1061                         break;
1062                 case 'h':
1063                 default:
1064                         mcs_usage();
1065                 }
1066         }
1067
1068         if (optind == argc)
1069                 mcs_usage();
1070
1071         /* Must specify one operation at least. */
1072         if (!append && !compress && !delete && !print)
1073                 mcs_usage();
1074
1075         /*
1076          * If we are going to delete, ignore other operations. This is
1077          * different from the Solaris implementation, which can print
1078          * and delete a section at the same time, for example. Also, this
1079          * implementation do not respect the order between operations that
1080          * user specified, i.e., "mcs -pc a.out" equals to "mcs -cp a.out".
1081          */
1082         if (delete) {
1083                 append = compress = print = 0;
1084                 ecp->flags |= SEC_REMOVE;
1085         }
1086         if (append)
1087                 ecp->flags |= SEC_APPEND;
1088         if (compress)
1089                 ecp->flags |= SEC_COMPRESS;
1090         if (print)
1091                 ecp->flags |= SEC_PRINT;
1092
1093         /* .comment is the default section to operate on. */
1094         if (!name)
1095                 (void)lookup_sec_act(ecp, ".comment", 1);
1096
1097         STAILQ_FOREACH(sac, &ecp->v_sac, sac_list) {
1098                 sac->append = append;
1099                 sac->compress = compress;
1100                 sac->print = print;
1101                 sac->remove = delete;
1102                 sac->string = string;
1103         }
1104
1105         for (i = optind; i < argc; i++) {
1106                 /* If only -p is specified, output to /dev/null */
1107                 if (print && !append && !compress && !delete)
1108                         create_file(ecp, argv[i], "/dev/null");
1109                 else
1110                         create_file(ecp, argv[i], NULL);
1111         }
1112 }
1113
1114 static void
1115 strip_main(struct elfcopy *ecp, int argc, char **argv)
1116 {
1117         struct sec_action       *sac;
1118         const char              *outfile;
1119         int                      opt;
1120         int                      i;
1121
1122         outfile = NULL;
1123         while ((opt = getopt_long(argc, argv, "hI:K:N:o:O:pR:sSdgVxXw",
1124             strip_longopts, NULL)) != -1) {
1125                 switch(opt) {
1126                 case 'R':
1127                         sac = lookup_sec_act(ecp, optarg, 1);
1128                         sac->remove = 1;
1129                         ecp->flags |= SEC_REMOVE;
1130                         break;
1131                 case 's':
1132                         ecp->strip = STRIP_ALL;
1133                         break;
1134                 case 'S':
1135                 case 'g':
1136                 case 'd':
1137                         ecp->strip = STRIP_DEBUG;
1138                         break;
1139                 case 'I':
1140                         /* ignored */
1141                         break;
1142                 case 'K':
1143                         add_to_symop_list(ecp, optarg, NULL, SYMOP_KEEP);
1144                         break;
1145                 case 'N':
1146                         add_to_symop_list(ecp, optarg, NULL, SYMOP_STRIP);
1147                         break;
1148                 case 'o':
1149                         outfile = optarg;
1150                         break;
1151                 case 'O':
1152                         set_output_target(ecp, optarg);
1153                         break;
1154                 case 'p':
1155                         ecp->flags |= PRESERVE_DATE;
1156                         break;
1157                 case 'V':
1158                         print_version();
1159                         break;
1160                 case 'w':
1161                         ecp->flags |= WILDCARD;
1162                         break;
1163                 case 'x':
1164                         ecp->flags |= DISCARD_LOCAL;
1165                         break;
1166                 case 'X':
1167                         ecp->flags |= DISCARD_LLABEL;
1168                         break;
1169                 case ECP_ONLY_DEBUG:
1170                         ecp->strip = STRIP_NONDEBUG;
1171                         break;
1172                 case ECP_STRIP_UNNEEDED:
1173                         ecp->strip = STRIP_UNNEEDED;
1174                         break;
1175                 case 'h':
1176                 default:
1177                         strip_usage();
1178                 }
1179         }
1180
1181         if (ecp->strip == 0 &&
1182             ((ecp->flags & DISCARD_LOCAL) == 0) &&
1183             ((ecp->flags & DISCARD_LLABEL) == 0) &&
1184             lookup_symop_list(ecp, NULL, SYMOP_STRIP) == NULL)
1185                 ecp->strip = STRIP_ALL;
1186         if (optind == argc)
1187                 strip_usage();
1188
1189         for (i = optind; i < argc; i++)
1190                 create_file(ecp, argv[i], outfile);
1191 }
1192
1193 static void
1194 parse_sec_flags(struct sec_action *sac, char *s)
1195 {
1196         const char      *flag;
1197         int              found, i;
1198
1199         for (flag = strtok(s, ","); flag; flag = strtok(NULL, ",")) {
1200                 found = 0;
1201                 for (i = 0; sec_flags[i].name != NULL; i++)
1202                         if (strcasecmp(sec_flags[i].name, flag) == 0) {
1203                                 sac->flags |= sec_flags[i].value;
1204                                 found = 1;
1205                                 break;
1206                         }
1207                 if (!found)
1208                         errx(EXIT_FAILURE, "unrecognized section flag %s",
1209                             flag);
1210         }
1211 }
1212
1213 static void
1214 parse_sec_address_op(struct elfcopy *ecp, int optnum, const char *optname,
1215     char *s)
1216 {
1217         struct sec_action       *sac;
1218         const char              *name;
1219         char                    *v;
1220         char                     op;
1221
1222         name = v = s;
1223         do {
1224                 v++;
1225         } while (*v != '\0' && *v != '=' && *v != '+' && *v != '-');
1226         if (*v == '\0' || *(v + 1) == '\0')
1227                 errx(EXIT_FAILURE, "invalid format for %s", optname);
1228         op = *v;
1229         *v++ = '\0';
1230         sac = lookup_sec_act(ecp, name, 1);
1231         switch (op) {
1232         case '=':
1233                 if (optnum == ECP_CHANGE_SEC_LMA ||
1234                     optnum == ECP_CHANGE_SEC_ADDR) {
1235                         sac->setlma = 1;
1236                         sac->lma = (uint64_t) strtoull(v, NULL, 0);
1237                 }
1238                 if (optnum == ECP_CHANGE_SEC_VMA ||
1239                     optnum == ECP_CHANGE_SEC_ADDR) {
1240                         sac->setvma = 1;
1241                         sac->vma = (uint64_t) strtoull(v, NULL, 0);
1242                 }
1243                 break;
1244         case '+':
1245                 if (optnum == ECP_CHANGE_SEC_LMA ||
1246                     optnum == ECP_CHANGE_SEC_ADDR)
1247                         sac->lma_adjust = (int64_t) strtoll(v, NULL, 0);
1248                 if (optnum == ECP_CHANGE_SEC_VMA ||
1249                     optnum == ECP_CHANGE_SEC_ADDR)
1250                         sac->vma_adjust = (int64_t) strtoll(v, NULL, 0);
1251                 break;
1252         case '-':
1253                 if (optnum == ECP_CHANGE_SEC_LMA ||
1254                     optnum == ECP_CHANGE_SEC_ADDR)
1255                         sac->lma_adjust = (int64_t) -strtoll(v, NULL, 0);
1256                 if (optnum == ECP_CHANGE_SEC_VMA ||
1257                     optnum == ECP_CHANGE_SEC_ADDR)
1258                         sac->vma_adjust = (int64_t) -strtoll(v, NULL, 0);
1259                 break;
1260         default:
1261                 break;
1262         }
1263 }
1264
1265 static void
1266 parse_symlist_file(struct elfcopy *ecp, const char *fn, unsigned int op)
1267 {
1268         struct symfile  *sf;
1269         struct stat      sb;
1270         FILE            *fp;
1271         char            *data, *p, *line, *end, *e, *n;
1272
1273         if (stat(fn, &sb) == -1)
1274                 err(EXIT_FAILURE, "stat %s failed", fn);
1275
1276         /* Check if we already read and processed this file. */
1277         STAILQ_FOREACH(sf, &ecp->v_symfile, symfile_list) {
1278                 if (sf->dev == sb.st_dev && sf->ino == sb.st_ino)
1279                         goto process_symfile;
1280         }
1281
1282         if ((fp = fopen(fn, "r")) == NULL)
1283                 err(EXIT_FAILURE, "can not open %s", fn);
1284         if ((data = malloc(sb.st_size + 1)) == NULL)
1285                 err(EXIT_FAILURE, "malloc failed");
1286         if (fread(data, 1, sb.st_size, fp) == 0 || ferror(fp))
1287                 err(EXIT_FAILURE, "fread failed");
1288         fclose(fp);
1289         data[sb.st_size] = '\0';
1290
1291         if ((sf = calloc(1, sizeof(*sf))) == NULL)
1292                 err(EXIT_FAILURE, "malloc failed");
1293         sf->dev = sb.st_dev;
1294         sf->ino = sb.st_ino;
1295         sf->size = sb.st_size + 1;
1296         sf->data = data;
1297
1298 process_symfile:
1299
1300         /*
1301          * Basically what we do here is to convert EOL to '\0', and remove
1302          * leading and trailing whitespaces for each line.
1303          */
1304
1305         end = sf->data + sf->size;
1306         line = NULL;
1307         for(p = sf->data; p < end; p++) {
1308                 if ((*p == '\t' || *p == ' ') && line == NULL)
1309                         continue;
1310                 if (*p == '\r' || *p == '\n' || *p == '\0') {
1311                         *p = '\0';
1312                         if (line == NULL)
1313                                 continue;
1314
1315                         /* Skip comment. */
1316                         if (*line == '#') {
1317                                 line = NULL;
1318                                 continue;
1319                         }
1320
1321                         e = p - 1;
1322                         while(e != line && (*e == '\t' || *e == ' '))
1323                                 *e-- = '\0';
1324                         if (op != SYMOP_REDEF)
1325                                 add_to_symop_list(ecp, line, NULL, op);
1326                         else {
1327                                 if (strlen(line) < 3)
1328                                         errx(EXIT_FAILURE,
1329                                             "illegal format for"
1330                                             " --redefine-sym");
1331                                 for(n = line + 1; n < e; n++) {
1332                                         if (*n == ' ' || *n == '\t') {
1333                                                 while(*n == ' ' || *n == '\t')
1334                                                         *n++ = '\0';
1335                                                 break;
1336                                         }
1337                                 }
1338                                 if (n >= e)
1339                                         errx(EXIT_FAILURE,
1340                                             "illegal format for"
1341                                             " --redefine-sym");
1342                                 add_to_symop_list(ecp, line, n, op);
1343                         }
1344                         line = NULL;
1345                         continue;
1346                 }
1347
1348                 if (line == NULL)
1349                         line = p;
1350         }
1351 }
1352
1353 static void
1354 set_input_target(struct elfcopy *ecp, const char *target_name)
1355 {
1356         Elftc_Bfd_Target *tgt;
1357
1358         if ((tgt = elftc_bfd_find_target(target_name)) == NULL)
1359                 errx(EXIT_FAILURE, "%s: invalid target name", target_name);
1360         ecp->itf = elftc_bfd_target_flavor(tgt);
1361 }
1362
1363 static void
1364 set_output_target(struct elfcopy *ecp, const char *target_name)
1365 {
1366         Elftc_Bfd_Target *tgt;
1367
1368         if ((tgt = elftc_bfd_find_target(target_name)) == NULL)
1369                 errx(EXIT_FAILURE, "%s: invalid target name", target_name);
1370         ecp->otf = elftc_bfd_target_flavor(tgt);
1371         if (ecp->otf == ETF_ELF) {
1372                 ecp->oec = elftc_bfd_target_class(tgt);
1373                 ecp->oed = elftc_bfd_target_byteorder(tgt);
1374                 ecp->oem = elftc_bfd_target_machine(tgt);
1375         }
1376         if (ecp->otf == ETF_EFI || ecp->otf == ETF_PE)
1377                 ecp->oem = elftc_bfd_target_machine(tgt);
1378
1379         ecp->otgt = target_name;
1380 }
1381
1382 static void
1383 set_osabi(struct elfcopy *ecp, const char *abi)
1384 {
1385         int i, found;
1386
1387         found = 0;
1388         for (i = 0; osabis[i].name != NULL; i++)
1389                 if (strcasecmp(osabis[i].name, abi) == 0) {
1390                         ecp->abi = osabis[i].abi;
1391                         found = 1;
1392                         break;
1393                 }
1394         if (!found)
1395                 errx(EXIT_FAILURE, "unrecognized OSABI %s", abi);
1396 }
1397
1398 #define ELFCOPY_USAGE_MESSAGE   "\
1399 Usage: %s [options] infile [outfile]\n\
1400   Transform object files.\n\n\
1401   Options:\n\
1402   -d | -g | --strip-debug      Remove debugging information from the output.\n\
1403   -j SECTION | --only-section=SECTION\n\
1404                                Copy only the named section to the output.\n\
1405   -p | --preserve-dates        Preserve access and modification times.\n\
1406   -w | --wildcard              Use shell-style patterns to name symbols.\n\
1407   -x | --discard-all           Do not copy non-globals to the output.\n\
1408   -I FORMAT | --input-target=FORMAT\n\
1409                                Specify object format for the input file.\n\
1410   -K SYM | --keep-symbol=SYM   Copy symbol SYM to the output.\n\
1411   -L SYM | --localize-symbol=SYM\n\
1412                                Make symbol SYM local to the output file.\n\
1413   -N SYM | --strip-symbol=SYM  Do not copy symbol SYM to the output.\n\
1414   -O FORMAT | --output-target=FORMAT\n\
1415                                Specify object format for the output file.\n\
1416                                FORMAT should be a target name understood by\n\
1417                                elftc_bfd_find_target(3).\n\
1418   -R NAME | --remove-section=NAME\n\
1419                                Remove the named section.\n\
1420   -S | --strip-all             Remove all symbol and relocation information\n\
1421                                from the output.\n\
1422   -V | --version               Print a version identifier and exit.\n\
1423   -W SYM | --weaken-symbol=SYM Mark symbol SYM as weak in the output.\n\
1424   -X | --discard-locals        Do not copy compiler generated symbols to\n\
1425                                the output.\n\
1426   --add-section NAME=FILE      Add the contents of FILE to the ELF object as\n\
1427                                a new section named NAME.\n\
1428   --adjust-section-vma SECTION{=,+,-}VAL | \\\n\
1429     --change-section-address SECTION{=,+,-}VAL\n\
1430                                Set or adjust the VMA and the LMA of the\n\
1431                                named section by VAL.\n\
1432   --adjust-start=INCR | --change-start=INCR\n\
1433                                Add INCR to the start address for the ELF\n\
1434                                object.\n\
1435   --adjust-vma=INCR | --change-addresses=INCR\n\
1436                                Increase the VMA and LMA of all sections by\n\
1437                                INCR.\n\
1438   --adjust-warning | --change-warnings\n\
1439                                Issue warnings for non-existent sections.\n\
1440   --change-section-lma SECTION{=,+,-}VAL\n\
1441                                Set or adjust the LMA address of the named\n\
1442                                section by VAL.\n\
1443   --change-section-vma SECTION{=,+,-}VAL\n\
1444                                Set or adjust the VMA address of the named\n\
1445                                section by VAL.\n\
1446   --gap-fill=VAL               Fill the gaps between sections with bytes\n\
1447                                of value VAL.\n\
1448   --localize-hidden            Make all hidden symbols local to the output\n\
1449                                file.\n\
1450   --no-adjust-warning| --no-change-warnings\n\
1451                                Do not issue warnings for non-existent\n\
1452                                sections.\n\
1453   --only-keep-debug            Copy only debugging information.\n\
1454   --output-target=FORMAT       Use the specified format for the output.\n\
1455   --pad-to=ADDRESS             Pad the output object up to the given address.\n\
1456   --prefix-alloc-sections=STRING\n\
1457                                Prefix the section names of all the allocated\n\
1458                                sections with STRING.\n\
1459   --prefix-sections=STRING     Prefix the section names of all the sections\n\
1460                                with STRING.\n\
1461   --prefix-symbols=STRING      Prefix the symbol names of all the symbols\n\
1462                                with STRING.\n\
1463   --rename-section OLDNAME=NEWNAME[,FLAGS]\n\
1464                                Rename and optionally change section flags.\n\
1465   --set-section-flags SECTION=FLAGS\n\
1466                                Set section flags for the named section.\n\
1467                                Supported flags are: 'alloc', 'code',\n\
1468                                'contents', 'data', 'debug', 'load',\n\
1469                                'noload', 'readonly', 'rom', and 'shared'.\n\
1470   --set-start=ADDRESS          Set the start address of the ELF object.\n\
1471   --srec-forceS3               Only generate S3 S-Records.\n\
1472   --srec-len=LEN               Set the maximum length of a S-Record line.\n\
1473   --strip-unneeded             Do not copy relocation information.\n"
1474
1475 static void
1476 elfcopy_usage(void)
1477 {
1478         (void) fprintf(stderr, ELFCOPY_USAGE_MESSAGE, ELFTC_GETPROGNAME());
1479         exit(EXIT_FAILURE);
1480 }
1481
1482 #define MCS_USAGE_MESSAGE       "\
1483 Usage: %s [options] file...\n\
1484   Manipulate the comment section in an ELF object.\n\n\
1485   Options:\n\
1486   -a STRING        Append 'STRING' to the comment section.\n\
1487   -c               Remove duplicate entries from the comment section.\n\
1488   -d               Delete the comment section.\n\
1489   -h | --help      Print a help message and exit.\n\
1490   -n NAME          Operate on the ELF section with name 'NAME'.\n\
1491   -p               Print the contents of the comment section.\n\
1492   -V | --version   Print a version identifier and exit.\n"
1493
1494 static void
1495 mcs_usage(void)
1496 {
1497         (void) fprintf(stderr, MCS_USAGE_MESSAGE, ELFTC_GETPROGNAME());
1498         exit(EXIT_FAILURE);
1499 }
1500
1501 #define STRIP_USAGE_MESSAGE     "\
1502 Usage: %s [options] file...\n\
1503   Discard information from ELF objects.\n\n\
1504   Options:\n\
1505   -d | -g | -S | --strip-debug    Remove debugging symbols.\n\
1506   -h | --help                     Print a help message.\n\
1507   -o FILE | --output-file FILE    Write output to FILE.\n\
1508   --only-keep-debug               Keep debugging information only.\n\
1509   -p | --preserve-dates           Preserve access and modification times.\n\
1510   -s | --strip-all                Remove all symbols.\n\
1511   --strip-unneeded                Remove symbols not needed for relocation\n\
1512                                   processing.\n\
1513   -w | --wildcard                 Use shell-style patterns to name symbols.\n\
1514   -x | --discard-all              Discard all non-global symbols.\n\
1515   -I TGT| --input-target=TGT      (Accepted, but ignored).\n\
1516   -K SYM | --keep-symbol=SYM      Keep symbol 'SYM' in the output.\n\
1517   -N SYM | --strip-symbol=SYM     Remove symbol 'SYM' from the output.\n\
1518   -O TGT | --output-target=TGT    Set the output file format to 'TGT'.\n\
1519   -R SEC | --remove-section=SEC   Remove the section named 'SEC'.\n\
1520   -V | --version                  Print a version identifier and exit.\n\
1521   -X | --discard-locals           Remove compiler-generated local symbols.\n"
1522
1523 static void
1524 strip_usage(void)
1525 {
1526         (void) fprintf(stderr, STRIP_USAGE_MESSAGE, ELFTC_GETPROGNAME());
1527         exit(EXIT_FAILURE);
1528 }
1529
1530 static void
1531 print_version(void)
1532 {
1533         (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version());
1534         exit(EXIT_SUCCESS);
1535 }
1536
1537 int
1538 main(int argc, char **argv)
1539 {
1540         struct elfcopy *ecp;
1541
1542         if (elf_version(EV_CURRENT) == EV_NONE)
1543                 errx(EXIT_FAILURE, "ELF library initialization failed: %s",
1544                     elf_errmsg(-1));
1545
1546         ecp = calloc(1, sizeof(*ecp));
1547         if (ecp == NULL)
1548                 err(EXIT_FAILURE, "calloc failed");
1549         memset(ecp, 0, sizeof(*ecp));
1550
1551         ecp->itf = ecp->otf = ETF_ELF;
1552         ecp->iec = ecp->oec = ELFCLASSNONE;
1553         ecp->oed = ELFDATANONE;
1554         ecp->abi = -1;
1555         /* There is always an empty section. */
1556         ecp->nos = 1;
1557         ecp->fill = 0;
1558
1559         STAILQ_INIT(&ecp->v_seg);
1560         STAILQ_INIT(&ecp->v_sac);
1561         STAILQ_INIT(&ecp->v_sadd);
1562         STAILQ_INIT(&ecp->v_symop);
1563         STAILQ_INIT(&ecp->v_symfile);
1564         STAILQ_INIT(&ecp->v_arobj);
1565         TAILQ_INIT(&ecp->v_sec);
1566
1567         if ((ecp->progname = ELFTC_GETPROGNAME()) == NULL)
1568                 ecp->progname = "elfcopy";
1569
1570         if (strcmp(ecp->progname, "strip") == 0)
1571                 strip_main(ecp, argc, argv);
1572         else if (strcmp(ecp->progname, "mcs") == 0)
1573                 mcs_main(ecp, argc, argv);
1574         else
1575                 elfcopy_main(ecp, argc, argv);
1576
1577         free_sec_add(ecp);
1578         free_sec_act(ecp);
1579         free(ecp);
1580
1581         exit(EXIT_SUCCESS);
1582 }