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