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