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