1/* objcopy.c -- copy object file from input to output, optionally massaging it. 2 Copyright (C) 1991-2017 Free Software Foundation, Inc. 3 4 This file is part of GNU Binutils. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21#include "sysdep.h" 22#include "bfd.h" 23#include "progress.h" 24#include "getopt.h" 25#include "libiberty.h" 26#include "bucomm.h" 27#include "budbg.h" 28#include "filenames.h" 29#include "fnmatch.h" 30#include "elf-bfd.h" 31#include "coff/internal.h" 32#include "libcoff.h" 33 34/* FIXME: See bfd/peXXigen.c for why we include an architecture specific 35 header in generic PE code. */ 36#include "coff/i386.h" 37#include "coff/pe.h" 38 39static bfd_vma pe_file_alignment = (bfd_vma) -1; 40static bfd_vma pe_heap_commit = (bfd_vma) -1; 41static bfd_vma pe_heap_reserve = (bfd_vma) -1; 42static bfd_vma pe_image_base = (bfd_vma) -1; 43static bfd_vma pe_section_alignment = (bfd_vma) -1; 44static bfd_vma pe_stack_commit = (bfd_vma) -1; 45static bfd_vma pe_stack_reserve = (bfd_vma) -1; 46static short pe_subsystem = -1; 47static short pe_major_subsystem_version = -1; 48static short pe_minor_subsystem_version = -1; 49 50struct is_specified_symbol_predicate_data 51{ 52 const char * name; 53 bfd_boolean found; 54}; 55 56/* A list to support redefine_sym. */ 57struct redefine_node 58{ 59 char *source; 60 char *target; 61 struct redefine_node *next; 62}; 63 64struct addsym_node 65{ 66 struct addsym_node *next; 67 char * symdef; 68 long symval; 69 flagword flags; 70 char * section; 71 char * othersym; 72}; 73 74typedef struct section_rename 75{ 76 const char * old_name; 77 const char * new_name; 78 flagword flags; 79 struct section_rename * next; 80} 81section_rename; 82 83/* List of sections to be renamed. */ 84static section_rename *section_rename_list; 85 86static asymbol **isympp = NULL; /* Input symbols. */ 87static asymbol **osympp = NULL; /* Output symbols that survive stripping. */ 88 89/* If `copy_byte' >= 0, copy 'copy_width' byte(s) of every `interleave' bytes. */ 90static int copy_byte = -1; 91static int interleave = 0; /* Initialised to 4 in copy_main(). */ 92static int copy_width = 1; 93 94static bfd_boolean verbose; /* Print file and target names. */ 95static bfd_boolean preserve_dates; /* Preserve input file timestamp. */ 96static int deterministic = -1; /* Enable deterministic archives. */ 97static int status = 0; /* Exit status. */ 98 99enum strip_action 100{ 101 STRIP_UNDEF, 102 STRIP_NONE, /* Don't strip. */ 103 STRIP_DEBUG, /* Strip all debugger symbols. */ 104 STRIP_UNNEEDED, /* Strip unnecessary symbols. */ 105 STRIP_NONDEBUG, /* Strip everything but debug info. */ 106 STRIP_DWO, /* Strip all DWO info. */ 107 STRIP_NONDWO, /* Strip everything but DWO info. */ 108 STRIP_ALL /* Strip all symbols. */ 109}; 110 111/* Which symbols to remove. */ 112static enum strip_action strip_symbols = STRIP_UNDEF; 113 114enum locals_action 115{ 116 LOCALS_UNDEF, 117 LOCALS_START_L, /* Discard locals starting with L. */ 118 LOCALS_ALL /* Discard all locals. */ 119}; 120 121/* Which local symbols to remove. Overrides STRIP_ALL. */ 122static enum locals_action discard_locals; 123 124/* Structure used to hold lists of sections and actions to take. */ 125struct section_list 126{ 127 struct section_list * next; /* Next section to change. */ 128 const char * pattern; /* Section name pattern. */ 129 bfd_boolean used; /* Whether this entry was used. */ 130 131 unsigned int context; /* What to do with matching sections. */ 132 /* Flag bits used in the context field. 133 COPY and REMOVE are mutually exlusive. SET and ALTER are mutually exclusive. */ 134#define SECTION_CONTEXT_REMOVE (1 << 0) /* Remove this section. */ 135#define SECTION_CONTEXT_COPY (1 << 1) /* Copy this section, delete all non-copied section. */ 136#define SECTION_CONTEXT_SET_VMA (1 << 2) /* Set the sections' VMA address. */ 137#define SECTION_CONTEXT_ALTER_VMA (1 << 3) /* Increment or decrement the section's VMA address. */ 138#define SECTION_CONTEXT_SET_LMA (1 << 4) /* Set the sections' LMA address. */ 139#define SECTION_CONTEXT_ALTER_LMA (1 << 5) /* Increment or decrement the section's LMA address. */ 140#define SECTION_CONTEXT_SET_FLAGS (1 << 6) /* Set the section's flags. */ 141#define SECTION_CONTEXT_REMOVE_RELOCS (1 << 7) /* Remove relocations for this section. */ 142 143 bfd_vma vma_val; /* Amount to change by or set to. */ 144 bfd_vma lma_val; /* Amount to change by or set to. */ 145 flagword flags; /* What to set the section flags to. */ 146}; 147 148static struct section_list *change_sections; 149 150/* TRUE if some sections are to be removed. */ 151static bfd_boolean sections_removed; 152 153/* TRUE if only some sections are to be copied. */ 154static bfd_boolean sections_copied; 155 156/* Changes to the start address. */ 157static bfd_vma change_start = 0; 158static bfd_boolean set_start_set = FALSE; 159static bfd_vma set_start; 160 161/* Changes to section addresses. */ 162static bfd_vma change_section_address = 0; 163 164/* Filling gaps between sections. */ 165static bfd_boolean gap_fill_set = FALSE; 166static bfd_byte gap_fill = 0; 167 168/* Pad to a given address. */ 169static bfd_boolean pad_to_set = FALSE; 170static bfd_vma pad_to; 171 172/* Use alternative machine code? */ 173static unsigned long use_alt_mach_code = 0; 174 175/* Output BFD flags user wants to set or clear */ 176static flagword bfd_flags_to_set; 177static flagword bfd_flags_to_clear; 178 179/* List of sections to add. */ 180struct section_add 181{ 182 /* Next section to add. */ 183 struct section_add *next; 184 /* Name of section to add. */ 185 const char *name; 186 /* Name of file holding section contents. */ 187 const char *filename; 188 /* Size of file. */ 189 size_t size; 190 /* Contents of file. */ 191 bfd_byte *contents; 192 /* BFD section, after it has been added. */ 193 asection *section; 194}; 195 196/* List of sections to add to the output BFD. */ 197static struct section_add *add_sections; 198 199/* List of sections to update in the output BFD. */ 200static struct section_add *update_sections; 201 202/* List of sections to dump from the output BFD. */ 203static struct section_add *dump_sections; 204 205/* If non-NULL the argument to --add-gnu-debuglink. 206 This should be the filename to store in the .gnu_debuglink section. */ 207static const char * gnu_debuglink_filename = NULL; 208 209/* Whether to convert debugging information. */ 210static bfd_boolean convert_debugging = FALSE; 211 212/* Whether to compress/decompress DWARF debug sections. */ 213static enum 214{ 215 nothing = 0, 216 compress = 1 << 0, 217 compress_zlib = compress | 1 << 1, 218 compress_gnu_zlib = compress | 1 << 2, 219 compress_gabi_zlib = compress | 1 << 3, 220 decompress = 1 << 4 221} do_debug_sections = nothing; 222 223/* Whether to generate ELF common symbols with the STT_COMMON type. */ 224static enum bfd_link_elf_stt_common do_elf_stt_common = unchanged; 225 226/* Whether to change the leading character in symbol names. */ 227static bfd_boolean change_leading_char = FALSE; 228 229/* Whether to remove the leading character from global symbol names. */ 230static bfd_boolean remove_leading_char = FALSE; 231 232/* Whether to permit wildcard in symbol comparison. */ 233static bfd_boolean wildcard = FALSE; 234 235/* True if --localize-hidden is in effect. */ 236static bfd_boolean localize_hidden = FALSE; 237 238/* List of symbols to strip, keep, localize, keep-global, weaken, 239 or redefine. */ 240static htab_t strip_specific_htab = NULL; 241static htab_t strip_unneeded_htab = NULL; 242static htab_t keep_specific_htab = NULL; 243static htab_t localize_specific_htab = NULL; 244static htab_t globalize_specific_htab = NULL; 245static htab_t keepglobal_specific_htab = NULL; 246static htab_t weaken_specific_htab = NULL; 247static struct redefine_node *redefine_sym_list = NULL; 248static struct addsym_node *add_sym_list = NULL, **add_sym_tail = &add_sym_list; 249static int add_symbols = 0; 250 251/* If this is TRUE, we weaken global symbols (set BSF_WEAK). */ 252static bfd_boolean weaken = FALSE; 253 254/* If this is TRUE, we retain BSF_FILE symbols. */ 255static bfd_boolean keep_file_symbols = FALSE; 256 257/* Prefix symbols/sections. */ 258static char *prefix_symbols_string = 0; 259static char *prefix_sections_string = 0; 260static char *prefix_alloc_sections_string = 0; 261 262/* True if --extract-symbol was passed on the command line. */ 263static bfd_boolean extract_symbol = FALSE; 264 265/* If `reverse_bytes' is nonzero, then reverse the order of every chunk 266 of <reverse_bytes> bytes within each output section. */ 267static int reverse_bytes = 0; 268 269/* For Coff objects, we may want to allow or disallow long section names, 270 or preserve them where found in the inputs. Debug info relies on them. */ 271enum long_section_name_handling 272{ 273 DISABLE, 274 ENABLE, 275 KEEP 276}; 277 278/* The default long section handling mode is to preserve them. 279 This is also the only behaviour for 'strip'. */ 280static enum long_section_name_handling long_section_names = KEEP; 281 282/* 150 isn't special; it's just an arbitrary non-ASCII char value. */ 283enum command_line_switch 284{ 285 OPTION_ADD_SECTION=150, 286 OPTION_ADD_GNU_DEBUGLINK, 287 OPTION_ADD_SYMBOL, 288 OPTION_ALT_MACH_CODE, 289 OPTION_CHANGE_ADDRESSES, 290 OPTION_CHANGE_LEADING_CHAR, 291 OPTION_CHANGE_SECTION_ADDRESS, 292 OPTION_CHANGE_SECTION_LMA, 293 OPTION_CHANGE_SECTION_VMA, 294 OPTION_CHANGE_START, 295 OPTION_CHANGE_WARNINGS, 296 OPTION_COMPRESS_DEBUG_SECTIONS, 297 OPTION_DEBUGGING, 298 OPTION_DECOMPRESS_DEBUG_SECTIONS, 299 OPTION_DUMP_SECTION, 300 OPTION_ELF_STT_COMMON, 301 OPTION_EXTRACT_DWO, 302 OPTION_EXTRACT_SYMBOL, 303 OPTION_FILE_ALIGNMENT, 304 OPTION_FORMATS_INFO, 305 OPTION_GAP_FILL, 306 OPTION_GLOBALIZE_SYMBOL, 307 OPTION_GLOBALIZE_SYMBOLS, 308 OPTION_HEAP, 309 OPTION_IMAGE_BASE, 310 OPTION_IMPURE, 311 OPTION_INTERLEAVE_WIDTH, 312 OPTION_KEEPGLOBAL_SYMBOLS, 313 OPTION_KEEP_FILE_SYMBOLS, 314 OPTION_KEEP_SYMBOLS, 315 OPTION_LOCALIZE_HIDDEN, 316 OPTION_LOCALIZE_SYMBOLS, 317 OPTION_LONG_SECTION_NAMES, 318 OPTION_NO_CHANGE_WARNINGS, 319 OPTION_ONLY_KEEP_DEBUG, 320 OPTION_PAD_TO, 321 OPTION_PREFIX_ALLOC_SECTIONS, 322 OPTION_PREFIX_SECTIONS, 323 OPTION_PREFIX_SYMBOLS, 324 OPTION_PURE, 325 OPTION_READONLY_TEXT, 326 OPTION_REDEFINE_SYM, 327 OPTION_REDEFINE_SYMS, 328 OPTION_REMOVE_LEADING_CHAR, 329 OPTION_REMOVE_RELOCS, 330 OPTION_RENAME_SECTION, 331 OPTION_REVERSE_BYTES, 332 OPTION_SECTION_ALIGNMENT, 333 OPTION_SET_SECTION_FLAGS, 334 OPTION_SET_START, 335 OPTION_SREC_FORCES3, 336 OPTION_SREC_LEN, 337 OPTION_STACK, 338 OPTION_STRIP_DWO, 339 OPTION_STRIP_SYMBOLS, 340 OPTION_STRIP_UNNEEDED, 341 OPTION_STRIP_UNNEEDED_SYMBOL, 342 OPTION_STRIP_UNNEEDED_SYMBOLS, 343 OPTION_SUBSYSTEM, 344 OPTION_UPDATE_SECTION, 345 OPTION_WEAKEN, 346 OPTION_WEAKEN_SYMBOLS, 347 OPTION_WRITABLE_TEXT 348}; 349 350/* Options to handle if running as "strip". */ 351 352static struct option strip_options[] = 353{ 354 {"disable-deterministic-archives", no_argument, 0, 'U'}, 355 {"discard-all", no_argument, 0, 'x'}, 356 {"discard-locals", no_argument, 0, 'X'}, 357 {"enable-deterministic-archives", no_argument, 0, 'D'}, 358 {"format", required_argument, 0, 'F'}, /* Obsolete */ 359 {"help", no_argument, 0, 'h'}, 360 {"info", no_argument, 0, OPTION_FORMATS_INFO}, 361 {"input-format", required_argument, 0, 'I'}, /* Obsolete */ 362 {"input-target", required_argument, 0, 'I'}, 363 {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS}, 364 {"keep-symbol", required_argument, 0, 'K'}, 365 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG}, 366 {"output-file", required_argument, 0, 'o'}, 367 {"output-format", required_argument, 0, 'O'}, /* Obsolete */ 368 {"output-target", required_argument, 0, 'O'}, 369 {"preserve-dates", no_argument, 0, 'p'}, 370 {"remove-section", required_argument, 0, 'R'}, 371 {"remove-relocations", required_argument, 0, OPTION_REMOVE_RELOCS}, 372 {"strip-all", no_argument, 0, 's'}, 373 {"strip-debug", no_argument, 0, 'S'}, 374 {"strip-dwo", no_argument, 0, OPTION_STRIP_DWO}, 375 {"strip-symbol", required_argument, 0, 'N'}, 376 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED}, 377 {"target", required_argument, 0, 'F'}, 378 {"verbose", no_argument, 0, 'v'}, 379 {"version", no_argument, 0, 'V'}, 380 {"wildcard", no_argument, 0, 'w'}, 381 {0, no_argument, 0, 0} 382}; 383 384/* Options to handle if running as "objcopy". */ 385 386static struct option copy_options[] = 387{ 388 {"add-gnu-debuglink", required_argument, 0, OPTION_ADD_GNU_DEBUGLINK}, 389 {"add-section", required_argument, 0, OPTION_ADD_SECTION}, 390 {"add-symbol", required_argument, 0, OPTION_ADD_SYMBOL}, 391 {"adjust-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS}, 392 {"adjust-start", required_argument, 0, OPTION_CHANGE_START}, 393 {"adjust-vma", required_argument, 0, OPTION_CHANGE_ADDRESSES}, 394 {"adjust-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS}, 395 {"alt-machine-code", required_argument, 0, OPTION_ALT_MACH_CODE}, 396 {"binary-architecture", required_argument, 0, 'B'}, 397 {"byte", required_argument, 0, 'b'}, 398 {"change-addresses", required_argument, 0, OPTION_CHANGE_ADDRESSES}, 399 {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR}, 400 {"change-section-address", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS}, 401 {"change-section-lma", required_argument, 0, OPTION_CHANGE_SECTION_LMA}, 402 {"change-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_VMA}, 403 {"change-start", required_argument, 0, OPTION_CHANGE_START}, 404 {"change-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS}, 405 {"compress-debug-sections", optional_argument, 0, OPTION_COMPRESS_DEBUG_SECTIONS}, 406 {"debugging", no_argument, 0, OPTION_DEBUGGING}, 407 {"decompress-debug-sections", no_argument, 0, OPTION_DECOMPRESS_DEBUG_SECTIONS}, 408 {"disable-deterministic-archives", no_argument, 0, 'U'}, 409 {"discard-all", no_argument, 0, 'x'}, 410 {"discard-locals", no_argument, 0, 'X'}, 411 {"dump-section", required_argument, 0, OPTION_DUMP_SECTION}, 412 {"elf-stt-common", required_argument, 0, OPTION_ELF_STT_COMMON}, 413 {"enable-deterministic-archives", no_argument, 0, 'D'}, 414 {"extract-dwo", no_argument, 0, OPTION_EXTRACT_DWO}, 415 {"extract-symbol", no_argument, 0, OPTION_EXTRACT_SYMBOL}, 416 {"file-alignment", required_argument, 0, OPTION_FILE_ALIGNMENT}, 417 {"format", required_argument, 0, 'F'}, /* Obsolete */ 418 {"gap-fill", required_argument, 0, OPTION_GAP_FILL}, 419 {"globalize-symbol", required_argument, 0, OPTION_GLOBALIZE_SYMBOL}, 420 {"globalize-symbols", required_argument, 0, OPTION_GLOBALIZE_SYMBOLS}, 421 {"heap", required_argument, 0, OPTION_HEAP}, 422 {"help", no_argument, 0, 'h'}, 423 {"image-base", required_argument, 0 , OPTION_IMAGE_BASE}, 424 {"impure", no_argument, 0, OPTION_IMPURE}, 425 {"info", no_argument, 0, OPTION_FORMATS_INFO}, 426 {"input-format", required_argument, 0, 'I'}, /* Obsolete */ 427 {"input-target", required_argument, 0, 'I'}, 428 {"interleave", optional_argument, 0, 'i'}, 429 {"interleave-width", required_argument, 0, OPTION_INTERLEAVE_WIDTH}, 430 {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS}, 431 {"keep-global-symbol", required_argument, 0, 'G'}, 432 {"keep-global-symbols", required_argument, 0, OPTION_KEEPGLOBAL_SYMBOLS}, 433 {"keep-symbol", required_argument, 0, 'K'}, 434 {"keep-symbols", required_argument, 0, OPTION_KEEP_SYMBOLS}, 435 {"localize-hidden", no_argument, 0, OPTION_LOCALIZE_HIDDEN}, 436 {"localize-symbol", required_argument, 0, 'L'}, 437 {"localize-symbols", required_argument, 0, OPTION_LOCALIZE_SYMBOLS}, 438 {"long-section-names", required_argument, 0, OPTION_LONG_SECTION_NAMES}, 439 {"no-adjust-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS}, 440 {"no-change-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS}, 441 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG}, 442 {"only-section", required_argument, 0, 'j'}, 443 {"output-format", required_argument, 0, 'O'}, /* Obsolete */ 444 {"output-target", required_argument, 0, 'O'}, 445 {"pad-to", required_argument, 0, OPTION_PAD_TO}, 446 {"prefix-alloc-sections", required_argument, 0, OPTION_PREFIX_ALLOC_SECTIONS}, 447 {"prefix-sections", required_argument, 0, OPTION_PREFIX_SECTIONS}, 448 {"prefix-symbols", required_argument, 0, OPTION_PREFIX_SYMBOLS}, 449 {"preserve-dates", no_argument, 0, 'p'}, 450 {"pure", no_argument, 0, OPTION_PURE}, 451 {"readonly-text", no_argument, 0, OPTION_READONLY_TEXT}, 452 {"redefine-sym", required_argument, 0, OPTION_REDEFINE_SYM}, 453 {"redefine-syms", required_argument, 0, OPTION_REDEFINE_SYMS}, 454 {"remove-leading-char", no_argument, 0, OPTION_REMOVE_LEADING_CHAR}, 455 {"remove-section", required_argument, 0, 'R'}, 456 {"remove-relocations", required_argument, 0, OPTION_REMOVE_RELOCS}, 457 {"rename-section", required_argument, 0, OPTION_RENAME_SECTION}, 458 {"reverse-bytes", required_argument, 0, OPTION_REVERSE_BYTES}, 459 {"section-alignment", required_argument, 0, OPTION_SECTION_ALIGNMENT}, 460 {"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS}, 461 {"set-start", required_argument, 0, OPTION_SET_START}, 462 {"srec-forceS3", no_argument, 0, OPTION_SREC_FORCES3}, 463 {"srec-len", required_argument, 0, OPTION_SREC_LEN}, 464 {"stack", required_argument, 0, OPTION_STACK}, 465 {"strip-all", no_argument, 0, 'S'}, 466 {"strip-debug", no_argument, 0, 'g'}, 467 {"strip-dwo", no_argument, 0, OPTION_STRIP_DWO}, 468 {"strip-symbol", required_argument, 0, 'N'}, 469 {"strip-symbols", required_argument, 0, OPTION_STRIP_SYMBOLS}, 470 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED}, 471 {"strip-unneeded-symbol", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOL}, 472 {"strip-unneeded-symbols", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOLS}, 473 {"subsystem", required_argument, 0, OPTION_SUBSYSTEM}, 474 {"target", required_argument, 0, 'F'}, 475 {"update-section", required_argument, 0, OPTION_UPDATE_SECTION}, 476 {"verbose", no_argument, 0, 'v'}, 477 {"version", no_argument, 0, 'V'}, 478 {"weaken", no_argument, 0, OPTION_WEAKEN}, 479 {"weaken-symbol", required_argument, 0, 'W'}, 480 {"weaken-symbols", required_argument, 0, OPTION_WEAKEN_SYMBOLS}, 481 {"wildcard", no_argument, 0, 'w'}, 482 {"writable-text", no_argument, 0, OPTION_WRITABLE_TEXT}, 483 {0, no_argument, 0, 0} 484}; 485 486/* IMPORTS */ 487extern char *program_name; 488 489/* This flag distinguishes between strip and objcopy: 490 1 means this is 'strip'; 0 means this is 'objcopy'. 491 -1 means if we should use argv[0] to decide. */ 492extern int is_strip; 493 494/* The maximum length of an S record. This variable is declared in srec.c 495 and can be modified by the --srec-len parameter. */ 496extern unsigned int Chunk; 497 498/* Restrict the generation of Srecords to type S3 only. 499 This variable is declare in bfd/srec.c and can be toggled 500 on by the --srec-forceS3 command line switch. */ 501extern bfd_boolean S3Forced; 502 503/* Forward declarations. */ 504static void setup_section (bfd *, asection *, void *); 505static void setup_bfd_headers (bfd *, bfd *); 506static void copy_relocations_in_section (bfd *, asection *, void *); 507static void copy_section (bfd *, asection *, void *); 508static void get_sections (bfd *, asection *, void *); 509static int compare_section_lma (const void *, const void *); 510static void mark_symbols_used_in_relocations (bfd *, asection *, void *); 511static bfd_boolean write_debugging_info (bfd *, void *, long *, asymbol ***); 512static const char *lookup_sym_redefinition (const char *); 513static const char *find_section_rename (const char *, flagword *); 514 515ATTRIBUTE_NORETURN static void 516copy_usage (FILE *stream, int exit_status) 517{ 518 fprintf (stream, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name); 519 fprintf (stream, _(" Copies a binary file, possibly transforming it in the process\n")); 520 fprintf (stream, _(" The options are:\n")); 521 fprintf (stream, _("\ 522 -I --input-target <bfdname> Assume input file is in format <bfdname>\n\ 523 -O --output-target <bfdname> Create an output file in format <bfdname>\n\ 524 -B --binary-architecture <arch> Set output arch, when input is arch-less\n\ 525 -F --target <bfdname> Set both input and output format to <bfdname>\n\ 526 --debugging Convert debugging information, if possible\n\ 527 -p --preserve-dates Copy modified/access timestamps to the output\n")); 528 if (DEFAULT_AR_DETERMINISTIC) 529 fprintf (stream, _("\ 530 -D --enable-deterministic-archives\n\ 531 Produce deterministic output when stripping archives (default)\n\ 532 -U --disable-deterministic-archives\n\ 533 Disable -D behavior\n")); 534 else 535 fprintf (stream, _("\ 536 -D --enable-deterministic-archives\n\ 537 Produce deterministic output when stripping archives\n\ 538 -U --disable-deterministic-archives\n\ 539 Disable -D behavior (default)\n")); 540 fprintf (stream, _("\ 541 -j --only-section <name> Only copy section <name> into the output\n\ 542 --add-gnu-debuglink=<file> Add section .gnu_debuglink linking to <file>\n\ 543 -R --remove-section <name> Remove section <name> from the output\n\ 544 --remove-relocations <name> Remove relocations from section <name>\n\ 545 -S --strip-all Remove all symbol and relocation information\n\ 546 -g --strip-debug Remove all debugging symbols & sections\n\ 547 --strip-dwo Remove all DWO sections\n\ 548 --strip-unneeded Remove all symbols not needed by relocations\n\ 549 -N --strip-symbol <name> Do not copy symbol <name>\n\ 550 --strip-unneeded-symbol <name>\n\ 551 Do not copy symbol <name> unless needed by\n\ 552 relocations\n\ 553 --only-keep-debug Strip everything but the debug information\n\ 554 --extract-dwo Copy only DWO sections\n\ 555 --extract-symbol Remove section contents but keep symbols\n\ 556 -K --keep-symbol <name> Do not strip symbol <name>\n\ 557 --keep-file-symbols Do not strip file symbol(s)\n\ 558 --localize-hidden Turn all ELF hidden symbols into locals\n\ 559 -L --localize-symbol <name> Force symbol <name> to be marked as a local\n\ 560 --globalize-symbol <name> Force symbol <name> to be marked as a global\n\ 561 -G --keep-global-symbol <name> Localize all symbols except <name>\n\ 562 -W --weaken-symbol <name> Force symbol <name> to be marked as a weak\n\ 563 --weaken Force all global symbols to be marked as weak\n\ 564 -w --wildcard Permit wildcard in symbol comparison\n\ 565 -x --discard-all Remove all non-global symbols\n\ 566 -X --discard-locals Remove any compiler-generated symbols\n\ 567 -i --interleave[=<number>] Only copy N out of every <number> bytes\n\ 568 --interleave-width <number> Set N for --interleave\n\ 569 -b --byte <num> Select byte <num> in every interleaved block\n\ 570 --gap-fill <val> Fill gaps between sections with <val>\n\ 571 --pad-to <addr> Pad the last section up to address <addr>\n\ 572 --set-start <addr> Set the start address to <addr>\n\ 573 {--change-start|--adjust-start} <incr>\n\ 574 Add <incr> to the start address\n\ 575 {--change-addresses|--adjust-vma} <incr>\n\ 576 Add <incr> to LMA, VMA and start addresses\n\ 577 {--change-section-address|--adjust-section-vma} <name>{=|+|-}<val>\n\ 578 Change LMA and VMA of section <name> by <val>\n\ 579 --change-section-lma <name>{=|+|-}<val>\n\ 580 Change the LMA of section <name> by <val>\n\ 581 --change-section-vma <name>{=|+|-}<val>\n\ 582 Change the VMA of section <name> by <val>\n\ 583 {--[no-]change-warnings|--[no-]adjust-warnings}\n\ 584 Warn if a named section does not exist\n\ 585 --set-section-flags <name>=<flags>\n\ 586 Set section <name>'s properties to <flags>\n\ 587 --add-section <name>=<file> Add section <name> found in <file> to output\n\ 588 --update-section <name>=<file>\n\ 589 Update contents of section <name> with\n\ 590 contents found in <file>\n\ 591 --dump-section <name>=<file> Dump the contents of section <name> into <file>\n\ 592 --rename-section <old>=<new>[,<flags>] Rename section <old> to <new>\n\ 593 --long-section-names {enable|disable|keep}\n\ 594 Handle long section names in Coff objects.\n\ 595 --change-leading-char Force output format's leading character style\n\ 596 --remove-leading-char Remove leading character from global symbols\n\ 597 --reverse-bytes=<num> Reverse <num> bytes at a time, in output sections with content\n\ 598 --redefine-sym <old>=<new> Redefine symbol name <old> to <new>\n\ 599 --redefine-syms <file> --redefine-sym for all symbol pairs \n\ 600 listed in <file>\n\ 601 --srec-len <number> Restrict the length of generated Srecords\n\ 602 --srec-forceS3 Restrict the type of generated Srecords to S3\n\ 603 --strip-symbols <file> -N for all symbols listed in <file>\n\ 604 --strip-unneeded-symbols <file>\n\ 605 --strip-unneeded-symbol for all symbols listed\n\ 606 in <file>\n\ 607 --keep-symbols <file> -K for all symbols listed in <file>\n\ 608 --localize-symbols <file> -L for all symbols listed in <file>\n\ 609 --globalize-symbols <file> --globalize-symbol for all in <file>\n\ 610 --keep-global-symbols <file> -G for all symbols listed in <file>\n\ 611 --weaken-symbols <file> -W for all symbols listed in <file>\n\ 612 --add-symbol <name>=[<section>:]<value>[,<flags>] Add a symbol\n\ 613 --alt-machine-code <index> Use the target's <index>'th alternative machine\n\ 614 --writable-text Mark the output text as writable\n\ 615 --readonly-text Make the output text write protected\n\ 616 --pure Mark the output file as demand paged\n\ 617 --impure Mark the output file as impure\n\ 618 --prefix-symbols <prefix> Add <prefix> to start of every symbol name\n\ 619 --prefix-sections <prefix> Add <prefix> to start of every section name\n\ 620 --prefix-alloc-sections <prefix>\n\ 621 Add <prefix> to start of every allocatable\n\ 622 section name\n\ 623 --file-alignment <num> Set PE file alignment to <num>\n\ 624 --heap <reserve>[,<commit>] Set PE reserve/commit heap to <reserve>/\n\ 625 <commit>\n\ 626 --image-base <address> Set PE image base to <address>\n\ 627 --section-alignment <num> Set PE section alignment to <num>\n\ 628 --stack <reserve>[,<commit>] Set PE reserve/commit stack to <reserve>/\n\ 629 <commit>\n\ 630 --subsystem <name>[:<version>]\n\ 631 Set PE subsystem to <name> [& <version>]\n\ 632 --compress-debug-sections[={none|zlib|zlib-gnu|zlib-gabi}]\n\ 633 Compress DWARF debug sections using zlib\n\ 634 --decompress-debug-sections Decompress DWARF debug sections using zlib\n\ 635 --elf-stt-common=[yes|no] Generate ELF common symbols with STT_COMMON\n\ 636 type\n\ 637 -v --verbose List all object files modified\n\ 638 @<file> Read options from <file>\n\ 639 -V --version Display this program's version number\n\ 640 -h --help Display this output\n\ 641 --info List object formats & architectures supported\n\ 642")); 643 list_supported_targets (program_name, stream); 644 if (REPORT_BUGS_TO[0] && exit_status == 0) 645 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO); 646 exit (exit_status); 647} 648 649ATTRIBUTE_NORETURN static void 650strip_usage (FILE *stream, int exit_status) 651{ 652 fprintf (stream, _("Usage: %s <option(s)> in-file(s)\n"), program_name); 653 fprintf (stream, _(" Removes symbols and sections from files\n")); 654 fprintf (stream, _(" The options are:\n")); 655 fprintf (stream, _("\ 656 -I --input-target=<bfdname> Assume input file is in format <bfdname>\n\ 657 -O --output-target=<bfdname> Create an output file in format <bfdname>\n\ 658 -F --target=<bfdname> Set both input and output format to <bfdname>\n\ 659 -p --preserve-dates Copy modified/access timestamps to the output\n\ 660")); 661 if (DEFAULT_AR_DETERMINISTIC) 662 fprintf (stream, _("\ 663 -D --enable-deterministic-archives\n\ 664 Produce deterministic output when stripping archives (default)\n\ 665 -U --disable-deterministic-archives\n\ 666 Disable -D behavior\n")); 667 else 668 fprintf (stream, _("\ 669 -D --enable-deterministic-archives\n\ 670 Produce deterministic output when stripping archives\n\ 671 -U --disable-deterministic-archives\n\ 672 Disable -D behavior (default)\n")); 673 fprintf (stream, _("\ 674 -R --remove-section=<name> Also remove section <name> from the output\n\ 675 --remove-relocations <name> Remove relocations from section <name>\n\ 676 -s --strip-all Remove all symbol and relocation information\n\ 677 -g -S -d --strip-debug Remove all debugging symbols & sections\n\ 678 --strip-dwo Remove all DWO sections\n\ 679 --strip-unneeded Remove all symbols not needed by relocations\n\ 680 --only-keep-debug Strip everything but the debug information\n\ 681 -N --strip-symbol=<name> Do not copy symbol <name>\n\ 682 -K --keep-symbol=<name> Do not strip symbol <name>\n\ 683 --keep-file-symbols Do not strip file symbol(s)\n\ 684 -w --wildcard Permit wildcard in symbol comparison\n\ 685 -x --discard-all Remove all non-global symbols\n\ 686 -X --discard-locals Remove any compiler-generated symbols\n\ 687 -v --verbose List all object files modified\n\ 688 -V --version Display this program's version number\n\ 689 -h --help Display this output\n\ 690 --info List object formats & architectures supported\n\ 691 -o <file> Place stripped output into <file>\n\ 692")); 693 694 list_supported_targets (program_name, stream); 695 if (REPORT_BUGS_TO[0] && exit_status == 0) 696 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO); 697 exit (exit_status); 698} 699 700/* Parse section flags into a flagword, with a fatal error if the 701 string can't be parsed. */ 702 703static flagword 704parse_flags (const char *s) 705{ 706 flagword ret; 707 const char *snext; 708 int len; 709 710 ret = SEC_NO_FLAGS; 711 712 do 713 { 714 snext = strchr (s, ','); 715 if (snext == NULL) 716 len = strlen (s); 717 else 718 { 719 len = snext - s; 720 ++snext; 721 } 722 723 if (0) ; 724#define PARSE_FLAG(fname,fval) \ 725 else if (strncasecmp (fname, s, len) == 0) ret |= fval 726 PARSE_FLAG ("alloc", SEC_ALLOC); 727 PARSE_FLAG ("load", SEC_LOAD); 728 PARSE_FLAG ("noload", SEC_NEVER_LOAD); 729 PARSE_FLAG ("readonly", SEC_READONLY); 730 PARSE_FLAG ("debug", SEC_DEBUGGING); 731 PARSE_FLAG ("code", SEC_CODE); 732 PARSE_FLAG ("data", SEC_DATA); 733 PARSE_FLAG ("rom", SEC_ROM); 734 PARSE_FLAG ("share", SEC_COFF_SHARED); 735 PARSE_FLAG ("contents", SEC_HAS_CONTENTS); 736 PARSE_FLAG ("merge", SEC_MERGE); 737 PARSE_FLAG ("strings", SEC_STRINGS); 738#undef PARSE_FLAG 739 else 740 { 741 char *copy; 742 743 copy = (char *) xmalloc (len + 1); 744 strncpy (copy, s, len); 745 copy[len] = '\0'; 746 non_fatal (_("unrecognized section flag `%s'"), copy); 747 fatal (_("supported flags: %s"), 748 "alloc, load, noload, readonly, debug, code, data, rom, share, contents, merge, strings"); 749 } 750 751 s = snext; 752 } 753 while (s != NULL); 754 755 return ret; 756} 757 758/* Parse symbol flags into a flagword, with a fatal error if the 759 string can't be parsed. */ 760 761static flagword 762parse_symflags (const char *s, char **other) 763{ 764 flagword ret; 765 const char *snext; 766 size_t len; 767 768 ret = BSF_NO_FLAGS; 769 770 do 771 { 772 snext = strchr (s, ','); 773 if (snext == NULL) 774 len = strlen (s); 775 else 776 { 777 len = snext - s; 778 ++snext; 779 } 780 781#define PARSE_FLAG(fname, fval) \ 782 else if (len == sizeof fname - 1 \ 783 && strncasecmp (fname, s, len) == 0) \ 784 ret |= fval 785 786#define PARSE_OTHER(fname, fval) \ 787 else if (len >= sizeof fname \ 788 && strncasecmp (fname, s, sizeof fname - 1) == 0) \ 789 fval = xstrndup (s + sizeof fname - 1, len - sizeof fname + 1) 790 791 if (0) ; 792 PARSE_FLAG ("local", BSF_LOCAL); 793 PARSE_FLAG ("global", BSF_GLOBAL); 794 PARSE_FLAG ("export", BSF_EXPORT); 795 PARSE_FLAG ("debug", BSF_DEBUGGING); 796 PARSE_FLAG ("function", BSF_FUNCTION); 797 PARSE_FLAG ("weak", BSF_WEAK); 798 PARSE_FLAG ("section", BSF_SECTION_SYM); 799 PARSE_FLAG ("constructor", BSF_CONSTRUCTOR); 800 PARSE_FLAG ("warning", BSF_WARNING); 801 PARSE_FLAG ("indirect", BSF_INDIRECT); 802 PARSE_FLAG ("file", BSF_FILE); 803 PARSE_FLAG ("object", BSF_OBJECT); 804 PARSE_FLAG ("synthetic", BSF_SYNTHETIC); 805 PARSE_FLAG ("indirect-function", BSF_GNU_INDIRECT_FUNCTION | BSF_FUNCTION); 806 PARSE_FLAG ("unique-object", BSF_GNU_UNIQUE | BSF_OBJECT); 807 PARSE_OTHER ("before=", *other); 808 809#undef PARSE_FLAG 810#undef PARSE_OTHER 811 else 812 { 813 char *copy; 814 815 copy = (char *) xmalloc (len + 1); 816 strncpy (copy, s, len); 817 copy[len] = '\0'; 818 non_fatal (_("unrecognized symbol flag `%s'"), copy); 819 fatal (_("supported flags: %s"), 820 "local, global, export, debug, function, weak, section, " 821 "constructor, warning, indirect, file, object, synthetic, " 822 "indirect-function, unique-object, before=<othersym>"); 823 } 824 825 s = snext; 826 } 827 while (s != NULL); 828 829 return ret; 830} 831 832/* Find and optionally add an entry in the change_sections list. 833 834 We need to be careful in how we match section names because of the support 835 for wildcard characters. For example suppose that the user has invoked 836 objcopy like this: 837 838 --set-section-flags .debug_*=debug 839 --set-section-flags .debug_str=readonly,debug 840 --change-section-address .debug_*ranges=0x1000 841 842 With the idea that all debug sections will receive the DEBUG flag, the 843 .debug_str section will also receive the READONLY flag and the 844 .debug_ranges and .debug_aranges sections will have their address set to 845 0x1000. (This may not make much sense, but it is just an example). 846 847 When adding the section name patterns to the section list we need to make 848 sure that previous entries do not match with the new entry, unless the 849 match is exact. (In which case we assume that the user is overriding 850 the previous entry with the new context). 851 852 When matching real section names to the section list we make use of the 853 wildcard characters, but we must do so in context. Eg if we are setting 854 section addresses then we match for .debug_ranges but not for .debug_info. 855 856 Finally, if ADD is false and we do find a match, we mark the section list 857 entry as used. */ 858 859static struct section_list * 860find_section_list (const char *name, bfd_boolean add, unsigned int context) 861{ 862 struct section_list *p, *match = NULL; 863 864 /* assert ((context & ((1 << 7) - 1)) != 0); */ 865 866 for (p = change_sections; p != NULL; p = p->next) 867 { 868 if (add) 869 { 870 if (strcmp (p->pattern, name) == 0) 871 { 872 /* Check for context conflicts. */ 873 if (((p->context & SECTION_CONTEXT_REMOVE) 874 && (context & SECTION_CONTEXT_COPY)) 875 || ((context & SECTION_CONTEXT_REMOVE) 876 && (p->context & SECTION_CONTEXT_COPY))) 877 fatal (_("error: %s both copied and removed"), name); 878 879 if (((p->context & SECTION_CONTEXT_SET_VMA) 880 && (context & SECTION_CONTEXT_ALTER_VMA)) 881 || ((context & SECTION_CONTEXT_SET_VMA) 882 && (context & SECTION_CONTEXT_ALTER_VMA))) 883 fatal (_("error: %s both sets and alters VMA"), name); 884 885 if (((p->context & SECTION_CONTEXT_SET_LMA) 886 && (context & SECTION_CONTEXT_ALTER_LMA)) 887 || ((context & SECTION_CONTEXT_SET_LMA) 888 && (context & SECTION_CONTEXT_ALTER_LMA))) 889 fatal (_("error: %s both sets and alters LMA"), name); 890 891 /* Extend the context. */ 892 p->context |= context; 893 return p; 894 } 895 } 896 /* If we are not adding a new name/pattern then 897 only check for a match if the context applies. */ 898 else if (p->context & context) 899 { 900 /* We could check for the presence of wildchar characters 901 first and choose between calling strcmp and fnmatch, 902 but is that really worth it ? */ 903 if (p->pattern [0] == '!') 904 { 905 if (fnmatch (p->pattern + 1, name, 0) == 0) 906 { 907 p->used = TRUE; 908 return NULL; 909 } 910 } 911 else 912 { 913 if (fnmatch (p->pattern, name, 0) == 0) 914 { 915 if (match == NULL) 916 match = p; 917 } 918 } 919 } 920 } 921 922 if (! add) 923 { 924 if (match != NULL) 925 match->used = TRUE; 926 return match; 927 } 928 929 p = (struct section_list *) xmalloc (sizeof (struct section_list)); 930 p->pattern = name; 931 p->used = FALSE; 932 p->context = context; 933 p->vma_val = 0; 934 p->lma_val = 0; 935 p->flags = 0; 936 p->next = change_sections; 937 change_sections = p; 938 939 return p; 940} 941 942/* There is htab_hash_string but no htab_eq_string. Makes sense. */ 943 944static int 945eq_string (const void *s1, const void *s2) 946{ 947 return strcmp ((const char *) s1, (const char *) s2) == 0; 948} 949 950static htab_t 951create_symbol_htab (void) 952{ 953 return htab_create_alloc (16, htab_hash_string, eq_string, NULL, xcalloc, free); 954} 955 956static void 957create_symbol_htabs (void) 958{ 959 strip_specific_htab = create_symbol_htab (); 960 strip_unneeded_htab = create_symbol_htab (); 961 keep_specific_htab = create_symbol_htab (); 962 localize_specific_htab = create_symbol_htab (); 963 globalize_specific_htab = create_symbol_htab (); 964 keepglobal_specific_htab = create_symbol_htab (); 965 weaken_specific_htab = create_symbol_htab (); 966} 967 968/* Add a symbol to strip_specific_list. */ 969 970static void 971add_specific_symbol (const char *name, htab_t htab) 972{ 973 *htab_find_slot (htab, name, INSERT) = (char *) name; 974} 975 976/* Add symbols listed in `filename' to strip_specific_list. */ 977 978#define IS_WHITESPACE(c) ((c) == ' ' || (c) == '\t') 979#define IS_LINE_TERMINATOR(c) ((c) == '\n' || (c) == '\r' || (c) == '\0') 980 981static void 982add_specific_symbols (const char *filename, htab_t htab) 983{ 984 off_t size; 985 FILE * f; 986 char * line; 987 char * buffer; 988 unsigned int line_count; 989 990 size = get_file_size (filename); 991 if (size == 0) 992 { 993 status = 1; 994 return; 995 } 996 997 buffer = (char *) xmalloc (size + 2); 998 f = fopen (filename, FOPEN_RT); 999 if (f == NULL) 1000 fatal (_("cannot open '%s': %s"), filename, strerror (errno)); 1001 1002 if (fread (buffer, 1, size, f) == 0 || ferror (f)) 1003 fatal (_("%s: fread failed"), filename); 1004 1005 fclose (f); 1006 buffer [size] = '\n'; 1007 buffer [size + 1] = '\0'; 1008 1009 line_count = 1; 1010 1011 for (line = buffer; * line != '\0'; line ++) 1012 { 1013 char * eol; 1014 char * name; 1015 char * name_end; 1016 int finished = FALSE; 1017 1018 for (eol = line;; eol ++) 1019 { 1020 switch (* eol) 1021 { 1022 case '\n': 1023 * eol = '\0'; 1024 /* Cope with \n\r. */ 1025 if (eol[1] == '\r') 1026 ++ eol; 1027 finished = TRUE; 1028 break; 1029 1030 case '\r': 1031 * eol = '\0'; 1032 /* Cope with \r\n. */ 1033 if (eol[1] == '\n') 1034 ++ eol; 1035 finished = TRUE; 1036 break; 1037 1038 case 0: 1039 finished = TRUE; 1040 break; 1041 1042 case '#': 1043 /* Line comment, Terminate the line here, in case a 1044 name is present and then allow the rest of the 1045 loop to find the real end of the line. */ 1046 * eol = '\0'; 1047 break; 1048 1049 default: 1050 break; 1051 } 1052 1053 if (finished) 1054 break; 1055 } 1056 1057 /* A name may now exist somewhere between 'line' and 'eol'. 1058 Strip off leading whitespace and trailing whitespace, 1059 then add it to the list. */ 1060 for (name = line; IS_WHITESPACE (* name); name ++) 1061 ; 1062 for (name_end = name; 1063 (! IS_WHITESPACE (* name_end)) 1064 && (! IS_LINE_TERMINATOR (* name_end)); 1065 name_end ++) 1066 ; 1067 1068 if (! IS_LINE_TERMINATOR (* name_end)) 1069 { 1070 char * extra; 1071 1072 for (extra = name_end + 1; IS_WHITESPACE (* extra); extra ++) 1073 ; 1074 1075 if (! IS_LINE_TERMINATOR (* extra)) 1076 non_fatal (_("%s:%d: Ignoring rubbish found on this line"), 1077 filename, line_count); 1078 } 1079 1080 * name_end = '\0'; 1081 1082 if (name_end > name) 1083 add_specific_symbol (name, htab); 1084 1085 /* Advance line pointer to end of line. The 'eol ++' in the for 1086 loop above will then advance us to the start of the next line. */ 1087 line = eol; 1088 line_count ++; 1089 } 1090} 1091 1092/* See whether a symbol should be stripped or kept 1093 based on strip_specific_list and keep_symbols. */ 1094 1095static int 1096is_specified_symbol_predicate (void **slot, void *data) 1097{ 1098 struct is_specified_symbol_predicate_data *d = 1099 (struct is_specified_symbol_predicate_data *) data; 1100 const char *slot_name = (char *) *slot; 1101 1102 if (*slot_name != '!') 1103 { 1104 if (! fnmatch (slot_name, d->name, 0)) 1105 { 1106 d->found = TRUE; 1107 /* Continue traversal, there might be a non-match rule. */ 1108 return 1; 1109 } 1110 } 1111 else 1112 { 1113 if (! fnmatch (slot_name + 1, d->name, 0)) 1114 { 1115 d->found = FALSE; 1116 /* Stop traversal. */ 1117 return 0; 1118 } 1119 } 1120 1121 /* Continue traversal. */ 1122 return 1; 1123} 1124 1125static bfd_boolean 1126is_specified_symbol (const char *name, htab_t htab) 1127{ 1128 if (wildcard) 1129 { 1130 struct is_specified_symbol_predicate_data data; 1131 1132 data.name = name; 1133 data.found = FALSE; 1134 1135 htab_traverse (htab, is_specified_symbol_predicate, &data); 1136 1137 return data.found; 1138 } 1139 1140 return htab_find (htab, name) != NULL; 1141} 1142 1143/* Return a pointer to the symbol used as a signature for GROUP. */ 1144 1145static asymbol * 1146group_signature (asection *group) 1147{ 1148 bfd *abfd = group->owner; 1149 Elf_Internal_Shdr *ghdr; 1150 1151 /* PR 20089: An earlier error may have prevented us from loading the symbol table. */ 1152 if (isympp == NULL) 1153 return NULL; 1154 1155 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 1156 return NULL; 1157 1158 ghdr = &elf_section_data (group)->this_hdr; 1159 if (ghdr->sh_link < elf_numsections (abfd)) 1160 { 1161 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 1162 Elf_Internal_Shdr *symhdr = elf_elfsections (abfd) [ghdr->sh_link]; 1163 1164 if (symhdr->sh_type == SHT_SYMTAB 1165 && ghdr->sh_info > 0 1166 && ghdr->sh_info < (symhdr->sh_size / bed->s->sizeof_sym)) 1167 return isympp[ghdr->sh_info - 1]; 1168 } 1169 return NULL; 1170} 1171 1172/* Return TRUE if the section is a DWO section. */ 1173 1174static bfd_boolean 1175is_dwo_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) 1176{ 1177 const char *name = bfd_get_section_name (abfd, sec); 1178 int len = strlen (name); 1179 1180 return strncmp (name + len - 4, ".dwo", 4) == 0; 1181} 1182 1183/* Return TRUE if section SEC is in the update list. */ 1184 1185static bfd_boolean 1186is_update_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) 1187{ 1188 if (update_sections != NULL) 1189 { 1190 struct section_add *pupdate; 1191 1192 for (pupdate = update_sections; 1193 pupdate != NULL; 1194 pupdate = pupdate->next) 1195 { 1196 if (strcmp (sec->name, pupdate->name) == 0) 1197 return TRUE; 1198 } 1199 } 1200 1201 return FALSE; 1202} 1203 1204/* See if a non-group section is being removed. */ 1205 1206static bfd_boolean 1207is_strip_section_1 (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) 1208{ 1209 if (sections_removed || sections_copied) 1210 { 1211 struct section_list *p; 1212 struct section_list *q; 1213 1214 p = find_section_list (bfd_get_section_name (abfd, sec), FALSE, 1215 SECTION_CONTEXT_REMOVE); 1216 q = find_section_list (bfd_get_section_name (abfd, sec), FALSE, 1217 SECTION_CONTEXT_COPY); 1218 1219 if (p && q) 1220 fatal (_("error: section %s matches both remove and copy options"), 1221 bfd_get_section_name (abfd, sec)); 1222 if (p && is_update_section (abfd, sec)) 1223 fatal (_("error: section %s matches both update and remove options"), 1224 bfd_get_section_name (abfd, sec)); 1225 1226 if (p != NULL) 1227 return TRUE; 1228 if (sections_copied && q == NULL) 1229 return TRUE; 1230 } 1231 1232 if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0) 1233 { 1234 if (strip_symbols == STRIP_DEBUG 1235 || strip_symbols == STRIP_UNNEEDED 1236 || strip_symbols == STRIP_ALL 1237 || discard_locals == LOCALS_ALL 1238 || convert_debugging) 1239 { 1240 /* By default we don't want to strip .reloc section. 1241 This section has for pe-coff special meaning. See 1242 pe-dll.c file in ld, and peXXigen.c in bfd for details. */ 1243 if (strcmp (bfd_get_section_name (abfd, sec), ".reloc") != 0) 1244 return TRUE; 1245 } 1246 1247 if (strip_symbols == STRIP_DWO) 1248 return is_dwo_section (abfd, sec); 1249 1250 if (strip_symbols == STRIP_NONDEBUG) 1251 return FALSE; 1252 } 1253 1254 if (strip_symbols == STRIP_NONDWO) 1255 return !is_dwo_section (abfd, sec); 1256 1257 return FALSE; 1258} 1259 1260/* See if a section is being removed. */ 1261 1262static bfd_boolean 1263is_strip_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) 1264{ 1265 if (is_strip_section_1 (abfd, sec)) 1266 return TRUE; 1267 1268 if ((bfd_get_section_flags (abfd, sec) & SEC_GROUP) != 0) 1269 { 1270 asymbol *gsym; 1271 const char *gname; 1272 asection *elt, *first; 1273 1274 /* PR binutils/3181 1275 If we are going to strip the group signature symbol, then 1276 strip the group section too. */ 1277 gsym = group_signature (sec); 1278 if (gsym != NULL) 1279 gname = gsym->name; 1280 else 1281 gname = sec->name; 1282 if ((strip_symbols == STRIP_ALL 1283 && !is_specified_symbol (gname, keep_specific_htab)) 1284 || is_specified_symbol (gname, strip_specific_htab)) 1285 return TRUE; 1286 1287 /* Remove the group section if all members are removed. */ 1288 first = elt = elf_next_in_group (sec); 1289 while (elt != NULL) 1290 { 1291 if (!is_strip_section_1 (abfd, elt)) 1292 return FALSE; 1293 elt = elf_next_in_group (elt); 1294 if (elt == first) 1295 break; 1296 } 1297 1298 return TRUE; 1299 } 1300 1301 return FALSE; 1302} 1303 1304static bfd_boolean 1305is_nondebug_keep_contents_section (bfd *ibfd, asection *isection) 1306{ 1307 /* Always keep ELF note sections. */ 1308 if (ibfd->xvec->flavour == bfd_target_elf_flavour) 1309 return (elf_section_type (isection) == SHT_NOTE); 1310 1311 /* Always keep the .buildid section for PE/COFF. 1312 1313 Strictly, this should be written "always keep the section storing the debug 1314 directory", but that may be the .text section for objects produced by some 1315 tools, which it is not sensible to keep. */ 1316 if (ibfd->xvec->flavour == bfd_target_coff_flavour) 1317 return (strcmp (bfd_get_section_name (ibfd, isection), ".buildid") == 0); 1318 1319 return FALSE; 1320} 1321 1322/* Return true if SYM is a hidden symbol. */ 1323 1324static bfd_boolean 1325is_hidden_symbol (asymbol *sym) 1326{ 1327 elf_symbol_type *elf_sym; 1328 1329 elf_sym = elf_symbol_from (sym->the_bfd, sym); 1330 if (elf_sym != NULL) 1331 switch (ELF_ST_VISIBILITY (elf_sym->internal_elf_sym.st_other)) 1332 { 1333 case STV_HIDDEN: 1334 case STV_INTERNAL: 1335 return TRUE; 1336 } 1337 return FALSE; 1338} 1339 1340static bfd_boolean 1341need_sym_before (struct addsym_node **node, const char *sym) 1342{ 1343 int count; 1344 struct addsym_node *ptr = add_sym_list; 1345 1346 /* 'othersym' symbols are at the front of the list. */ 1347 for (count = 0; count < add_symbols; count++) 1348 { 1349 if (!ptr->othersym) 1350 break; 1351 else if (strcmp (ptr->othersym, sym) == 0) 1352 { 1353 free (ptr->othersym); 1354 ptr->othersym = ""; /* Empty name is hopefully never a valid symbol name. */ 1355 *node = ptr; 1356 return TRUE; 1357 } 1358 ptr = ptr->next; 1359 } 1360 return FALSE; 1361} 1362 1363static asymbol * 1364create_new_symbol (struct addsym_node *ptr, bfd *obfd) 1365{ 1366 asymbol *sym = bfd_make_empty_symbol (obfd); 1367 1368 bfd_asymbol_name (sym) = ptr->symdef; 1369 sym->value = ptr->symval; 1370 sym->flags = ptr->flags; 1371 if (ptr->section) 1372 { 1373 asection *sec = bfd_get_section_by_name (obfd, ptr->section); 1374 if (!sec) 1375 fatal (_("Section %s not found"), ptr->section); 1376 sym->section = sec; 1377 } 1378 else 1379 sym->section = bfd_abs_section_ptr; 1380 return sym; 1381} 1382 1383/* Choose which symbol entries to copy; put the result in OSYMS. 1384 We don't copy in place, because that confuses the relocs. 1385 Return the number of symbols to print. */ 1386 1387static unsigned int 1388filter_symbols (bfd *abfd, bfd *obfd, asymbol **osyms, 1389 asymbol **isyms, long symcount) 1390{ 1391 asymbol **from = isyms, **to = osyms; 1392 long src_count = 0, dst_count = 0; 1393 int relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0; 1394 1395 for (; src_count < symcount; src_count++) 1396 { 1397 asymbol *sym = from[src_count]; 1398 flagword flags = sym->flags; 1399 char *name = (char *) bfd_asymbol_name (sym); 1400 bfd_boolean keep; 1401 bfd_boolean used_in_reloc = FALSE; 1402 bfd_boolean undefined; 1403 bfd_boolean rem_leading_char; 1404 bfd_boolean add_leading_char; 1405 1406 undefined = bfd_is_und_section (bfd_get_section (sym)); 1407 1408 if (add_sym_list) 1409 { 1410 struct addsym_node *ptr; 1411 1412 if (need_sym_before (&ptr, name)) 1413 to[dst_count++] = create_new_symbol (ptr, obfd); 1414 } 1415 1416 if (redefine_sym_list || section_rename_list) 1417 { 1418 char *new_name; 1419 1420 new_name = (char *) lookup_sym_redefinition (name); 1421 if (new_name == name 1422 && (flags & BSF_SECTION_SYM) != 0) 1423 new_name = (char *) find_section_rename (name, NULL); 1424 bfd_asymbol_name (sym) = new_name; 1425 name = new_name; 1426 } 1427 1428 /* Check if we will remove the current leading character. */ 1429 rem_leading_char = 1430 (name[0] == bfd_get_symbol_leading_char (abfd)) 1431 && (change_leading_char 1432 || (remove_leading_char 1433 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0 1434 || undefined 1435 || bfd_is_com_section (bfd_get_section (sym))))); 1436 1437 /* Check if we will add a new leading character. */ 1438 add_leading_char = 1439 change_leading_char 1440 && (bfd_get_symbol_leading_char (obfd) != '\0') 1441 && (bfd_get_symbol_leading_char (abfd) == '\0' 1442 || (name[0] == bfd_get_symbol_leading_char (abfd))); 1443 1444 /* Short circuit for change_leading_char if we can do it in-place. */ 1445 if (rem_leading_char && add_leading_char && !prefix_symbols_string) 1446 { 1447 name[0] = bfd_get_symbol_leading_char (obfd); 1448 bfd_asymbol_name (sym) = name; 1449 rem_leading_char = FALSE; 1450 add_leading_char = FALSE; 1451 } 1452 1453 /* Remove leading char. */ 1454 if (rem_leading_char) 1455 bfd_asymbol_name (sym) = ++name; 1456 1457 /* Add new leading char and/or prefix. */ 1458 if (add_leading_char || prefix_symbols_string) 1459 { 1460 char *n, *ptr; 1461 1462 ptr = n = (char *) xmalloc (1 + strlen (prefix_symbols_string) 1463 + strlen (name) + 1); 1464 if (add_leading_char) 1465 *ptr++ = bfd_get_symbol_leading_char (obfd); 1466 1467 if (prefix_symbols_string) 1468 { 1469 strcpy (ptr, prefix_symbols_string); 1470 ptr += strlen (prefix_symbols_string); 1471 } 1472 1473 strcpy (ptr, name); 1474 bfd_asymbol_name (sym) = n; 1475 name = n; 1476 } 1477 1478 if (strip_symbols == STRIP_ALL) 1479 keep = FALSE; 1480 else if ((flags & BSF_KEEP) != 0 /* Used in relocation. */ 1481 || ((flags & BSF_SECTION_SYM) != 0 1482 && ((*bfd_get_section (sym)->symbol_ptr_ptr)->flags 1483 & BSF_KEEP) != 0)) 1484 { 1485 keep = TRUE; 1486 used_in_reloc = TRUE; 1487 } 1488 else if (relocatable /* Relocatable file. */ 1489 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0 1490 || bfd_is_com_section (bfd_get_section (sym)))) 1491 keep = TRUE; 1492 else if (bfd_decode_symclass (sym) == 'I') 1493 /* Global symbols in $idata sections need to be retained 1494 even if relocatable is FALSE. External users of the 1495 library containing the $idata section may reference these 1496 symbols. */ 1497 keep = TRUE; 1498 else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */ 1499 || (flags & BSF_WEAK) != 0 1500 || undefined 1501 || bfd_is_com_section (bfd_get_section (sym))) 1502 keep = strip_symbols != STRIP_UNNEEDED; 1503 else if ((flags & BSF_DEBUGGING) != 0) /* Debugging symbol. */ 1504 keep = (strip_symbols != STRIP_DEBUG 1505 && strip_symbols != STRIP_UNNEEDED 1506 && ! convert_debugging); 1507 else if (bfd_coff_get_comdat_section (abfd, bfd_get_section (sym))) 1508 /* COMDAT sections store special information in local 1509 symbols, so we cannot risk stripping any of them. */ 1510 keep = TRUE; 1511 else /* Local symbol. */ 1512 keep = (strip_symbols != STRIP_UNNEEDED 1513 && (discard_locals != LOCALS_ALL 1514 && (discard_locals != LOCALS_START_L 1515 || ! bfd_is_local_label (abfd, sym)))); 1516 1517 if (keep && is_specified_symbol (name, strip_specific_htab)) 1518 { 1519 /* There are multiple ways to set 'keep' above, but if it 1520 was the relocatable symbol case, then that's an error. */ 1521 if (used_in_reloc) 1522 { 1523 non_fatal (_("not stripping symbol `%s' because it is named in a relocation"), name); 1524 status = 1; 1525 } 1526 else 1527 keep = FALSE; 1528 } 1529 1530 if (keep 1531 && !(flags & BSF_KEEP) 1532 && is_specified_symbol (name, strip_unneeded_htab)) 1533 keep = FALSE; 1534 1535 if (!keep 1536 && ((keep_file_symbols && (flags & BSF_FILE)) 1537 || is_specified_symbol (name, keep_specific_htab))) 1538 keep = TRUE; 1539 1540 if (keep && is_strip_section (abfd, bfd_get_section (sym))) 1541 keep = FALSE; 1542 1543 if (keep) 1544 { 1545 if ((flags & BSF_GLOBAL) != 0 1546 && (weaken || is_specified_symbol (name, weaken_specific_htab))) 1547 { 1548 sym->flags &= ~ BSF_GLOBAL; 1549 sym->flags |= BSF_WEAK; 1550 } 1551 1552 if (!undefined 1553 && (flags & (BSF_GLOBAL | BSF_WEAK)) 1554 && (is_specified_symbol (name, localize_specific_htab) 1555 || (htab_elements (keepglobal_specific_htab) != 0 1556 && ! is_specified_symbol (name, keepglobal_specific_htab)) 1557 || (localize_hidden && is_hidden_symbol (sym)))) 1558 { 1559 sym->flags &= ~ (BSF_GLOBAL | BSF_WEAK); 1560 sym->flags |= BSF_LOCAL; 1561 } 1562 1563 if (!undefined 1564 && (flags & BSF_LOCAL) 1565 && is_specified_symbol (name, globalize_specific_htab)) 1566 { 1567 sym->flags &= ~ BSF_LOCAL; 1568 sym->flags |= BSF_GLOBAL; 1569 } 1570 1571 to[dst_count++] = sym; 1572 } 1573 } 1574 if (add_sym_list) 1575 { 1576 struct addsym_node *ptr = add_sym_list; 1577 1578 for (src_count = 0; src_count < add_symbols; src_count++) 1579 { 1580 if (ptr->othersym) 1581 { 1582 if (strcmp (ptr->othersym, "")) 1583 fatal (_("'before=%s' not found"), ptr->othersym); 1584 } 1585 else 1586 to[dst_count++] = create_new_symbol (ptr, obfd); 1587 1588 ptr = ptr->next; 1589 } 1590 } 1591 1592 to[dst_count] = NULL; 1593 1594 return dst_count; 1595} 1596 1597/* Find the redefined name of symbol SOURCE. */ 1598 1599static const char * 1600lookup_sym_redefinition (const char *source) 1601{ 1602 struct redefine_node *list; 1603 1604 for (list = redefine_sym_list; list != NULL; list = list->next) 1605 if (strcmp (source, list->source) == 0) 1606 return list->target; 1607 1608 return source; 1609} 1610 1611/* Add a node to a symbol redefine list. */ 1612 1613static void 1614redefine_list_append (const char *cause, const char *source, const char *target) 1615{ 1616 struct redefine_node **p; 1617 struct redefine_node *list; 1618 struct redefine_node *new_node; 1619 1620 for (p = &redefine_sym_list; (list = *p) != NULL; p = &list->next) 1621 { 1622 if (strcmp (source, list->source) == 0) 1623 fatal (_("%s: Multiple redefinition of symbol \"%s\""), 1624 cause, source); 1625 1626 if (strcmp (target, list->target) == 0) 1627 fatal (_("%s: Symbol \"%s\" is target of more than one redefinition"), 1628 cause, target); 1629 } 1630 1631 new_node = (struct redefine_node *) xmalloc (sizeof (struct redefine_node)); 1632 1633 new_node->source = strdup (source); 1634 new_node->target = strdup (target); 1635 new_node->next = NULL; 1636 1637 *p = new_node; 1638} 1639 1640/* Handle the --redefine-syms option. Read lines containing "old new" 1641 from the file, and add them to the symbol redefine list. */ 1642 1643static void 1644add_redefine_syms_file (const char *filename) 1645{ 1646 FILE *file; 1647 char *buf; 1648 size_t bufsize; 1649 size_t len; 1650 size_t outsym_off; 1651 int c, lineno; 1652 1653 file = fopen (filename, "r"); 1654 if (file == NULL) 1655 fatal (_("couldn't open symbol redefinition file %s (error: %s)"), 1656 filename, strerror (errno)); 1657 1658 bufsize = 100; 1659 buf = (char *) xmalloc (bufsize + 1 /* For the terminating NUL. */); 1660 1661 lineno = 1; 1662 c = getc (file); 1663 len = 0; 1664 outsym_off = 0; 1665 while (c != EOF) 1666 { 1667 /* Collect the input symbol name. */ 1668 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF) 1669 { 1670 if (c == '#') 1671 goto comment; 1672 buf[len++] = c; 1673 if (len >= bufsize) 1674 { 1675 bufsize *= 2; 1676 buf = (char *) xrealloc (buf, bufsize + 1); 1677 } 1678 c = getc (file); 1679 } 1680 buf[len++] = '\0'; 1681 if (c == EOF) 1682 break; 1683 1684 /* Eat white space between the symbol names. */ 1685 while (IS_WHITESPACE (c)) 1686 c = getc (file); 1687 if (c == '#' || IS_LINE_TERMINATOR (c)) 1688 goto comment; 1689 if (c == EOF) 1690 break; 1691 1692 /* Collect the output symbol name. */ 1693 outsym_off = len; 1694 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF) 1695 { 1696 if (c == '#') 1697 goto comment; 1698 buf[len++] = c; 1699 if (len >= bufsize) 1700 { 1701 bufsize *= 2; 1702 buf = (char *) xrealloc (buf, bufsize + 1); 1703 } 1704 c = getc (file); 1705 } 1706 buf[len++] = '\0'; 1707 if (c == EOF) 1708 break; 1709 1710 /* Eat white space at end of line. */ 1711 while (! IS_LINE_TERMINATOR(c) && c != EOF && IS_WHITESPACE (c)) 1712 c = getc (file); 1713 if (c == '#') 1714 goto comment; 1715 /* Handle \r\n. */ 1716 if ((c == '\r' && (c = getc (file)) == '\n') 1717 || c == '\n' || c == EOF) 1718 { 1719 end_of_line: 1720 /* Append the redefinition to the list. */ 1721 if (buf[0] != '\0') 1722 redefine_list_append (filename, &buf[0], &buf[outsym_off]); 1723 1724 lineno++; 1725 len = 0; 1726 outsym_off = 0; 1727 if (c == EOF) 1728 break; 1729 c = getc (file); 1730 continue; 1731 } 1732 else 1733 fatal (_("%s:%d: garbage found at end of line"), filename, lineno); 1734 comment: 1735 if (len != 0 && (outsym_off == 0 || outsym_off == len)) 1736 fatal (_("%s:%d: missing new symbol name"), filename, lineno); 1737 buf[len++] = '\0'; 1738 1739 /* Eat the rest of the line and finish it. */ 1740 while (c != '\n' && c != EOF) 1741 c = getc (file); 1742 goto end_of_line; 1743 } 1744 1745 if (len != 0) 1746 fatal (_("%s:%d: premature end of file"), filename, lineno); 1747 1748 free (buf); 1749} 1750 1751/* Copy unknown object file IBFD onto OBFD. 1752 Returns TRUE upon success, FALSE otherwise. */ 1753 1754static bfd_boolean 1755copy_unknown_object (bfd *ibfd, bfd *obfd) 1756{ 1757 char *cbuf; 1758 int tocopy; 1759 long ncopied; 1760 long size; 1761 struct stat buf; 1762 1763 if (bfd_stat_arch_elt (ibfd, &buf) != 0) 1764 { 1765 bfd_nonfatal_message (NULL, ibfd, NULL, NULL); 1766 return FALSE; 1767 } 1768 1769 size = buf.st_size; 1770 if (size < 0) 1771 { 1772 non_fatal (_("stat returns negative size for `%s'"), 1773 bfd_get_archive_filename (ibfd)); 1774 return FALSE; 1775 } 1776 1777 if (bfd_seek (ibfd, (file_ptr) 0, SEEK_SET) != 0) 1778 { 1779 bfd_nonfatal (bfd_get_archive_filename (ibfd)); 1780 return FALSE; 1781 } 1782 1783 if (verbose) 1784 printf (_("copy from `%s' [unknown] to `%s' [unknown]\n"), 1785 bfd_get_archive_filename (ibfd), bfd_get_filename (obfd)); 1786 1787 cbuf = (char *) xmalloc (BUFSIZE); 1788 ncopied = 0; 1789 while (ncopied < size) 1790 { 1791 tocopy = size - ncopied; 1792 if (tocopy > BUFSIZE) 1793 tocopy = BUFSIZE; 1794 1795 if (bfd_bread (cbuf, (bfd_size_type) tocopy, ibfd) 1796 != (bfd_size_type) tocopy) 1797 { 1798 bfd_nonfatal_message (NULL, ibfd, NULL, NULL); 1799 free (cbuf); 1800 return FALSE; 1801 } 1802 1803 if (bfd_bwrite (cbuf, (bfd_size_type) tocopy, obfd) 1804 != (bfd_size_type) tocopy) 1805 { 1806 bfd_nonfatal_message (NULL, obfd, NULL, NULL); 1807 free (cbuf); 1808 return FALSE; 1809 } 1810 1811 ncopied += tocopy; 1812 } 1813 1814 /* We should at least to be able to read it back when copying an 1815 unknown object in an archive. */ 1816 chmod (bfd_get_filename (obfd), buf.st_mode | S_IRUSR); 1817 free (cbuf); 1818 return TRUE; 1819} 1820 1821/* Copy object file IBFD onto OBFD. 1822 Returns TRUE upon success, FALSE otherwise. */ 1823 1824static bfd_boolean 1825copy_object (bfd *ibfd, bfd *obfd, const bfd_arch_info_type *input_arch) 1826{ 1827 bfd_vma start; 1828 long symcount; 1829 asection **osections = NULL; 1830 asection *gnu_debuglink_section = NULL; 1831 bfd_size_type *gaps = NULL; 1832 bfd_size_type max_gap = 0; 1833 long symsize; 1834 void *dhandle; 1835 enum bfd_architecture iarch; 1836 unsigned int imach; 1837 unsigned int c, i; 1838 1839 if (ibfd->xvec->byteorder != obfd->xvec->byteorder 1840 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN 1841 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN) 1842 { 1843 /* PR 17636: Call non-fatal so that we return to our parent who 1844 may need to tidy temporary files. */ 1845 non_fatal (_("Unable to change endianness of input file(s)")); 1846 return FALSE; 1847 } 1848 1849 if (!bfd_set_format (obfd, bfd_get_format (ibfd))) 1850 { 1851 bfd_nonfatal_message (NULL, obfd, NULL, NULL); 1852 return FALSE; 1853 } 1854 1855 if (ibfd->sections == NULL) 1856 { 1857 non_fatal (_("error: the input file '%s' has no sections"), 1858 bfd_get_archive_filename (ibfd)); 1859 return FALSE; 1860 } 1861 1862 if (ibfd->xvec->flavour != bfd_target_elf_flavour) 1863 { 1864 if ((do_debug_sections & compress) != 0 1865 && do_debug_sections != compress) 1866 { 1867 non_fatal (_("--compress-debug-sections=[zlib|zlib-gnu|zlib-gabi] is unsupported on `%s'"), 1868 bfd_get_archive_filename (ibfd)); 1869 return FALSE; 1870 } 1871 1872 if (do_elf_stt_common) 1873 { 1874 non_fatal (_("--elf-stt-common=[yes|no] is unsupported on `%s'"), 1875 bfd_get_archive_filename (ibfd)); 1876 return FALSE; 1877 } 1878 } 1879 1880 if (verbose) 1881 printf (_("copy from `%s' [%s] to `%s' [%s]\n"), 1882 bfd_get_archive_filename (ibfd), bfd_get_target (ibfd), 1883 bfd_get_filename (obfd), bfd_get_target (obfd)); 1884 1885 if (extract_symbol) 1886 start = 0; 1887 else 1888 { 1889 if (set_start_set) 1890 start = set_start; 1891 else 1892 start = bfd_get_start_address (ibfd); 1893 start += change_start; 1894 } 1895 1896 /* Neither the start address nor the flags 1897 need to be set for a core file. */ 1898 if (bfd_get_format (obfd) != bfd_core) 1899 { 1900 flagword flags; 1901 1902 flags = bfd_get_file_flags (ibfd); 1903 flags |= bfd_flags_to_set; 1904 flags &= ~bfd_flags_to_clear; 1905 flags &= bfd_applicable_file_flags (obfd); 1906 1907 if (strip_symbols == STRIP_ALL) 1908 flags &= ~HAS_RELOC; 1909 1910 if (!bfd_set_start_address (obfd, start) 1911 || !bfd_set_file_flags (obfd, flags)) 1912 { 1913 bfd_nonfatal_message (NULL, ibfd, NULL, NULL); 1914 return FALSE; 1915 } 1916 } 1917 1918 /* Copy architecture of input file to output file. */ 1919 iarch = bfd_get_arch (ibfd); 1920 imach = bfd_get_mach (ibfd); 1921 if (input_arch) 1922 { 1923 if (bfd_get_arch_info (ibfd) == NULL 1924 || bfd_get_arch_info (ibfd)->arch == bfd_arch_unknown) 1925 { 1926 iarch = input_arch->arch; 1927 imach = input_arch->mach; 1928 } 1929 else 1930 non_fatal (_("Input file `%s' ignores binary architecture parameter."), 1931 bfd_get_archive_filename (ibfd)); 1932 } 1933 if (!bfd_set_arch_mach (obfd, iarch, imach) 1934 && (ibfd->target_defaulted 1935 || bfd_get_arch (ibfd) != bfd_get_arch (obfd))) 1936 { 1937 if (bfd_get_arch (ibfd) == bfd_arch_unknown) 1938 non_fatal (_("Unable to recognise the format of the input file `%s'"), 1939 bfd_get_archive_filename (ibfd)); 1940 else 1941 non_fatal (_("Output file cannot represent architecture `%s'"), 1942 bfd_printable_arch_mach (bfd_get_arch (ibfd), 1943 bfd_get_mach (ibfd))); 1944 return FALSE; 1945 } 1946 1947 if (!bfd_set_format (obfd, bfd_get_format (ibfd))) 1948 { 1949 bfd_nonfatal_message (NULL, ibfd, NULL, NULL); 1950 return FALSE; 1951 } 1952 1953 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour 1954 && bfd_pei_p (obfd)) 1955 { 1956 /* Set up PE parameters. */ 1957 pe_data_type *pe = pe_data (obfd); 1958 1959 /* Copy PE parameters before changing them. */ 1960 if (ibfd->xvec->flavour == bfd_target_coff_flavour 1961 && bfd_pei_p (ibfd)) 1962 pe->pe_opthdr = pe_data (ibfd)->pe_opthdr; 1963 1964 if (pe_file_alignment != (bfd_vma) -1) 1965 pe->pe_opthdr.FileAlignment = pe_file_alignment; 1966 else 1967 pe_file_alignment = PE_DEF_FILE_ALIGNMENT; 1968 1969 if (pe_heap_commit != (bfd_vma) -1) 1970 pe->pe_opthdr.SizeOfHeapCommit = pe_heap_commit; 1971 1972 if (pe_heap_reserve != (bfd_vma) -1) 1973 pe->pe_opthdr.SizeOfHeapCommit = pe_heap_reserve; 1974 1975 if (pe_image_base != (bfd_vma) -1) 1976 pe->pe_opthdr.ImageBase = pe_image_base; 1977 1978 if (pe_section_alignment != (bfd_vma) -1) 1979 pe->pe_opthdr.SectionAlignment = pe_section_alignment; 1980 else 1981 pe_section_alignment = PE_DEF_SECTION_ALIGNMENT; 1982 1983 if (pe_stack_commit != (bfd_vma) -1) 1984 pe->pe_opthdr.SizeOfStackCommit = pe_stack_commit; 1985 1986 if (pe_stack_reserve != (bfd_vma) -1) 1987 pe->pe_opthdr.SizeOfStackCommit = pe_stack_reserve; 1988 1989 if (pe_subsystem != -1) 1990 pe->pe_opthdr.Subsystem = pe_subsystem; 1991 1992 if (pe_major_subsystem_version != -1) 1993 pe->pe_opthdr.MajorSubsystemVersion = pe_major_subsystem_version; 1994 1995 if (pe_minor_subsystem_version != -1) 1996 pe->pe_opthdr.MinorSubsystemVersion = pe_minor_subsystem_version; 1997 1998 if (pe_file_alignment > pe_section_alignment) 1999 { 2000 char file_alignment[20], section_alignment[20]; 2001 2002 sprintf_vma (file_alignment, pe_file_alignment); 2003 sprintf_vma (section_alignment, pe_section_alignment); 2004 non_fatal (_("warning: file alignment (0x%s) > section alignment (0x%s)"), 2005 2006 file_alignment, section_alignment); 2007 } 2008 } 2009 2010 if (isympp) 2011 free (isympp); 2012 2013 if (osympp != isympp) 2014 free (osympp); 2015 2016 isympp = NULL; 2017 osympp = NULL; 2018 2019 symsize = bfd_get_symtab_upper_bound (ibfd); 2020 if (symsize < 0) 2021 { 2022 bfd_nonfatal_message (NULL, ibfd, NULL, NULL); 2023 return FALSE; 2024 } 2025 2026 osympp = isympp = (asymbol **) xmalloc (symsize); 2027 symcount = bfd_canonicalize_symtab (ibfd, isympp); 2028 if (symcount < 0) 2029 { 2030 bfd_nonfatal_message (NULL, ibfd, NULL, NULL); 2031 return FALSE; 2032 } 2033 /* PR 17512: file: d6323821 2034 If the symbol table could not be loaded do not pretend that we have 2035 any symbols. This trips us up later on when we load the relocs. */ 2036 if (symcount == 0) 2037 { 2038 free (isympp); 2039 osympp = isympp = NULL; 2040 } 2041 2042 /* BFD mandates that all output sections be created and sizes set before 2043 any output is done. Thus, we traverse all sections multiple times. */ 2044 bfd_map_over_sections (ibfd, setup_section, obfd); 2045 2046 if (!extract_symbol) 2047 setup_bfd_headers (ibfd, obfd); 2048 2049 if (add_sections != NULL) 2050 { 2051 struct section_add *padd; 2052 struct section_list *pset; 2053 2054 for (padd = add_sections; padd != NULL; padd = padd->next) 2055 { 2056 flagword flags; 2057 2058 pset = find_section_list (padd->name, FALSE, 2059 SECTION_CONTEXT_SET_FLAGS); 2060 if (pset != NULL) 2061 flags = pset->flags | SEC_HAS_CONTENTS; 2062 else 2063 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA; 2064 2065 /* bfd_make_section_with_flags() does not return very helpful 2066 error codes, so check for the most likely user error first. */ 2067 if (bfd_get_section_by_name (obfd, padd->name)) 2068 { 2069 bfd_nonfatal_message (NULL, obfd, NULL, 2070 _("can't add section '%s'"), padd->name); 2071 return FALSE; 2072 } 2073 else 2074 { 2075 /* We use LINKER_CREATED here so that the backend hooks 2076 will create any special section type information, 2077 instead of presuming we know what we're doing merely 2078 because we set the flags. */ 2079 padd->section = bfd_make_section_with_flags 2080 (obfd, padd->name, flags | SEC_LINKER_CREATED); 2081 if (padd->section == NULL) 2082 { 2083 bfd_nonfatal_message (NULL, obfd, NULL, 2084 _("can't create section `%s'"), 2085 padd->name); 2086 return FALSE; 2087 } 2088 } 2089 2090 if (! bfd_set_section_size (obfd, padd->section, padd->size)) 2091 { 2092 bfd_nonfatal_message (NULL, obfd, padd->section, NULL); 2093 return FALSE; 2094 } 2095 2096 pset = find_section_list (padd->name, FALSE, 2097 SECTION_CONTEXT_SET_VMA | SECTION_CONTEXT_ALTER_VMA); 2098 if (pset != NULL 2099 && ! bfd_set_section_vma (obfd, padd->section, pset->vma_val)) 2100 { 2101 bfd_nonfatal_message (NULL, obfd, padd->section, NULL); 2102 return FALSE; 2103 } 2104 2105 pset = find_section_list (padd->name, FALSE, 2106 SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_ALTER_LMA); 2107 if (pset != NULL) 2108 { 2109 padd->section->lma = pset->lma_val; 2110 2111 if (! bfd_set_section_alignment 2112 (obfd, padd->section, 2113 bfd_section_alignment (obfd, padd->section))) 2114 { 2115 bfd_nonfatal_message (NULL, obfd, padd->section, NULL); 2116 return FALSE; 2117 } 2118 } 2119 } 2120 } 2121 2122 if (update_sections != NULL) 2123 { 2124 struct section_add *pupdate; 2125 2126 for (pupdate = update_sections; 2127 pupdate != NULL; 2128 pupdate = pupdate->next) 2129 { 2130 asection *osec; 2131 2132 pupdate->section = bfd_get_section_by_name (ibfd, pupdate->name); 2133 if (pupdate->section == NULL) 2134 { 2135 non_fatal (_("error: %s not found, can't be updated"), pupdate->name); 2136 return FALSE; 2137 } 2138 2139 osec = pupdate->section->output_section; 2140 if (! bfd_set_section_size (obfd, osec, pupdate->size)) 2141 { 2142 bfd_nonfatal_message (NULL, obfd, osec, NULL); 2143 return FALSE; 2144 } 2145 } 2146 } 2147 2148 if (dump_sections != NULL) 2149 { 2150 struct section_add * pdump; 2151 2152 for (pdump = dump_sections; pdump != NULL; pdump = pdump->next) 2153 { 2154 asection * sec; 2155 2156 sec = bfd_get_section_by_name (ibfd, pdump->name); 2157 if (sec == NULL) 2158 { 2159 bfd_nonfatal_message (NULL, ibfd, NULL, 2160 _("can't dump section '%s' - it does not exist"), 2161 pdump->name); 2162 continue; 2163 } 2164 2165 if ((bfd_get_section_flags (ibfd, sec) & SEC_HAS_CONTENTS) == 0) 2166 { 2167 bfd_nonfatal_message (NULL, ibfd, sec, 2168 _("can't dump section - it has no contents")); 2169 continue; 2170 } 2171 2172 bfd_size_type size = bfd_get_section_size (sec); 2173 if (size == 0) 2174 { 2175 bfd_nonfatal_message (NULL, ibfd, sec, 2176 _("can't dump section - it is empty")); 2177 continue; 2178 } 2179 2180 FILE * f; 2181 f = fopen (pdump->filename, FOPEN_WB); 2182 if (f == NULL) 2183 { 2184 bfd_nonfatal_message (pdump->filename, NULL, NULL, 2185 _("could not open section dump file")); 2186 continue; 2187 } 2188 2189 bfd_byte * contents = xmalloc (size); 2190 if (bfd_get_section_contents (ibfd, sec, contents, 0, size)) 2191 { 2192 if (fwrite (contents, 1, size, f) != size) 2193 { 2194 non_fatal (_("error writing section contents to %s (error: %s)"), 2195 pdump->filename, 2196 strerror (errno)); 2197 return FALSE; 2198 } 2199 } 2200 else 2201 bfd_nonfatal_message (NULL, ibfd, sec, 2202 _("could not retrieve section contents")); 2203 2204 fclose (f); 2205 free (contents); 2206 } 2207 } 2208 2209 if (gnu_debuglink_filename != NULL) 2210 { 2211 /* PR 15125: Give a helpful warning message if 2212 the debuglink section already exists, and 2213 allow the rest of the copy to complete. */ 2214 if (bfd_get_section_by_name (obfd, ".gnu_debuglink")) 2215 { 2216 non_fatal (_("%s: debuglink section already exists"), 2217 bfd_get_filename (obfd)); 2218 gnu_debuglink_filename = NULL; 2219 } 2220 else 2221 { 2222 gnu_debuglink_section = bfd_create_gnu_debuglink_section 2223 (obfd, gnu_debuglink_filename); 2224 2225 if (gnu_debuglink_section == NULL) 2226 { 2227 bfd_nonfatal_message (NULL, obfd, NULL, 2228 _("cannot create debug link section `%s'"), 2229 gnu_debuglink_filename); 2230 return FALSE; 2231 } 2232 2233 /* Special processing for PE format files. We 2234 have no way to distinguish PE from COFF here. */ 2235 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour) 2236 { 2237 bfd_vma debuglink_vma; 2238 asection * highest_section; 2239 asection * sec; 2240 2241 /* The PE spec requires that all sections be adjacent and sorted 2242 in ascending order of VMA. It also specifies that debug 2243 sections should be last. This is despite the fact that debug 2244 sections are not loaded into memory and so in theory have no 2245 use for a VMA. 2246 2247 This means that the debuglink section must be given a non-zero 2248 VMA which makes it contiguous with other debug sections. So 2249 walk the current section list, find the section with the 2250 highest VMA and start the debuglink section after that one. */ 2251 for (sec = obfd->sections, highest_section = NULL; 2252 sec != NULL; 2253 sec = sec->next) 2254 if (sec->vma > 0 2255 && (highest_section == NULL 2256 || sec->vma > highest_section->vma)) 2257 highest_section = sec; 2258 2259 if (highest_section) 2260 debuglink_vma = BFD_ALIGN (highest_section->vma 2261 + highest_section->size, 2262 /* FIXME: We ought to be using 2263 COFF_PAGE_SIZE here or maybe 2264 bfd_get_section_alignment() (if it 2265 was set) but since this is for PE 2266 and we know the required alignment 2267 it is easier just to hard code it. */ 2268 0x1000); 2269 else 2270 /* Umm, not sure what to do in this case. */ 2271 debuglink_vma = 0x1000; 2272 2273 bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma); 2274 } 2275 } 2276 } 2277 2278 c = bfd_count_sections (obfd); 2279 if (c != 0 2280 && (gap_fill_set || pad_to_set)) 2281 { 2282 asection **set; 2283 2284 /* We must fill in gaps between the sections and/or we must pad 2285 the last section to a specified address. We do this by 2286 grabbing a list of the sections, sorting them by VMA, and 2287 increasing the section sizes as required to fill the gaps. 2288 We write out the gap contents below. */ 2289 2290 osections = (asection **) xmalloc (c * sizeof (asection *)); 2291 set = osections; 2292 bfd_map_over_sections (obfd, get_sections, &set); 2293 2294 qsort (osections, c, sizeof (asection *), compare_section_lma); 2295 2296 gaps = (bfd_size_type *) xmalloc (c * sizeof (bfd_size_type)); 2297 memset (gaps, 0, c * sizeof (bfd_size_type)); 2298 2299 if (gap_fill_set) 2300 { 2301 for (i = 0; i < c - 1; i++) 2302 { 2303 flagword flags; 2304 bfd_size_type size; 2305 bfd_vma gap_start, gap_stop; 2306 2307 flags = bfd_get_section_flags (obfd, osections[i]); 2308 if ((flags & SEC_HAS_CONTENTS) == 0 2309 || (flags & SEC_LOAD) == 0) 2310 continue; 2311 2312 size = bfd_section_size (obfd, osections[i]); 2313 gap_start = bfd_section_lma (obfd, osections[i]) + size; 2314 gap_stop = bfd_section_lma (obfd, osections[i + 1]); 2315 if (gap_start < gap_stop) 2316 { 2317 if (! bfd_set_section_size (obfd, osections[i], 2318 size + (gap_stop - gap_start))) 2319 { 2320 bfd_nonfatal_message (NULL, obfd, osections[i], 2321 _("Can't fill gap after section")); 2322 status = 1; 2323 break; 2324 } 2325 gaps[i] = gap_stop - gap_start; 2326 if (max_gap < gap_stop - gap_start) 2327 max_gap = gap_stop - gap_start; 2328 } 2329 } 2330 } 2331 2332 if (pad_to_set) 2333 { 2334 bfd_vma lma; 2335 bfd_size_type size; 2336 2337 lma = bfd_section_lma (obfd, osections[c - 1]); 2338 size = bfd_section_size (obfd, osections[c - 1]); 2339 if (lma + size < pad_to) 2340 { 2341 if (! bfd_set_section_size (obfd, osections[c - 1], 2342 pad_to - lma)) 2343 { 2344 bfd_nonfatal_message (NULL, obfd, osections[c - 1], 2345 _("can't add padding")); 2346 status = 1; 2347 } 2348 else 2349 { 2350 gaps[c - 1] = pad_to - (lma + size); 2351 if (max_gap < pad_to - (lma + size)) 2352 max_gap = pad_to - (lma + size); 2353 } 2354 } 2355 } 2356 } 2357 2358 /* Symbol filtering must happen after the output sections 2359 have been created, but before their contents are set. */ 2360 dhandle = NULL; 2361 if (convert_debugging) 2362 dhandle = read_debugging_info (ibfd, isympp, symcount, FALSE); 2363 2364 if (strip_symbols == STRIP_DEBUG 2365 || strip_symbols == STRIP_ALL 2366 || strip_symbols == STRIP_UNNEEDED 2367 || strip_symbols == STRIP_NONDEBUG 2368 || strip_symbols == STRIP_DWO 2369 || strip_symbols == STRIP_NONDWO 2370 || discard_locals != LOCALS_UNDEF 2371 || localize_hidden 2372 || htab_elements (strip_specific_htab) != 0 2373 || htab_elements (keep_specific_htab) != 0 2374 || htab_elements (localize_specific_htab) != 0 2375 || htab_elements (globalize_specific_htab) != 0 2376 || htab_elements (keepglobal_specific_htab) != 0 2377 || htab_elements (weaken_specific_htab) != 0 2378 || prefix_symbols_string 2379 || sections_removed 2380 || sections_copied 2381 || convert_debugging 2382 || change_leading_char 2383 || remove_leading_char 2384 || redefine_sym_list 2385 || section_rename_list 2386 || weaken 2387 || add_symbols) 2388 { 2389 /* Mark symbols used in output relocations so that they 2390 are kept, even if they are local labels or static symbols. 2391 2392 Note we iterate over the input sections examining their 2393 relocations since the relocations for the output sections 2394 haven't been set yet. mark_symbols_used_in_relocations will 2395 ignore input sections which have no corresponding output 2396 section. */ 2397 if (strip_symbols != STRIP_ALL) 2398 bfd_map_over_sections (ibfd, 2399 mark_symbols_used_in_relocations, 2400 isympp); 2401 osympp = (asymbol **) xmalloc ((symcount + add_symbols + 1) * sizeof (asymbol *)); 2402 symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount); 2403 } 2404 2405 if (convert_debugging && dhandle != NULL) 2406 { 2407 if (! write_debugging_info (obfd, dhandle, &symcount, &osympp)) 2408 { 2409 status = 1; 2410 return FALSE; 2411 } 2412 } 2413 2414 bfd_set_symtab (obfd, osympp, symcount); 2415 2416 /* This has to happen before section positions are set. */ 2417 bfd_map_over_sections (ibfd, copy_relocations_in_section, obfd); 2418 2419 /* This has to happen after the symbol table has been set. */ 2420 bfd_map_over_sections (ibfd, copy_section, obfd); 2421 2422 if (add_sections != NULL) 2423 { 2424 struct section_add *padd; 2425 2426 for (padd = add_sections; padd != NULL; padd = padd->next) 2427 { 2428 if (! bfd_set_section_contents (obfd, padd->section, padd->contents, 2429 0, padd->size)) 2430 { 2431 bfd_nonfatal_message (NULL, obfd, padd->section, NULL); 2432 return FALSE; 2433 } 2434 } 2435 } 2436 2437 if (update_sections != NULL) 2438 { 2439 struct section_add *pupdate; 2440 2441 for (pupdate = update_sections; 2442 pupdate != NULL; 2443 pupdate = pupdate->next) 2444 { 2445 asection *osec; 2446 2447 osec = pupdate->section->output_section; 2448 if (! bfd_set_section_contents (obfd, osec, pupdate->contents, 2449 0, pupdate->size)) 2450 { 2451 bfd_nonfatal_message (NULL, obfd, osec, NULL); 2452 return FALSE; 2453 } 2454 } 2455 } 2456 2457 if (gnu_debuglink_filename != NULL) 2458 { 2459 if (! bfd_fill_in_gnu_debuglink_section 2460 (obfd, gnu_debuglink_section, gnu_debuglink_filename)) 2461 { 2462 bfd_nonfatal_message (NULL, obfd, NULL, 2463 _("cannot fill debug link section `%s'"), 2464 gnu_debuglink_filename); 2465 return FALSE; 2466 } 2467 } 2468 2469 if (gap_fill_set || pad_to_set) 2470 { 2471 bfd_byte *buf; 2472 2473 /* Fill in the gaps. */ 2474 if (max_gap > 8192) 2475 max_gap = 8192; 2476 buf = (bfd_byte *) xmalloc (max_gap); 2477 memset (buf, gap_fill, max_gap); 2478 2479 c = bfd_count_sections (obfd); 2480 for (i = 0; i < c; i++) 2481 { 2482 if (gaps[i] != 0) 2483 { 2484 bfd_size_type left; 2485 file_ptr off; 2486 2487 left = gaps[i]; 2488 off = bfd_section_size (obfd, osections[i]) - left; 2489 2490 while (left > 0) 2491 { 2492 bfd_size_type now; 2493 2494 if (left > 8192) 2495 now = 8192; 2496 else 2497 now = left; 2498 2499 if (! bfd_set_section_contents (obfd, osections[i], buf, 2500 off, now)) 2501 { 2502 bfd_nonfatal_message (NULL, obfd, osections[i], NULL); 2503 return FALSE; 2504 } 2505 2506 left -= now; 2507 off += now; 2508 } 2509 } 2510 } 2511 } 2512 2513 /* Allow the BFD backend to copy any private data it understands 2514 from the input BFD to the output BFD. This is done last to 2515 permit the routine to look at the filtered symbol table, which is 2516 important for the ECOFF code at least. */ 2517 if (! bfd_copy_private_bfd_data (ibfd, obfd)) 2518 { 2519 bfd_nonfatal_message (NULL, obfd, NULL, 2520 _("error copying private BFD data")); 2521 return FALSE; 2522 } 2523 2524 /* Switch to the alternate machine code. We have to do this at the 2525 very end, because we only initialize the header when we create 2526 the first section. */ 2527 if (use_alt_mach_code != 0) 2528 { 2529 if (! bfd_alt_mach_code (obfd, use_alt_mach_code)) 2530 { 2531 non_fatal (_("this target does not support %lu alternative machine codes"), 2532 use_alt_mach_code); 2533 if (bfd_get_flavour (obfd) == bfd_target_elf_flavour) 2534 { 2535 non_fatal (_("treating that number as an absolute e_machine value instead")); 2536 elf_elfheader (obfd)->e_machine = use_alt_mach_code; 2537 } 2538 else 2539 non_fatal (_("ignoring the alternative value")); 2540 } 2541 } 2542 2543 return TRUE; 2544} 2545 2546/* Read each archive element in turn from IBFD, copy the 2547 contents to temp file, and keep the temp file handle. 2548 If 'force_output_target' is TRUE then make sure that 2549 all elements in the new archive are of the type 2550 'output_target'. */ 2551 2552static void 2553copy_archive (bfd *ibfd, bfd *obfd, const char *output_target, 2554 bfd_boolean force_output_target, 2555 const bfd_arch_info_type *input_arch) 2556{ 2557 struct name_list 2558 { 2559 struct name_list *next; 2560 const char *name; 2561 bfd *obfd; 2562 } *list, *l; 2563 bfd **ptr = &obfd->archive_head; 2564 bfd *this_element; 2565 char *dir; 2566 const char *filename; 2567 2568 /* Make a temp directory to hold the contents. */ 2569 dir = make_tempdir (bfd_get_filename (obfd)); 2570 if (dir == NULL) 2571 fatal (_("cannot create tempdir for archive copying (error: %s)"), 2572 strerror (errno)); 2573 2574 if (strip_symbols == STRIP_ALL) 2575 obfd->has_armap = FALSE; 2576 else 2577 obfd->has_armap = ibfd->has_armap; 2578 obfd->is_thin_archive = ibfd->is_thin_archive; 2579 2580 if (deterministic) 2581 obfd->flags |= BFD_DETERMINISTIC_OUTPUT; 2582 2583 list = NULL; 2584 2585 this_element = bfd_openr_next_archived_file (ibfd, NULL); 2586 2587 if (!bfd_set_format (obfd, bfd_get_format (ibfd))) 2588 { 2589 status = 1; 2590 bfd_nonfatal_message (NULL, obfd, NULL, NULL); 2591 goto cleanup_and_exit; 2592 } 2593 2594 while (!status && this_element != NULL) 2595 { 2596 char *output_name; 2597 bfd *output_bfd; 2598 bfd *last_element; 2599 struct stat buf; 2600 int stat_status = 0; 2601 bfd_boolean del = TRUE; 2602 bfd_boolean ok_object; 2603 2604 /* PR binutils/17533: Do not allow directory traversal 2605 outside of the current directory tree by archive members. */ 2606 if (! is_valid_archive_path (bfd_get_filename (this_element))) 2607 { 2608 non_fatal (_("illegal pathname found in archive member: %s"), 2609 bfd_get_filename (this_element)); 2610 status = 1; 2611 goto cleanup_and_exit; 2612 } 2613 2614 /* Create an output file for this member. */ 2615 output_name = concat (dir, "/", 2616 bfd_get_filename (this_element), (char *) 0); 2617 2618 /* If the file already exists, make another temp dir. */ 2619 if (stat (output_name, &buf) >= 0) 2620 { 2621 output_name = make_tempdir (output_name); 2622 if (output_name == NULL) 2623 { 2624 non_fatal (_("cannot create tempdir for archive copying (error: %s)"), 2625 strerror (errno)); 2626 status = 1; 2627 goto cleanup_and_exit; 2628 } 2629 2630 l = (struct name_list *) xmalloc (sizeof (struct name_list)); 2631 l->name = output_name; 2632 l->next = list; 2633 l->obfd = NULL; 2634 list = l; 2635 output_name = concat (output_name, "/", 2636 bfd_get_filename (this_element), (char *) 0); 2637 } 2638 2639 if (preserve_dates) 2640 { 2641 stat_status = bfd_stat_arch_elt (this_element, &buf); 2642 2643 if (stat_status != 0) 2644 non_fatal (_("internal stat error on %s"), 2645 bfd_get_filename (this_element)); 2646 } 2647 2648 l = (struct name_list *) xmalloc (sizeof (struct name_list)); 2649 l->name = output_name; 2650 l->next = list; 2651 l->obfd = NULL; 2652 list = l; 2653 2654 ok_object = bfd_check_format (this_element, bfd_object); 2655 if (!ok_object) 2656 bfd_nonfatal_message (NULL, this_element, NULL, 2657 _("Unable to recognise the format of file")); 2658 2659 /* PR binutils/3110: Cope with archives 2660 containing multiple target types. */ 2661 if (force_output_target || !ok_object) 2662 output_bfd = bfd_openw (output_name, output_target); 2663 else 2664 output_bfd = bfd_openw (output_name, bfd_get_target (this_element)); 2665 2666 if (output_bfd == NULL) 2667 { 2668 bfd_nonfatal_message (output_name, NULL, NULL, NULL); 2669 status = 1; 2670 goto cleanup_and_exit; 2671 } 2672 2673 if (ok_object) 2674 { 2675 del = !copy_object (this_element, output_bfd, input_arch); 2676 2677 if (del && bfd_get_arch (this_element) == bfd_arch_unknown) 2678 /* Try again as an unknown object file. */ 2679 ok_object = FALSE; 2680 else if (!bfd_close (output_bfd)) 2681 { 2682 bfd_nonfatal_message (output_name, NULL, NULL, NULL); 2683 /* Error in new object file. Don't change archive. */ 2684 status = 1; 2685 } 2686 } 2687 2688 if (!ok_object) 2689 { 2690 del = !copy_unknown_object (this_element, output_bfd); 2691 if (!bfd_close_all_done (output_bfd)) 2692 { 2693 bfd_nonfatal_message (output_name, NULL, NULL, NULL); 2694 /* Error in new object file. Don't change archive. */ 2695 status = 1; 2696 } 2697 } 2698 2699 if (del) 2700 { 2701 unlink (output_name); 2702 status = 1; 2703 } 2704 else 2705 { 2706 if (preserve_dates && stat_status == 0) 2707 set_times (output_name, &buf); 2708 2709 /* Open the newly output file and attach to our list. */ 2710 output_bfd = bfd_openr (output_name, output_target); 2711 2712 l->obfd = output_bfd; 2713 2714 *ptr = output_bfd; 2715 ptr = &output_bfd->archive_next; 2716 2717 last_element = this_element; 2718 2719 this_element = bfd_openr_next_archived_file (ibfd, last_element); 2720 2721 bfd_close (last_element); 2722 } 2723 } 2724 *ptr = NULL; 2725 2726 filename = bfd_get_filename (obfd); 2727 if (!bfd_close (obfd)) 2728 { 2729 status = 1; 2730 bfd_nonfatal_message (filename, NULL, NULL, NULL); 2731 } 2732 2733 filename = bfd_get_filename (ibfd); 2734 if (!bfd_close (ibfd)) 2735 { 2736 status = 1; 2737 bfd_nonfatal_message (filename, NULL, NULL, NULL); 2738 } 2739 2740 cleanup_and_exit: 2741 /* Delete all the files that we opened. */ 2742 for (l = list; l != NULL; l = l->next) 2743 { 2744 if (l->obfd == NULL) 2745 rmdir (l->name); 2746 else 2747 { 2748 bfd_close (l->obfd); 2749 unlink (l->name); 2750 } 2751 } 2752 2753 rmdir (dir); 2754} 2755 2756static void 2757set_long_section_mode (bfd *output_bfd, bfd *input_bfd, enum long_section_name_handling style) 2758{ 2759 /* This is only relevant to Coff targets. */ 2760 if (bfd_get_flavour (output_bfd) == bfd_target_coff_flavour) 2761 { 2762 if (style == KEEP 2763 && bfd_get_flavour (input_bfd) == bfd_target_coff_flavour) 2764 style = bfd_coff_long_section_names (input_bfd) ? ENABLE : DISABLE; 2765 bfd_coff_set_long_section_names (output_bfd, style != DISABLE); 2766 } 2767} 2768 2769/* The top-level control. */ 2770 2771static void 2772copy_file (const char *input_filename, const char *output_filename, 2773 const char *input_target, const char *output_target, 2774 const bfd_arch_info_type *input_arch) 2775{ 2776 bfd *ibfd; 2777 char **obj_matching; 2778 char **core_matching; 2779 off_t size = get_file_size (input_filename); 2780 2781 if (size < 1) 2782 { 2783 if (size == 0) 2784 non_fatal (_("error: the input file '%s' is empty"), 2785 input_filename); 2786 status = 1; 2787 return; 2788 } 2789 2790 /* To allow us to do "strip *" without dying on the first 2791 non-object file, failures are nonfatal. */ 2792 ibfd = bfd_openr (input_filename, input_target); 2793 if (ibfd == NULL) 2794 { 2795 bfd_nonfatal_message (input_filename, NULL, NULL, NULL); 2796 status = 1; 2797 return; 2798 } 2799 2800 switch (do_debug_sections) 2801 { 2802 case compress: 2803 case compress_zlib: 2804 case compress_gnu_zlib: 2805 case compress_gabi_zlib: 2806 ibfd->flags |= BFD_COMPRESS; 2807 /* Don't check if input is ELF here since this information is 2808 only available after bfd_check_format_matches is called. */ 2809 if (do_debug_sections != compress_gnu_zlib) 2810 ibfd->flags |= BFD_COMPRESS_GABI; 2811 break; 2812 case decompress: 2813 ibfd->flags |= BFD_DECOMPRESS; 2814 break; 2815 default: 2816 break; 2817 } 2818 2819 switch (do_elf_stt_common) 2820 { 2821 case elf_stt_common: 2822 ibfd->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON; 2823 break; 2824 break; 2825 case no_elf_stt_common: 2826 ibfd->flags |= BFD_CONVERT_ELF_COMMON; 2827 break; 2828 default: 2829 break; 2830 } 2831 2832 if (bfd_check_format (ibfd, bfd_archive)) 2833 { 2834 bfd_boolean force_output_target; 2835 bfd *obfd; 2836 2837 /* bfd_get_target does not return the correct value until 2838 bfd_check_format succeeds. */ 2839 if (output_target == NULL) 2840 { 2841 output_target = bfd_get_target (ibfd); 2842 force_output_target = FALSE; 2843 } 2844 else 2845 force_output_target = TRUE; 2846 2847 obfd = bfd_openw (output_filename, output_target); 2848 if (obfd == NULL) 2849 { 2850 bfd_nonfatal_message (output_filename, NULL, NULL, NULL); 2851 status = 1; 2852 return; 2853 } 2854 /* This is a no-op on non-Coff targets. */ 2855 set_long_section_mode (obfd, ibfd, long_section_names); 2856 2857 copy_archive (ibfd, obfd, output_target, force_output_target, input_arch); 2858 } 2859 else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching)) 2860 { 2861 bfd *obfd; 2862 do_copy: 2863 2864 /* bfd_get_target does not return the correct value until 2865 bfd_check_format succeeds. */ 2866 if (output_target == NULL) 2867 output_target = bfd_get_target (ibfd); 2868 2869 obfd = bfd_openw (output_filename, output_target); 2870 if (obfd == NULL) 2871 { 2872 bfd_nonfatal_message (output_filename, NULL, NULL, NULL); 2873 status = 1; 2874 return; 2875 } 2876 /* This is a no-op on non-Coff targets. */ 2877 set_long_section_mode (obfd, ibfd, long_section_names); 2878 2879 if (! copy_object (ibfd, obfd, input_arch)) 2880 status = 1; 2881 2882 /* PR 17512: file: 0f15796a. 2883 If the file could not be copied it may not be in a writeable 2884 state. So use bfd_close_all_done to avoid the possibility of 2885 writing uninitialised data into the file. */ 2886 if (! (status ? bfd_close_all_done (obfd) : bfd_close (obfd))) 2887 { 2888 status = 1; 2889 bfd_nonfatal_message (output_filename, NULL, NULL, NULL); 2890 return; 2891 } 2892 2893 if (!bfd_close (ibfd)) 2894 { 2895 status = 1; 2896 bfd_nonfatal_message (input_filename, NULL, NULL, NULL); 2897 return; 2898 } 2899 } 2900 else 2901 { 2902 bfd_error_type obj_error = bfd_get_error (); 2903 bfd_error_type core_error; 2904 2905 if (bfd_check_format_matches (ibfd, bfd_core, &core_matching)) 2906 { 2907 /* This probably can't happen.. */ 2908 if (obj_error == bfd_error_file_ambiguously_recognized) 2909 free (obj_matching); 2910 goto do_copy; 2911 } 2912 2913 core_error = bfd_get_error (); 2914 /* Report the object error in preference to the core error. */ 2915 if (obj_error != core_error) 2916 bfd_set_error (obj_error); 2917 2918 bfd_nonfatal_message (input_filename, NULL, NULL, NULL); 2919 2920 if (obj_error == bfd_error_file_ambiguously_recognized) 2921 { 2922 list_matching_formats (obj_matching); 2923 free (obj_matching); 2924 } 2925 if (core_error == bfd_error_file_ambiguously_recognized) 2926 { 2927 list_matching_formats (core_matching); 2928 free (core_matching); 2929 } 2930 2931 status = 1; 2932 } 2933} 2934 2935/* Add a name to the section renaming list. */ 2936 2937static void 2938add_section_rename (const char * old_name, const char * new_name, 2939 flagword flags) 2940{ 2941 section_rename * srename; 2942 2943 /* Check for conflicts first. */ 2944 for (srename = section_rename_list; srename != NULL; srename = srename->next) 2945 if (strcmp (srename->old_name, old_name) == 0) 2946 { 2947 /* Silently ignore duplicate definitions. */ 2948 if (strcmp (srename->new_name, new_name) == 0 2949 && srename->flags == flags) 2950 return; 2951 2952 fatal (_("Multiple renames of section %s"), old_name); 2953 } 2954 2955 srename = (section_rename *) xmalloc (sizeof (* srename)); 2956 2957 srename->old_name = old_name; 2958 srename->new_name = new_name; 2959 srename->flags = flags; 2960 srename->next = section_rename_list; 2961 2962 section_rename_list = srename; 2963} 2964 2965/* Check the section rename list for a new name of the input section 2966 called OLD_NAME. Returns the new name if one is found and sets 2967 RETURNED_FLAGS if non-NULL to the flags to be used for this section. */ 2968 2969static const char * 2970find_section_rename (const char *old_name, flagword *returned_flags) 2971{ 2972 const section_rename *srename; 2973 2974 for (srename = section_rename_list; srename != NULL; srename = srename->next) 2975 if (strcmp (srename->old_name, old_name) == 0) 2976 { 2977 if (returned_flags != NULL && srename->flags != (flagword) -1) 2978 *returned_flags = srename->flags; 2979 2980 return srename->new_name; 2981 } 2982 2983 return old_name; 2984} 2985 2986/* Once each of the sections is copied, we may still need to do some 2987 finalization work for private section headers. Do that here. */ 2988 2989static void 2990setup_bfd_headers (bfd *ibfd, bfd *obfd) 2991{ 2992 /* Allow the BFD backend to copy any private data it understands 2993 from the input section to the output section. */ 2994 if (! bfd_copy_private_header_data (ibfd, obfd)) 2995 { 2996 status = 1; 2997 bfd_nonfatal_message (NULL, ibfd, NULL, 2998 _("error in private header data")); 2999 return; 3000 } 3001 3002 /* All went well. */ 3003 return; 3004} 3005 3006/* Create a section in OBFD with the same 3007 name and attributes as ISECTION in IBFD. */ 3008 3009static void 3010setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg) 3011{ 3012 bfd *obfd = (bfd *) obfdarg; 3013 struct section_list *p; 3014 sec_ptr osection; 3015 bfd_size_type size; 3016 bfd_vma vma; 3017 bfd_vma lma; 3018 flagword flags; 3019 const char *err; 3020 const char * name; 3021 char *prefix = NULL; 3022 bfd_boolean make_nobits; 3023 3024 if (is_strip_section (ibfd, isection)) 3025 return; 3026 3027 /* Get the, possibly new, name of the output section. */ 3028 name = bfd_section_name (ibfd, isection); 3029 flags = bfd_get_section_flags (ibfd, isection); 3030 name = find_section_rename (name, &flags); 3031 3032 /* Prefix sections. */ 3033 if ((prefix_alloc_sections_string) 3034 && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC)) 3035 prefix = prefix_alloc_sections_string; 3036 else if (prefix_sections_string) 3037 prefix = prefix_sections_string; 3038 3039 if (prefix) 3040 { 3041 char *n; 3042 3043 n = (char *) xmalloc (strlen (prefix) + strlen (name) + 1); 3044 strcpy (n, prefix); 3045 strcat (n, name); 3046 name = n; 3047 } 3048 3049 make_nobits = FALSE; 3050 3051 p = find_section_list (bfd_section_name (ibfd, isection), FALSE, 3052 SECTION_CONTEXT_SET_FLAGS); 3053 if (p != NULL) 3054 flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC)); 3055 else if (strip_symbols == STRIP_NONDEBUG 3056 && (flags & (SEC_ALLOC | SEC_GROUP)) != 0 3057 && !is_nondebug_keep_contents_section (ibfd, isection)) 3058 { 3059 flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP); 3060 if (obfd->xvec->flavour == bfd_target_elf_flavour) 3061 { 3062 make_nobits = TRUE; 3063 3064 /* Twiddle the input section flags so that it seems to 3065 elf.c:copy_private_bfd_data that section flags have not 3066 changed between input and output sections. This hack 3067 prevents wholesale rewriting of the program headers. */ 3068 isection->flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP); 3069 } 3070 } 3071 3072 osection = bfd_make_section_anyway_with_flags (obfd, name, flags); 3073 3074 if (osection == NULL) 3075 { 3076 err = _("failed to create output section"); 3077 goto loser; 3078 } 3079 3080 if (make_nobits) 3081 elf_section_type (osection) = SHT_NOBITS; 3082 3083 size = bfd_section_size (ibfd, isection); 3084 size = bfd_convert_section_size (ibfd, isection, obfd, size); 3085 if (copy_byte >= 0) 3086 size = (size + interleave - 1) / interleave * copy_width; 3087 else if (extract_symbol) 3088 size = 0; 3089 if (! bfd_set_section_size (obfd, osection, size)) 3090 { 3091 err = _("failed to set size"); 3092 goto loser; 3093 } 3094 3095 vma = bfd_section_vma (ibfd, isection); 3096 p = find_section_list (bfd_section_name (ibfd, isection), FALSE, 3097 SECTION_CONTEXT_ALTER_VMA | SECTION_CONTEXT_SET_VMA); 3098 if (p != NULL) 3099 { 3100 if (p->context & SECTION_CONTEXT_SET_VMA) 3101 vma = p->vma_val; 3102 else 3103 vma += p->vma_val; 3104 } 3105 else 3106 vma += change_section_address; 3107 3108 if (! bfd_set_section_vma (obfd, osection, vma)) 3109 { 3110 err = _("failed to set vma"); 3111 goto loser; 3112 } 3113 3114 lma = isection->lma; 3115 p = find_section_list (bfd_section_name (ibfd, isection), FALSE, 3116 SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_SET_LMA); 3117 if (p != NULL) 3118 { 3119 if (p->context & SECTION_CONTEXT_ALTER_LMA) 3120 lma += p->lma_val; 3121 else 3122 lma = p->lma_val; 3123 } 3124 else 3125 lma += change_section_address; 3126 3127 osection->lma = lma; 3128 3129 /* FIXME: This is probably not enough. If we change the LMA we 3130 may have to recompute the header for the file as well. */ 3131 if (!bfd_set_section_alignment (obfd, 3132 osection, 3133 bfd_section_alignment (ibfd, isection))) 3134 { 3135 err = _("failed to set alignment"); 3136 goto loser; 3137 } 3138 3139 /* Copy merge entity size. */ 3140 osection->entsize = isection->entsize; 3141 3142 /* Copy compress status. */ 3143 osection->compress_status = isection->compress_status; 3144 3145 /* This used to be mangle_section; we do here to avoid using 3146 bfd_get_section_by_name since some formats allow multiple 3147 sections with the same name. */ 3148 isection->output_section = osection; 3149 isection->output_offset = 0; 3150 3151 if ((isection->flags & SEC_GROUP) != 0) 3152 { 3153 asymbol *gsym = group_signature (isection); 3154 3155 if (gsym != NULL) 3156 { 3157 gsym->flags |= BSF_KEEP; 3158 if (ibfd->xvec->flavour == bfd_target_elf_flavour) 3159 elf_group_id (isection) = gsym; 3160 } 3161 } 3162 3163 /* Allow the BFD backend to copy any private data it understands 3164 from the input section to the output section. */ 3165 if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection)) 3166 { 3167 err = _("failed to copy private data"); 3168 goto loser; 3169 } 3170 3171 /* All went well. */ 3172 return; 3173 3174 loser: 3175 status = 1; 3176 bfd_nonfatal_message (NULL, obfd, osection, err); 3177} 3178 3179/* Return TRUE if input section ISECTION should be skipped. */ 3180 3181static bfd_boolean 3182skip_section (bfd *ibfd, sec_ptr isection) 3183{ 3184 sec_ptr osection; 3185 bfd_size_type size; 3186 flagword flags; 3187 3188 /* If we have already failed earlier on, 3189 do not keep on generating complaints now. */ 3190 if (status != 0) 3191 return TRUE; 3192 3193 if (extract_symbol) 3194 return TRUE; 3195 3196 if (is_strip_section (ibfd, isection)) 3197 return TRUE; 3198 3199 if (is_update_section (ibfd, isection)) 3200 return TRUE; 3201 3202 flags = bfd_get_section_flags (ibfd, isection); 3203 if ((flags & SEC_GROUP) != 0) 3204 return TRUE; 3205 3206 osection = isection->output_section; 3207 size = bfd_get_section_size (isection); 3208 3209 if (size == 0 || osection == 0) 3210 return TRUE; 3211 3212 return FALSE; 3213} 3214 3215/* Add section SECTION_PATTERN to the list of sections that will have their 3216 relocations removed. */ 3217 3218static void 3219handle_remove_relocations_option (const char *section_pattern) 3220{ 3221 find_section_list (section_pattern, TRUE, SECTION_CONTEXT_REMOVE_RELOCS); 3222} 3223 3224/* Return TRUE if ISECTION from IBFD should have its relocations removed, 3225 otherwise return FALSE. If the user has requested that relocations be 3226 removed from a section that does not have relocations then this 3227 function will still return TRUE. */ 3228 3229static bfd_boolean 3230discard_relocations (bfd *ibfd ATTRIBUTE_UNUSED, asection *isection) 3231{ 3232 return (find_section_list (bfd_section_name (ibfd, isection), FALSE, 3233 SECTION_CONTEXT_REMOVE_RELOCS) != NULL); 3234} 3235 3236/* Wrapper for dealing with --remove-section (-R) command line arguments. 3237 A special case is detected here, if the user asks to remove a relocation 3238 section (one starting with ".rela." or ".rel.") then this removal must 3239 be done using a different technique. */ 3240 3241static void 3242handle_remove_section_option (const char *section_pattern) 3243{ 3244 if (strncmp (section_pattern, ".rela.", 6) == 0) 3245 handle_remove_relocations_option (section_pattern + 5); 3246 else if (strncmp (section_pattern, ".rel.", 5) == 0) 3247 handle_remove_relocations_option (section_pattern + 4); 3248 else 3249 { 3250 find_section_list (section_pattern, TRUE, SECTION_CONTEXT_REMOVE); 3251 sections_removed = TRUE; 3252 } 3253} 3254 3255/* Copy relocations in input section ISECTION of IBFD to an output 3256 section with the same name in OBFDARG. If stripping then don't 3257 copy any relocation info. */ 3258 3259static void 3260copy_relocations_in_section (bfd *ibfd, sec_ptr isection, void *obfdarg) 3261{ 3262 bfd *obfd = (bfd *) obfdarg; 3263 long relsize; 3264 arelent **relpp; 3265 long relcount; 3266 sec_ptr osection; 3267 3268 if (skip_section (ibfd, isection)) 3269 return; 3270 3271 osection = isection->output_section; 3272 3273 /* Core files and DWO files do not need to be relocated. */ 3274 if (bfd_get_format (obfd) == bfd_core 3275 || strip_symbols == STRIP_NONDWO 3276 || discard_relocations (ibfd, isection)) 3277 relsize = 0; 3278 else 3279 { 3280 relsize = bfd_get_reloc_upper_bound (ibfd, isection); 3281 3282 if (relsize < 0) 3283 { 3284 /* Do not complain if the target does not support relocations. */ 3285 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation) 3286 relsize = 0; 3287 else 3288 { 3289 status = 1; 3290 bfd_nonfatal_message (NULL, ibfd, isection, NULL); 3291 return; 3292 } 3293 } 3294 } 3295 3296 if (relsize == 0) 3297 { 3298 bfd_set_reloc (obfd, osection, NULL, 0); 3299 osection->flags &= ~SEC_RELOC; 3300 } 3301 else 3302 { 3303 relpp = (arelent **) xmalloc (relsize); 3304 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp); 3305 if (relcount < 0) 3306 { 3307 status = 1; 3308 bfd_nonfatal_message (NULL, ibfd, isection, 3309 _("relocation count is negative")); 3310 return; 3311 } 3312 3313 if (strip_symbols == STRIP_ALL) 3314 { 3315 /* Remove relocations which are not in 3316 keep_strip_specific_list. */ 3317 arelent **temp_relpp; 3318 long temp_relcount = 0; 3319 long i; 3320 3321 temp_relpp = (arelent **) xmalloc (relsize); 3322 for (i = 0; i < relcount; i++) 3323 { 3324 /* PR 17512: file: 9e907e0c. */ 3325 if (relpp[i]->sym_ptr_ptr 3326 /* PR 20096 */ 3327 && * relpp[i]->sym_ptr_ptr) 3328 if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr), 3329 keep_specific_htab)) 3330 temp_relpp [temp_relcount++] = relpp [i]; 3331 } 3332 relcount = temp_relcount; 3333 free (relpp); 3334 relpp = temp_relpp; 3335 } 3336 3337 bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount); 3338 if (relcount == 0) 3339 { 3340 osection->flags &= ~SEC_RELOC; 3341 free (relpp); 3342 } 3343 } 3344} 3345 3346/* Copy the data of input section ISECTION of IBFD 3347 to an output section with the same name in OBFD. */ 3348 3349static void 3350copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg) 3351{ 3352 bfd *obfd = (bfd *) obfdarg; 3353 struct section_list *p; 3354 sec_ptr osection; 3355 bfd_size_type size; 3356 3357 if (skip_section (ibfd, isection)) 3358 return; 3359 3360 osection = isection->output_section; 3361 /* The output SHF_COMPRESSED section size is different from input if 3362 ELF classes of input and output aren't the same. We can't use 3363 the output section size since --interleave will shrink the output 3364 section. Size will be updated if the section is converted. */ 3365 size = bfd_get_section_size (isection); 3366 3367 if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS 3368 && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS) 3369 { 3370 bfd_byte *memhunk = NULL; 3371 3372 if (!bfd_get_full_section_contents (ibfd, isection, &memhunk) 3373 || !bfd_convert_section_contents (ibfd, isection, obfd, 3374 &memhunk, &size)) 3375 { 3376 status = 1; 3377 bfd_nonfatal_message (NULL, ibfd, isection, NULL); 3378 free (memhunk); 3379 return; 3380 } 3381 3382 if (reverse_bytes) 3383 { 3384 /* We don't handle leftover bytes (too many possible behaviors, 3385 and we don't know what the user wants). The section length 3386 must be a multiple of the number of bytes to swap. */ 3387 if ((size % reverse_bytes) == 0) 3388 { 3389 unsigned long i, j; 3390 bfd_byte b; 3391 3392 for (i = 0; i < size; i += reverse_bytes) 3393 for (j = 0; j < (unsigned long)(reverse_bytes / 2); j++) 3394 { 3395 bfd_byte *m = (bfd_byte *) memhunk; 3396 3397 b = m[i + j]; 3398 m[i + j] = m[(i + reverse_bytes) - (j + 1)]; 3399 m[(i + reverse_bytes) - (j + 1)] = b; 3400 } 3401 } 3402 else 3403 /* User must pad the section up in order to do this. */ 3404 fatal (_("cannot reverse bytes: length of section %s must be evenly divisible by %d"), 3405 bfd_section_name (ibfd, isection), reverse_bytes); 3406 } 3407 3408 if (copy_byte >= 0) 3409 { 3410 /* Keep only every `copy_byte'th byte in MEMHUNK. */ 3411 char *from = (char *) memhunk + copy_byte; 3412 char *to = (char *) memhunk; 3413 char *end = (char *) memhunk + size; 3414 int i; 3415 3416 for (; from < end; from += interleave) 3417 for (i = 0; i < copy_width; i++) 3418 { 3419 if (&from[i] >= end) 3420 break; 3421 *to++ = from[i]; 3422 } 3423 3424 size = (size + interleave - 1 - copy_byte) / interleave * copy_width; 3425 osection->lma /= interleave; 3426 } 3427 3428 if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size)) 3429 { 3430 status = 1; 3431 bfd_nonfatal_message (NULL, obfd, osection, NULL); 3432 free (memhunk); 3433 return; 3434 } 3435 free (memhunk); 3436 } 3437 else if ((p = find_section_list (bfd_get_section_name (ibfd, isection), 3438 FALSE, SECTION_CONTEXT_SET_FLAGS)) != NULL 3439 && (p->flags & SEC_HAS_CONTENTS) != 0) 3440 { 3441 void *memhunk = xmalloc (size); 3442 3443 /* We don't permit the user to turn off the SEC_HAS_CONTENTS 3444 flag--they can just remove the section entirely and add it 3445 back again. However, we do permit them to turn on the 3446 SEC_HAS_CONTENTS flag, and take it to mean that the section 3447 contents should be zeroed out. */ 3448 3449 memset (memhunk, 0, size); 3450 if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size)) 3451 { 3452 status = 1; 3453 bfd_nonfatal_message (NULL, obfd, osection, NULL); 3454 free (memhunk); 3455 return; 3456 } 3457 free (memhunk); 3458 } 3459} 3460 3461/* Get all the sections. This is used when --gap-fill or --pad-to is 3462 used. */ 3463 3464static void 3465get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg) 3466{ 3467 asection ***secppp = (asection ***) secppparg; 3468 3469 **secppp = osection; 3470 ++(*secppp); 3471} 3472 3473/* Sort sections by VMA. This is called via qsort, and is used when 3474 --gap-fill or --pad-to is used. We force non loadable or empty 3475 sections to the front, where they are easier to ignore. */ 3476 3477static int 3478compare_section_lma (const void *arg1, const void *arg2) 3479{ 3480 const asection *const *sec1 = (const asection * const *) arg1; 3481 const asection *const *sec2 = (const asection * const *) arg2; 3482 flagword flags1, flags2; 3483 3484 /* Sort non loadable sections to the front. */ 3485 flags1 = (*sec1)->flags; 3486 flags2 = (*sec2)->flags; 3487 if ((flags1 & SEC_HAS_CONTENTS) == 0 3488 || (flags1 & SEC_LOAD) == 0) 3489 { 3490 if ((flags2 & SEC_HAS_CONTENTS) != 0 3491 && (flags2 & SEC_LOAD) != 0) 3492 return -1; 3493 } 3494 else 3495 { 3496 if ((flags2 & SEC_HAS_CONTENTS) == 0 3497 || (flags2 & SEC_LOAD) == 0) 3498 return 1; 3499 } 3500 3501 /* Sort sections by LMA. */ 3502 if ((*sec1)->lma > (*sec2)->lma) 3503 return 1; 3504 else if ((*sec1)->lma < (*sec2)->lma) 3505 return -1; 3506 3507 /* Sort sections with the same LMA by size. */ 3508 if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2)) 3509 return 1; 3510 else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2)) 3511 return -1; 3512 3513 return 0; 3514} 3515 3516/* Mark all the symbols which will be used in output relocations with 3517 the BSF_KEEP flag so that those symbols will not be stripped. 3518 3519 Ignore relocations which will not appear in the output file. */ 3520 3521static void 3522mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg) 3523{ 3524 asymbol **symbols = (asymbol **) symbolsarg; 3525 long relsize; 3526 arelent **relpp; 3527 long relcount, i; 3528 3529 /* Ignore an input section with no corresponding output section. */ 3530 if (isection->output_section == NULL) 3531 return; 3532 3533 relsize = bfd_get_reloc_upper_bound (ibfd, isection); 3534 if (relsize < 0) 3535 { 3536 /* Do not complain if the target does not support relocations. */ 3537 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation) 3538 return; 3539 bfd_fatal (bfd_get_filename (ibfd)); 3540 } 3541 3542 if (relsize == 0) 3543 return; 3544 3545 relpp = (arelent **) xmalloc (relsize); 3546 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols); 3547 if (relcount < 0) 3548 bfd_fatal (bfd_get_filename (ibfd)); 3549 3550 /* Examine each symbol used in a relocation. If it's not one of the 3551 special bfd section symbols, then mark it with BSF_KEEP. */ 3552 for (i = 0; i < relcount; i++) 3553 { 3554 /* See PRs 20923 and 20930 for reproducers for the NULL tests. */ 3555 if (relpp[i]->sym_ptr_ptr != NULL 3556 && * relpp[i]->sym_ptr_ptr != NULL 3557 && *relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol 3558 && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol 3559 && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol) 3560 (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP; 3561 } 3562 3563 if (relpp != NULL) 3564 free (relpp); 3565} 3566 3567/* Write out debugging information. */ 3568 3569static bfd_boolean 3570write_debugging_info (bfd *obfd, void *dhandle, 3571 long *symcountp ATTRIBUTE_UNUSED, 3572 asymbol ***symppp ATTRIBUTE_UNUSED) 3573{ 3574 if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour) 3575 return write_ieee_debugging_info (obfd, dhandle); 3576 3577 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour 3578 || bfd_get_flavour (obfd) == bfd_target_elf_flavour) 3579 { 3580 bfd_byte *syms, *strings; 3581 bfd_size_type symsize, stringsize; 3582 asection *stabsec, *stabstrsec; 3583 flagword flags; 3584 3585 if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms, 3586 &symsize, &strings, 3587 &stringsize)) 3588 return FALSE; 3589 3590 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING; 3591 stabsec = bfd_make_section_with_flags (obfd, ".stab", flags); 3592 stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags); 3593 if (stabsec == NULL 3594 || stabstrsec == NULL 3595 || ! bfd_set_section_size (obfd, stabsec, symsize) 3596 || ! bfd_set_section_size (obfd, stabstrsec, stringsize) 3597 || ! bfd_set_section_alignment (obfd, stabsec, 2) 3598 || ! bfd_set_section_alignment (obfd, stabstrsec, 0)) 3599 { 3600 bfd_nonfatal_message (NULL, obfd, NULL, 3601 _("can't create debugging section")); 3602 return FALSE; 3603 } 3604 3605 /* We can get away with setting the section contents now because 3606 the next thing the caller is going to do is copy over the 3607 real sections. We may someday have to split the contents 3608 setting out of this function. */ 3609 if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize) 3610 || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0, 3611 stringsize)) 3612 { 3613 bfd_nonfatal_message (NULL, obfd, NULL, 3614 _("can't set debugging section contents")); 3615 return FALSE; 3616 } 3617 3618 return TRUE; 3619 } 3620 3621 bfd_nonfatal_message (NULL, obfd, NULL, 3622 _("don't know how to write debugging information for %s"), 3623 bfd_get_target (obfd)); 3624 return FALSE; 3625} 3626 3627/* If neither -D nor -U was specified explicitly, 3628 then use the configured default. */ 3629static void 3630default_deterministic (void) 3631{ 3632 if (deterministic < 0) 3633 deterministic = DEFAULT_AR_DETERMINISTIC; 3634} 3635 3636static int 3637strip_main (int argc, char *argv[]) 3638{ 3639 char *input_target = NULL; 3640 char *output_target = NULL; 3641 bfd_boolean show_version = FALSE; 3642 bfd_boolean formats_info = FALSE; 3643 int c; 3644 int i; 3645 char *output_file = NULL; 3646 3647 while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvwDU", 3648 strip_options, (int *) 0)) != EOF) 3649 { 3650 switch (c) 3651 { 3652 case 'I': 3653 input_target = optarg; 3654 break; 3655 case 'O': 3656 output_target = optarg; 3657 break; 3658 case 'F': 3659 input_target = output_target = optarg; 3660 break; 3661 case 'R': 3662 handle_remove_section_option (optarg); 3663 break; 3664 case OPTION_REMOVE_RELOCS: 3665 handle_remove_relocations_option (optarg); 3666 break; 3667 case 's': 3668 strip_symbols = STRIP_ALL; 3669 break; 3670 case 'S': 3671 case 'g': 3672 case 'd': /* Historic BSD alias for -g. Used by early NetBSD. */ 3673 strip_symbols = STRIP_DEBUG; 3674 break; 3675 case OPTION_STRIP_DWO: 3676 strip_symbols = STRIP_DWO; 3677 break; 3678 case OPTION_STRIP_UNNEEDED: 3679 strip_symbols = STRIP_UNNEEDED; 3680 break; 3681 case 'K': 3682 add_specific_symbol (optarg, keep_specific_htab); 3683 break; 3684 case 'N': 3685 add_specific_symbol (optarg, strip_specific_htab); 3686 break; 3687 case 'o': 3688 output_file = optarg; 3689 break; 3690 case 'p': 3691 preserve_dates = TRUE; 3692 break; 3693 case 'D': 3694 deterministic = TRUE; 3695 break; 3696 case 'U': 3697 deterministic = FALSE; 3698 break; 3699 case 'x': 3700 discard_locals = LOCALS_ALL; 3701 break; 3702 case 'X': 3703 discard_locals = LOCALS_START_L; 3704 break; 3705 case 'v': 3706 verbose = TRUE; 3707 break; 3708 case 'V': 3709 show_version = TRUE; 3710 break; 3711 case OPTION_FORMATS_INFO: 3712 formats_info = TRUE; 3713 break; 3714 case OPTION_ONLY_KEEP_DEBUG: 3715 strip_symbols = STRIP_NONDEBUG; 3716 break; 3717 case OPTION_KEEP_FILE_SYMBOLS: 3718 keep_file_symbols = 1; 3719 break; 3720 case 0: 3721 /* We've been given a long option. */ 3722 break; 3723 case 'w': 3724 wildcard = TRUE; 3725 break; 3726 case 'H': 3727 case 'h': 3728 strip_usage (stdout, 0); 3729 default: 3730 strip_usage (stderr, 1); 3731 } 3732 } 3733 3734 if (formats_info) 3735 { 3736 display_info (); 3737 return 0; 3738 } 3739 3740 if (show_version) 3741 print_version ("strip"); 3742 3743 default_deterministic (); 3744 3745 /* Default is to strip all symbols. */ 3746 if (strip_symbols == STRIP_UNDEF 3747 && discard_locals == LOCALS_UNDEF 3748 && htab_elements (strip_specific_htab) == 0) 3749 strip_symbols = STRIP_ALL; 3750 3751 if (output_target == NULL) 3752 output_target = input_target; 3753 3754 i = optind; 3755 if (i == argc 3756 || (output_file != NULL && (i + 1) < argc)) 3757 strip_usage (stderr, 1); 3758 3759 for (; i < argc; i++) 3760 { 3761 int hold_status = status; 3762 struct stat statbuf; 3763 char *tmpname; 3764 3765 if (get_file_size (argv[i]) < 1) 3766 { 3767 status = 1; 3768 continue; 3769 } 3770 3771 if (preserve_dates) 3772 /* No need to check the return value of stat(). 3773 It has already been checked in get_file_size(). */ 3774 stat (argv[i], &statbuf); 3775 3776 if (output_file == NULL 3777 || filename_cmp (argv[i], output_file) == 0) 3778 tmpname = make_tempname (argv[i]); 3779 else 3780 tmpname = output_file; 3781 3782 if (tmpname == NULL) 3783 { 3784 bfd_nonfatal_message (argv[i], NULL, NULL, 3785 _("could not create temporary file to hold stripped copy")); 3786 status = 1; 3787 continue; 3788 } 3789 3790 status = 0; 3791 copy_file (argv[i], tmpname, input_target, output_target, NULL); 3792 if (status == 0) 3793 { 3794 if (preserve_dates) 3795 set_times (tmpname, &statbuf); 3796 if (output_file != tmpname) 3797 status = (smart_rename (tmpname, 3798 output_file ? output_file : argv[i], 3799 preserve_dates) != 0); 3800 if (status == 0) 3801 status = hold_status; 3802 } 3803 else 3804 unlink_if_ordinary (tmpname); 3805 if (output_file != tmpname) 3806 free (tmpname); 3807 } 3808 3809 return status; 3810} 3811 3812/* Set up PE subsystem. */ 3813 3814static void 3815set_pe_subsystem (const char *s) 3816{ 3817 const char *version, *subsystem; 3818 size_t i; 3819 static const struct 3820 { 3821 const char *name; 3822 const char set_def; 3823 const short value; 3824 } 3825 v[] = 3826 { 3827 { "native", 0, IMAGE_SUBSYSTEM_NATIVE }, 3828 { "windows", 0, IMAGE_SUBSYSTEM_WINDOWS_GUI }, 3829 { "console", 0, IMAGE_SUBSYSTEM_WINDOWS_CUI }, 3830 { "posix", 0, IMAGE_SUBSYSTEM_POSIX_CUI }, 3831 { "wince", 0, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI }, 3832 { "efi-app", 1, IMAGE_SUBSYSTEM_EFI_APPLICATION }, 3833 { "efi-bsd", 1, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER }, 3834 { "efi-rtd", 1, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER }, 3835 { "sal-rtd", 1, IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER }, 3836 { "xbox", 0, IMAGE_SUBSYSTEM_XBOX } 3837 }; 3838 short value; 3839 char *copy; 3840 int set_def = -1; 3841 3842 /* Check for the presence of a version number. */ 3843 version = strchr (s, ':'); 3844 if (version == NULL) 3845 subsystem = s; 3846 else 3847 { 3848 int len = version - s; 3849 copy = xstrdup (s); 3850 subsystem = copy; 3851 copy[len] = '\0'; 3852 version = copy + 1 + len; 3853 pe_major_subsystem_version = strtoul (version, ©, 0); 3854 if (*copy == '.') 3855 pe_minor_subsystem_version = strtoul (copy + 1, ©, 0); 3856 if (*copy != '\0') 3857 non_fatal (_("%s: bad version in PE subsystem"), s); 3858 } 3859 3860 /* Check for numeric subsystem. */ 3861 value = (short) strtol (subsystem, ©, 0); 3862 if (*copy == '\0') 3863 { 3864 for (i = 0; i < ARRAY_SIZE (v); i++) 3865 if (v[i].value == value) 3866 { 3867 pe_subsystem = value; 3868 set_def = v[i].set_def; 3869 break; 3870 } 3871 } 3872 else 3873 { 3874 /* Search for subsystem by name. */ 3875 for (i = 0; i < ARRAY_SIZE (v); i++) 3876 if (strcmp (subsystem, v[i].name) == 0) 3877 { 3878 pe_subsystem = v[i].value; 3879 set_def = v[i].set_def; 3880 break; 3881 } 3882 } 3883 3884 switch (set_def) 3885 { 3886 case -1: 3887 fatal (_("unknown PE subsystem: %s"), s); 3888 break; 3889 case 0: 3890 break; 3891 default: 3892 if (pe_file_alignment == (bfd_vma) -1) 3893 pe_file_alignment = PE_DEF_FILE_ALIGNMENT; 3894 if (pe_section_alignment == (bfd_vma) -1) 3895 pe_section_alignment = PE_DEF_SECTION_ALIGNMENT; 3896 break; 3897 } 3898 if (s != subsystem) 3899 free ((char *) subsystem); 3900} 3901 3902/* Convert EFI target to PEI target. */ 3903 3904static void 3905convert_efi_target (char *efi) 3906{ 3907 efi[0] = 'p'; 3908 efi[1] = 'e'; 3909 efi[2] = 'i'; 3910 3911 if (strcmp (efi + 4, "ia32") == 0) 3912 { 3913 /* Change ia32 to i386. */ 3914 efi[5]= '3'; 3915 efi[6]= '8'; 3916 efi[7]= '6'; 3917 } 3918 else if (strcmp (efi + 4, "x86_64") == 0) 3919 { 3920 /* Change x86_64 to x86-64. */ 3921 efi[7] = '-'; 3922 } 3923} 3924 3925/* Allocate and return a pointer to a struct section_add, initializing the 3926 structure using ARG, a string in the format "sectionname=filename". 3927 The returned structure will have its next pointer set to NEXT. The 3928 OPTION field is the name of the command line option currently being 3929 parsed, and is only used if an error needs to be reported. */ 3930 3931static struct section_add * 3932init_section_add (const char *arg, 3933 struct section_add *next, 3934 const char *option) 3935{ 3936 struct section_add *pa; 3937 const char *s; 3938 3939 s = strchr (arg, '='); 3940 if (s == NULL) 3941 fatal (_("bad format for %s"), option); 3942 3943 pa = (struct section_add *) xmalloc (sizeof (struct section_add)); 3944 pa->name = xstrndup (arg, s - arg); 3945 pa->filename = s + 1; 3946 pa->next = next; 3947 pa->contents = NULL; 3948 pa->size = 0; 3949 3950 return pa; 3951} 3952 3953/* Load the file specified in PA, allocating memory to hold the file 3954 contents, and store a pointer to the allocated memory in the contents 3955 field of PA. The size field of PA is also updated. All errors call 3956 FATAL. */ 3957 3958static void 3959section_add_load_file (struct section_add *pa) 3960{ 3961 size_t off, alloc; 3962 FILE *f; 3963 3964 /* We don't use get_file_size so that we can do 3965 --add-section .note.GNU_stack=/dev/null 3966 get_file_size doesn't work on /dev/null. */ 3967 3968 f = fopen (pa->filename, FOPEN_RB); 3969 if (f == NULL) 3970 fatal (_("cannot open: %s: %s"), 3971 pa->filename, strerror (errno)); 3972 3973 off = 0; 3974 alloc = 4096; 3975 pa->contents = (bfd_byte *) xmalloc (alloc); 3976 while (!feof (f)) 3977 { 3978 off_t got; 3979 3980 if (off == alloc) 3981 { 3982 alloc <<= 1; 3983 pa->contents = (bfd_byte *) xrealloc (pa->contents, alloc); 3984 } 3985 3986 got = fread (pa->contents + off, 1, alloc - off, f); 3987 if (ferror (f)) 3988 fatal (_("%s: fread failed"), pa->filename); 3989 3990 off += got; 3991 } 3992 3993 pa->size = off; 3994 3995 fclose (f); 3996} 3997 3998static int 3999copy_main (int argc, char *argv[]) 4000{ 4001 char *input_filename = NULL; 4002 char *output_filename = NULL; 4003 char *tmpname; 4004 char *input_target = NULL; 4005 char *output_target = NULL; 4006 bfd_boolean show_version = FALSE; 4007 bfd_boolean change_warn = TRUE; 4008 bfd_boolean formats_info = FALSE; 4009 int c; 4010 struct stat statbuf; 4011 const bfd_arch_info_type *input_arch = NULL; 4012 4013 while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:wDU", 4014 copy_options, (int *) 0)) != EOF) 4015 { 4016 switch (c) 4017 { 4018 case 'b': 4019 copy_byte = atoi (optarg); 4020 if (copy_byte < 0) 4021 fatal (_("byte number must be non-negative")); 4022 break; 4023 4024 case 'B': 4025 input_arch = bfd_scan_arch (optarg); 4026 if (input_arch == NULL) 4027 fatal (_("architecture %s unknown"), optarg); 4028 break; 4029 4030 case 'i': 4031 if (optarg) 4032 { 4033 interleave = atoi (optarg); 4034 if (interleave < 1) 4035 fatal (_("interleave must be positive")); 4036 } 4037 else 4038 interleave = 4; 4039 break; 4040 4041 case OPTION_INTERLEAVE_WIDTH: 4042 copy_width = atoi (optarg); 4043 if (copy_width < 1) 4044 fatal(_("interleave width must be positive")); 4045 break; 4046 4047 case 'I': 4048 case 's': /* "source" - 'I' is preferred */ 4049 input_target = optarg; 4050 break; 4051 4052 case 'O': 4053 case 'd': /* "destination" - 'O' is preferred */ 4054 output_target = optarg; 4055 break; 4056 4057 case 'F': 4058 input_target = output_target = optarg; 4059 break; 4060 4061 case 'j': 4062 find_section_list (optarg, TRUE, SECTION_CONTEXT_COPY); 4063 sections_copied = TRUE; 4064 break; 4065 4066 case 'R': 4067 handle_remove_section_option (optarg); 4068 break; 4069 4070 case OPTION_REMOVE_RELOCS: 4071 handle_remove_relocations_option (optarg); 4072 break; 4073 4074 case 'S': 4075 strip_symbols = STRIP_ALL; 4076 break; 4077 4078 case 'g': 4079 strip_symbols = STRIP_DEBUG; 4080 break; 4081 4082 case OPTION_STRIP_DWO: 4083 strip_symbols = STRIP_DWO; 4084 break; 4085 4086 case OPTION_STRIP_UNNEEDED: 4087 strip_symbols = STRIP_UNNEEDED; 4088 break; 4089 4090 case OPTION_ONLY_KEEP_DEBUG: 4091 strip_symbols = STRIP_NONDEBUG; 4092 break; 4093 4094 case OPTION_KEEP_FILE_SYMBOLS: 4095 keep_file_symbols = 1; 4096 break; 4097 4098 case OPTION_ADD_GNU_DEBUGLINK: 4099 long_section_names = ENABLE ; 4100 gnu_debuglink_filename = optarg; 4101 break; 4102 4103 case 'K': 4104 add_specific_symbol (optarg, keep_specific_htab); 4105 break; 4106 4107 case 'N': 4108 add_specific_symbol (optarg, strip_specific_htab); 4109 break; 4110 4111 case OPTION_STRIP_UNNEEDED_SYMBOL: 4112 add_specific_symbol (optarg, strip_unneeded_htab); 4113 break; 4114 4115 case 'L': 4116 add_specific_symbol (optarg, localize_specific_htab); 4117 break; 4118 4119 case OPTION_GLOBALIZE_SYMBOL: 4120 add_specific_symbol (optarg, globalize_specific_htab); 4121 break; 4122 4123 case 'G': 4124 add_specific_symbol (optarg, keepglobal_specific_htab); 4125 break; 4126 4127 case 'W': 4128 add_specific_symbol (optarg, weaken_specific_htab); 4129 break; 4130 4131 case 'p': 4132 preserve_dates = TRUE; 4133 break; 4134 4135 case 'D': 4136 deterministic = TRUE; 4137 break; 4138 4139 case 'U': 4140 deterministic = FALSE; 4141 break; 4142 4143 case 'w': 4144 wildcard = TRUE; 4145 break; 4146 4147 case 'x': 4148 discard_locals = LOCALS_ALL; 4149 break; 4150 4151 case 'X': 4152 discard_locals = LOCALS_START_L; 4153 break; 4154 4155 case 'v': 4156 verbose = TRUE; 4157 break; 4158 4159 case 'V': 4160 show_version = TRUE; 4161 break; 4162 4163 case OPTION_FORMATS_INFO: 4164 formats_info = TRUE; 4165 break; 4166 4167 case OPTION_WEAKEN: 4168 weaken = TRUE; 4169 break; 4170 4171 case OPTION_ADD_SECTION: 4172 add_sections = init_section_add (optarg, add_sections, 4173 "--add-section"); 4174 section_add_load_file (add_sections); 4175 break; 4176 4177 case OPTION_UPDATE_SECTION: 4178 update_sections = init_section_add (optarg, update_sections, 4179 "--update-section"); 4180 section_add_load_file (update_sections); 4181 break; 4182 4183 case OPTION_DUMP_SECTION: 4184 dump_sections = init_section_add (optarg, dump_sections, 4185 "--dump-section"); 4186 break; 4187 4188 case OPTION_ADD_SYMBOL: 4189 { 4190 char *s, *t; 4191 struct addsym_node *newsym = xmalloc (sizeof *newsym); 4192 4193 newsym->next = NULL; 4194 s = strchr (optarg, '='); 4195 if (s == NULL) 4196 fatal (_("bad format for %s"), "--add-symbol"); 4197 t = strchr (s + 1, ':'); 4198 4199 newsym->symdef = xstrndup (optarg, s - optarg); 4200 if (t) 4201 { 4202 newsym->section = xstrndup (s + 1, t - (s + 1)); 4203 newsym->symval = strtol (t + 1, NULL, 0); 4204 } 4205 else 4206 { 4207 newsym->section = NULL; 4208 newsym->symval = strtol (s + 1, NULL, 0); 4209 t = s; 4210 } 4211 4212 t = strchr (t + 1, ','); 4213 newsym->othersym = NULL; 4214 if (t) 4215 newsym->flags = parse_symflags (t+1, &newsym->othersym); 4216 else 4217 newsym->flags = BSF_GLOBAL; 4218 4219 /* Keep 'othersym' symbols at the front of the list. */ 4220 if (newsym->othersym) 4221 { 4222 newsym->next = add_sym_list; 4223 if (!add_sym_list) 4224 add_sym_tail = &newsym->next; 4225 add_sym_list = newsym; 4226 } 4227 else 4228 { 4229 *add_sym_tail = newsym; 4230 add_sym_tail = &newsym->next; 4231 } 4232 add_symbols++; 4233 } 4234 break; 4235 4236 case OPTION_CHANGE_START: 4237 change_start = parse_vma (optarg, "--change-start"); 4238 break; 4239 4240 case OPTION_CHANGE_SECTION_ADDRESS: 4241 case OPTION_CHANGE_SECTION_LMA: 4242 case OPTION_CHANGE_SECTION_VMA: 4243 { 4244 struct section_list * p; 4245 unsigned int context = 0; 4246 const char *s; 4247 int len; 4248 char *name; 4249 char *option = NULL; 4250 bfd_vma val; 4251 4252 switch (c) 4253 { 4254 case OPTION_CHANGE_SECTION_ADDRESS: 4255 option = "--change-section-address"; 4256 context = SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_ALTER_VMA; 4257 break; 4258 case OPTION_CHANGE_SECTION_LMA: 4259 option = "--change-section-lma"; 4260 context = SECTION_CONTEXT_ALTER_LMA; 4261 break; 4262 case OPTION_CHANGE_SECTION_VMA: 4263 option = "--change-section-vma"; 4264 context = SECTION_CONTEXT_ALTER_VMA; 4265 break; 4266 } 4267 4268 s = strchr (optarg, '='); 4269 if (s == NULL) 4270 { 4271 s = strchr (optarg, '+'); 4272 if (s == NULL) 4273 { 4274 s = strchr (optarg, '-'); 4275 if (s == NULL) 4276 fatal (_("bad format for %s"), option); 4277 } 4278 } 4279 else 4280 { 4281 /* Correct the context. */ 4282 switch (c) 4283 { 4284 case OPTION_CHANGE_SECTION_ADDRESS: 4285 context = SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_SET_VMA; 4286 break; 4287 case OPTION_CHANGE_SECTION_LMA: 4288 context = SECTION_CONTEXT_SET_LMA; 4289 break; 4290 case OPTION_CHANGE_SECTION_VMA: 4291 context = SECTION_CONTEXT_SET_VMA; 4292 break; 4293 } 4294 } 4295 4296 len = s - optarg; 4297 name = (char *) xmalloc (len + 1); 4298 strncpy (name, optarg, len); 4299 name[len] = '\0'; 4300 4301 p = find_section_list (name, TRUE, context); 4302 4303 val = parse_vma (s + 1, option); 4304 if (*s == '-') 4305 val = - val; 4306 4307 switch (c) 4308 { 4309 case OPTION_CHANGE_SECTION_ADDRESS: 4310 p->vma_val = val; 4311 /* Fall through. */ 4312 4313 case OPTION_CHANGE_SECTION_LMA: 4314 p->lma_val = val; 4315 break; 4316 4317 case OPTION_CHANGE_SECTION_VMA: 4318 p->vma_val = val; 4319 break; 4320 } 4321 } 4322 break; 4323 4324 case OPTION_CHANGE_ADDRESSES: 4325 change_section_address = parse_vma (optarg, "--change-addresses"); 4326 change_start = change_section_address; 4327 break; 4328 4329 case OPTION_CHANGE_WARNINGS: 4330 change_warn = TRUE; 4331 break; 4332 4333 case OPTION_CHANGE_LEADING_CHAR: 4334 change_leading_char = TRUE; 4335 break; 4336 4337 case OPTION_COMPRESS_DEBUG_SECTIONS: 4338 if (optarg) 4339 { 4340 if (strcasecmp (optarg, "none") == 0) 4341 do_debug_sections = decompress; 4342 else if (strcasecmp (optarg, "zlib") == 0) 4343 do_debug_sections = compress_zlib; 4344 else if (strcasecmp (optarg, "zlib-gnu") == 0) 4345 do_debug_sections = compress_gnu_zlib; 4346 else if (strcasecmp (optarg, "zlib-gabi") == 0) 4347 do_debug_sections = compress_gabi_zlib; 4348 else 4349 fatal (_("unrecognized --compress-debug-sections type `%s'"), 4350 optarg); 4351 } 4352 else 4353 do_debug_sections = compress; 4354 break; 4355 4356 case OPTION_DEBUGGING: 4357 convert_debugging = TRUE; 4358 break; 4359 4360 case OPTION_DECOMPRESS_DEBUG_SECTIONS: 4361 do_debug_sections = decompress; 4362 break; 4363 4364 case OPTION_ELF_STT_COMMON: 4365 if (strcasecmp (optarg, "yes") == 0) 4366 do_elf_stt_common = elf_stt_common; 4367 else if (strcasecmp (optarg, "no") == 0) 4368 do_elf_stt_common = no_elf_stt_common; 4369 else 4370 fatal (_("unrecognized --elf-stt-common= option `%s'"), 4371 optarg); 4372 break; 4373 4374 case OPTION_GAP_FILL: 4375 { 4376 bfd_vma gap_fill_vma; 4377 4378 gap_fill_vma = parse_vma (optarg, "--gap-fill"); 4379 gap_fill = (bfd_byte) gap_fill_vma; 4380 if ((bfd_vma) gap_fill != gap_fill_vma) 4381 { 4382 char buff[20]; 4383 4384 sprintf_vma (buff, gap_fill_vma); 4385 4386 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"), 4387 buff, gap_fill); 4388 } 4389 gap_fill_set = TRUE; 4390 } 4391 break; 4392 4393 case OPTION_NO_CHANGE_WARNINGS: 4394 change_warn = FALSE; 4395 break; 4396 4397 case OPTION_PAD_TO: 4398 pad_to = parse_vma (optarg, "--pad-to"); 4399 pad_to_set = TRUE; 4400 break; 4401 4402 case OPTION_REMOVE_LEADING_CHAR: 4403 remove_leading_char = TRUE; 4404 break; 4405 4406 case OPTION_REDEFINE_SYM: 4407 { 4408 /* Push this redefinition onto redefine_symbol_list. */ 4409 4410 int len; 4411 const char *s; 4412 const char *nextarg; 4413 char *source, *target; 4414 4415 s = strchr (optarg, '='); 4416 if (s == NULL) 4417 fatal (_("bad format for %s"), "--redefine-sym"); 4418 4419 len = s - optarg; 4420 source = (char *) xmalloc (len + 1); 4421 strncpy (source, optarg, len); 4422 source[len] = '\0'; 4423 4424 nextarg = s + 1; 4425 len = strlen (nextarg); 4426 target = (char *) xmalloc (len + 1); 4427 strcpy (target, nextarg); 4428 4429 redefine_list_append ("--redefine-sym", source, target); 4430 4431 free (source); 4432 free (target); 4433 } 4434 break; 4435 4436 case OPTION_REDEFINE_SYMS: 4437 add_redefine_syms_file (optarg); 4438 break; 4439 4440 case OPTION_SET_SECTION_FLAGS: 4441 { 4442 struct section_list *p; 4443 const char *s; 4444 int len; 4445 char *name; 4446 4447 s = strchr (optarg, '='); 4448 if (s == NULL) 4449 fatal (_("bad format for %s"), "--set-section-flags"); 4450 4451 len = s - optarg; 4452 name = (char *) xmalloc (len + 1); 4453 strncpy (name, optarg, len); 4454 name[len] = '\0'; 4455 4456 p = find_section_list (name, TRUE, SECTION_CONTEXT_SET_FLAGS); 4457 4458 p->flags = parse_flags (s + 1); 4459 } 4460 break; 4461 4462 case OPTION_RENAME_SECTION: 4463 { 4464 flagword flags; 4465 const char *eq, *fl; 4466 char *old_name; 4467 char *new_name; 4468 unsigned int len; 4469 4470 eq = strchr (optarg, '='); 4471 if (eq == NULL) 4472 fatal (_("bad format for %s"), "--rename-section"); 4473 4474 len = eq - optarg; 4475 if (len == 0) 4476 fatal (_("bad format for %s"), "--rename-section"); 4477 4478 old_name = (char *) xmalloc (len + 1); 4479 strncpy (old_name, optarg, len); 4480 old_name[len] = 0; 4481 4482 eq++; 4483 fl = strchr (eq, ','); 4484 if (fl) 4485 { 4486 flags = parse_flags (fl + 1); 4487 len = fl - eq; 4488 } 4489 else 4490 { 4491 flags = -1; 4492 len = strlen (eq); 4493 } 4494 4495 if (len == 0) 4496 fatal (_("bad format for %s"), "--rename-section"); 4497 4498 new_name = (char *) xmalloc (len + 1); 4499 strncpy (new_name, eq, len); 4500 new_name[len] = 0; 4501 4502 add_section_rename (old_name, new_name, flags); 4503 } 4504 break; 4505 4506 case OPTION_SET_START: 4507 set_start = parse_vma (optarg, "--set-start"); 4508 set_start_set = TRUE; 4509 break; 4510 4511 case OPTION_SREC_LEN: 4512 Chunk = parse_vma (optarg, "--srec-len"); 4513 break; 4514 4515 case OPTION_SREC_FORCES3: 4516 S3Forced = TRUE; 4517 break; 4518 4519 case OPTION_STRIP_SYMBOLS: 4520 add_specific_symbols (optarg, strip_specific_htab); 4521 break; 4522 4523 case OPTION_STRIP_UNNEEDED_SYMBOLS: 4524 add_specific_symbols (optarg, strip_unneeded_htab); 4525 break; 4526 4527 case OPTION_KEEP_SYMBOLS: 4528 add_specific_symbols (optarg, keep_specific_htab); 4529 break; 4530 4531 case OPTION_LOCALIZE_HIDDEN: 4532 localize_hidden = TRUE; 4533 break; 4534 4535 case OPTION_LOCALIZE_SYMBOLS: 4536 add_specific_symbols (optarg, localize_specific_htab); 4537 break; 4538 4539 case OPTION_LONG_SECTION_NAMES: 4540 if (!strcmp ("enable", optarg)) 4541 long_section_names = ENABLE; 4542 else if (!strcmp ("disable", optarg)) 4543 long_section_names = DISABLE; 4544 else if (!strcmp ("keep", optarg)) 4545 long_section_names = KEEP; 4546 else 4547 fatal (_("unknown long section names option '%s'"), optarg); 4548 break; 4549 4550 case OPTION_GLOBALIZE_SYMBOLS: 4551 add_specific_symbols (optarg, globalize_specific_htab); 4552 break; 4553 4554 case OPTION_KEEPGLOBAL_SYMBOLS: 4555 add_specific_symbols (optarg, keepglobal_specific_htab); 4556 break; 4557 4558 case OPTION_WEAKEN_SYMBOLS: 4559 add_specific_symbols (optarg, weaken_specific_htab); 4560 break; 4561 4562 case OPTION_ALT_MACH_CODE: 4563 use_alt_mach_code = strtoul (optarg, NULL, 0); 4564 if (use_alt_mach_code == 0) 4565 fatal (_("unable to parse alternative machine code")); 4566 break; 4567 4568 case OPTION_PREFIX_SYMBOLS: 4569 prefix_symbols_string = optarg; 4570 break; 4571 4572 case OPTION_PREFIX_SECTIONS: 4573 prefix_sections_string = optarg; 4574 break; 4575 4576 case OPTION_PREFIX_ALLOC_SECTIONS: 4577 prefix_alloc_sections_string = optarg; 4578 break; 4579 4580 case OPTION_READONLY_TEXT: 4581 bfd_flags_to_set |= WP_TEXT; 4582 bfd_flags_to_clear &= ~WP_TEXT; 4583 break; 4584 4585 case OPTION_WRITABLE_TEXT: 4586 bfd_flags_to_clear |= WP_TEXT; 4587 bfd_flags_to_set &= ~WP_TEXT; 4588 break; 4589 4590 case OPTION_PURE: 4591 bfd_flags_to_set |= D_PAGED; 4592 bfd_flags_to_clear &= ~D_PAGED; 4593 break; 4594 4595 case OPTION_IMPURE: 4596 bfd_flags_to_clear |= D_PAGED; 4597 bfd_flags_to_set &= ~D_PAGED; 4598 break; 4599 4600 case OPTION_EXTRACT_DWO: 4601 strip_symbols = STRIP_NONDWO; 4602 break; 4603 4604 case OPTION_EXTRACT_SYMBOL: 4605 extract_symbol = TRUE; 4606 break; 4607 4608 case OPTION_REVERSE_BYTES: 4609 { 4610 int prev = reverse_bytes; 4611 4612 reverse_bytes = atoi (optarg); 4613 if ((reverse_bytes <= 0) || ((reverse_bytes % 2) != 0)) 4614 fatal (_("number of bytes to reverse must be positive and even")); 4615 4616 if (prev && prev != reverse_bytes) 4617 non_fatal (_("Warning: ignoring previous --reverse-bytes value of %d"), 4618 prev); 4619 break; 4620 } 4621 4622 case OPTION_FILE_ALIGNMENT: 4623 pe_file_alignment = parse_vma (optarg, "--file-alignment"); 4624 break; 4625 4626 case OPTION_HEAP: 4627 { 4628 char *end; 4629 pe_heap_reserve = strtoul (optarg, &end, 0); 4630 if (end == optarg 4631 || (*end != '.' && *end != '\0')) 4632 non_fatal (_("%s: invalid reserve value for --heap"), 4633 optarg); 4634 else if (*end != '\0') 4635 { 4636 pe_heap_commit = strtoul (end + 1, &end, 0); 4637 if (*end != '\0') 4638 non_fatal (_("%s: invalid commit value for --heap"), 4639 optarg); 4640 } 4641 } 4642 break; 4643 4644 case OPTION_IMAGE_BASE: 4645 pe_image_base = parse_vma (optarg, "--image-base"); 4646 break; 4647 4648 case OPTION_SECTION_ALIGNMENT: 4649 pe_section_alignment = parse_vma (optarg, 4650 "--section-alignment"); 4651 break; 4652 4653 case OPTION_SUBSYSTEM: 4654 set_pe_subsystem (optarg); 4655 break; 4656 4657 case OPTION_STACK: 4658 { 4659 char *end; 4660 pe_stack_reserve = strtoul (optarg, &end, 0); 4661 if (end == optarg 4662 || (*end != '.' && *end != '\0')) 4663 non_fatal (_("%s: invalid reserve value for --stack"), 4664 optarg); 4665 else if (*end != '\0') 4666 { 4667 pe_stack_commit = strtoul (end + 1, &end, 0); 4668 if (*end != '\0') 4669 non_fatal (_("%s: invalid commit value for --stack"), 4670 optarg); 4671 } 4672 } 4673 break; 4674 4675 case 0: 4676 /* We've been given a long option. */ 4677 break; 4678 4679 case 'H': 4680 case 'h': 4681 copy_usage (stdout, 0); 4682 4683 default: 4684 copy_usage (stderr, 1); 4685 } 4686 } 4687 4688 if (formats_info) 4689 { 4690 display_info (); 4691 return 0; 4692 } 4693 4694 if (show_version) 4695 print_version ("objcopy"); 4696 4697 if (interleave && copy_byte == -1) 4698 fatal (_("interleave start byte must be set with --byte")); 4699 4700 if (copy_byte >= interleave) 4701 fatal (_("byte number must be less than interleave")); 4702 4703 if (copy_width > interleave - copy_byte) 4704 fatal (_("interleave width must be less than or equal to interleave - byte`")); 4705 4706 if (optind == argc || optind + 2 < argc) 4707 copy_usage (stderr, 1); 4708 4709 input_filename = argv[optind]; 4710 if (optind + 1 < argc) 4711 output_filename = argv[optind + 1]; 4712 4713 default_deterministic (); 4714 4715 /* Default is to strip no symbols. */ 4716 if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF) 4717 strip_symbols = STRIP_NONE; 4718 4719 if (output_target == NULL) 4720 output_target = input_target; 4721 4722 /* Convert input EFI target to PEI target. */ 4723 if (input_target != NULL 4724 && strncmp (input_target, "efi-", 4) == 0) 4725 { 4726 char *efi; 4727 4728 efi = xstrdup (output_target + 4); 4729 if (strncmp (efi, "bsdrv-", 6) == 0 4730 || strncmp (efi, "rtdrv-", 6) == 0) 4731 efi += 2; 4732 else if (strncmp (efi, "app-", 4) != 0) 4733 fatal (_("unknown input EFI target: %s"), input_target); 4734 4735 input_target = efi; 4736 convert_efi_target (efi); 4737 } 4738 4739 /* Convert output EFI target to PEI target. */ 4740 if (output_target != NULL 4741 && strncmp (output_target, "efi-", 4) == 0) 4742 { 4743 char *efi; 4744 4745 efi = xstrdup (output_target + 4); 4746 if (strncmp (efi, "app-", 4) == 0) 4747 { 4748 if (pe_subsystem == -1) 4749 pe_subsystem = IMAGE_SUBSYSTEM_EFI_APPLICATION; 4750 } 4751 else if (strncmp (efi, "bsdrv-", 6) == 0) 4752 { 4753 if (pe_subsystem == -1) 4754 pe_subsystem = IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER; 4755 efi += 2; 4756 } 4757 else if (strncmp (efi, "rtdrv-", 6) == 0) 4758 { 4759 if (pe_subsystem == -1) 4760 pe_subsystem = IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER; 4761 efi += 2; 4762 } 4763 else 4764 fatal (_("unknown output EFI target: %s"), output_target); 4765 4766 if (pe_file_alignment == (bfd_vma) -1) 4767 pe_file_alignment = PE_DEF_FILE_ALIGNMENT; 4768 if (pe_section_alignment == (bfd_vma) -1) 4769 pe_section_alignment = PE_DEF_SECTION_ALIGNMENT; 4770 4771 output_target = efi; 4772 convert_efi_target (efi); 4773 } 4774 4775 if (preserve_dates) 4776 if (stat (input_filename, & statbuf) < 0) 4777 fatal (_("warning: could not locate '%s'. System error message: %s"), 4778 input_filename, strerror (errno)); 4779 4780 /* If there is no destination file, or the source and destination files 4781 are the same, then create a temp and rename the result into the input. */ 4782 if (output_filename == NULL 4783 || filename_cmp (input_filename, output_filename) == 0) 4784 tmpname = make_tempname (input_filename); 4785 else 4786 tmpname = output_filename; 4787 4788 if (tmpname == NULL) 4789 fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"), 4790 input_filename, strerror (errno)); 4791 4792 copy_file (input_filename, tmpname, input_target, output_target, input_arch); 4793 if (status == 0) 4794 { 4795 if (preserve_dates) 4796 set_times (tmpname, &statbuf); 4797 if (tmpname != output_filename) 4798 status = (smart_rename (tmpname, input_filename, 4799 preserve_dates) != 0); 4800 } 4801 else 4802 unlink_if_ordinary (tmpname); 4803 4804 if (change_warn) 4805 { 4806 struct section_list *p; 4807 4808 for (p = change_sections; p != NULL; p = p->next) 4809 { 4810 if (! p->used) 4811 { 4812 if (p->context & (SECTION_CONTEXT_SET_VMA | SECTION_CONTEXT_ALTER_VMA)) 4813 { 4814 char buff [20]; 4815 4816 sprintf_vma (buff, p->vma_val); 4817 4818 /* xgettext:c-format */ 4819 non_fatal (_("%s %s%c0x%s never used"), 4820 "--change-section-vma", 4821 p->pattern, 4822 p->context & SECTION_CONTEXT_SET_VMA ? '=' : '+', 4823 buff); 4824 } 4825 4826 if (p->context & (SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_ALTER_LMA)) 4827 { 4828 char buff [20]; 4829 4830 sprintf_vma (buff, p->lma_val); 4831 4832 /* xgettext:c-format */ 4833 non_fatal (_("%s %s%c0x%s never used"), 4834 "--change-section-lma", 4835 p->pattern, 4836 p->context & SECTION_CONTEXT_SET_LMA ? '=' : '+', 4837 buff); 4838 } 4839 } 4840 } 4841 } 4842 4843 return 0; 4844} 4845 4846int 4847main (int argc, char *argv[]) 4848{ 4849#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) 4850 setlocale (LC_MESSAGES, ""); 4851#endif 4852#if defined (HAVE_SETLOCALE) 4853 setlocale (LC_CTYPE, ""); 4854#endif 4855 bindtextdomain (PACKAGE, LOCALEDIR); 4856 textdomain (PACKAGE); 4857 4858 program_name = argv[0]; 4859 xmalloc_set_program_name (program_name); 4860 4861 START_PROGRESS (program_name, 0); 4862 4863 expandargv (&argc, &argv); 4864 4865 strip_symbols = STRIP_UNDEF; 4866 discard_locals = LOCALS_UNDEF; 4867 4868 bfd_init (); 4869 set_default_bfd_target (); 4870 4871 if (is_strip < 0) 4872 { 4873 int i = strlen (program_name); 4874#ifdef HAVE_DOS_BASED_FILE_SYSTEM 4875 /* Drop the .exe suffix, if any. */ 4876 if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0) 4877 { 4878 i -= 4; 4879 program_name[i] = '\0'; 4880 } 4881#endif 4882 is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0); 4883 } 4884 4885 create_symbol_htabs (); 4886 4887 if (argv != NULL) 4888 bfd_set_error_program_name (argv[0]); 4889 4890 if (is_strip) 4891 strip_main (argc, argv); 4892 else 4893 copy_main (argc, argv); 4894 4895 END_PROGRESS (program_name); 4896 4897 return status; 4898} 4899