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