binutils/objcopy.c

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