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
2000   relsize = bfd_get_reloc_upper_bound (abfd, sec);
2001   if (relsize > 0)
2002     {
2003       arelent **  relpp;
2004       long        relcount;
2005
2006       /* If there are relocs associated with this section then we
2007          cannot safely merge it.  */
2008       relpp = (arelent **) xmalloc (relsize);
2009       relcount = bfd_canonicalize_reloc (abfd, sec, relpp, isympp);
2010       free (relpp);
2011       if (relcount != 0)
2012         goto done;
2013     }
2014
2015   /* Make a copy of the notes and convert to our internal format.
2016      Minimum size of a note is 12 bytes.  */
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   /* The first note should be the first version note.  */
2186   if (pnotes[0].note.namedata[attribute_type_byte] != GNU_BUILD_ATTRIBUTE_VERSION)
2187     {
2188       err = _("bad GNU build attribute notes: first note not version note");
2189       goto done;
2190     }
2191
2192   /* Now merge the notes.  The rules are:
2193      1. Preserve the ordering of the notes.
2194      2. Preserve any NT_GNU_BUILD_ATTRIBUTE_FUNC notes.
2195      3. Eliminate any NT_GNU_BUILD_ATTRIBUTE_OPEN notes that have the same
2196         full name field as the immediately preceeding note with the same type
2197         of name and whose address ranges coincide.
2198         IE - if there are gaps in the coverage of the notes, then these gaps
2199         must be preserved.
2200      4. Combine the numeric value of any NT_GNU_BUILD_ATTRIBUTE_OPEN notes
2201         of type GNU_BUILD_ATTRIBUTE_STACK_SIZE.
2202      5. If an NT_GNU_BUILD_ATTRIBUTE_OPEN note is going to be preserved and
2203         its description field is empty then the nearest preceeding OPEN note
2204         with a non-empty description field must also be preserved *OR* the
2205         description field of the note must be changed to contain the starting
2206         address to which it refers.
2207      6. Notes with the same start and end address can be deleted.  */
2208   for (pnote = pnotes + 1; pnote < pnotes_end; pnote ++)
2209     {
2210       int                      note_type;
2211       objcopy_internal_note *  back;
2212       objcopy_internal_note *  prev_open_with_range = NULL;
2213
2214       /* Rule 6 - delete 0-range notes.  */
2215       if (pnote->start == pnote->end)
2216         {
2217           duplicate_found = TRUE;
2218           pnote->note.type = 0;
2219           continue;
2220         }
2221
2222       /* Rule 2 - preserve function notes.  */
2223       if (! is_open_note (pnote))
2224         {
2225           int iter;
2226
2227           /* Check to see if there is an identical previous function note.
2228              This can happen with overlays for example.  */
2229           for (iter = 0, back = pnote -1; back >= pnotes; back --)
2230             {
2231               if (back->start == pnote->start
2232                   && back->end == pnote->end
2233                   && back->note.namesz == pnote->note.namesz
2234                   && memcmp (back->note.namedata, pnote->note.namedata, pnote->note.namesz) == 0)
2235                 {
2236  fprintf (stderr, "DUP FUNXC\n");
2237                   duplicate_found = TRUE;
2238                   pnote->note.type = 0;
2239                   break;
2240                 }
2241
2242               /* Don't scan too far back however.  */
2243               if (iter ++ > 16)
2244                 break;
2245             }
2246           continue;
2247         }
2248
2249       note_type = pnote->note.namedata[attribute_type_byte];
2250
2251       /* Scan backwards from pnote, looking for duplicates.
2252          Clear the type field of any found - but do not delete them just yet.  */
2253       for (back = pnote - 1; back >= pnotes; back --)
2254         {
2255           int back_type = back->note.namedata[attribute_type_byte];
2256
2257           /* If this is the first open note with an address
2258              range that we have encountered then record it.  */
2259           if (prev_open_with_range == NULL
2260               && back->note.descsz > 0
2261               && ! is_func_note (back))
2262             prev_open_with_range = back;
2263
2264           if (! is_open_note (back))
2265             continue;
2266
2267           /* If the two notes are different then keep on searching.  */
2268           if (back_type != note_type)
2269             continue;
2270
2271           /* Rule 4 - combine stack size notes.  */
2272           if (back_type == GNU_BUILD_ATTRIBUTE_STACK_SIZE)
2273             {
2274               unsigned char * name;
2275               unsigned long   note_val;
2276               unsigned long   back_val;
2277               unsigned int    shift;
2278               unsigned int    bytes;
2279               unsigned long   byte;
2280
2281               for (shift = 0, note_val = 0,
2282                      bytes = pnote->note.namesz - val_start,
2283                      name = (unsigned char *) pnote->note.namedata + val_start;
2284                    bytes--;)
2285                 {
2286                   byte = (* name ++) & 0xff;
2287                   note_val |= byte << shift;
2288                   shift += 8;
2289                 }
2290
2291               for (shift = 0, back_val = 0,
2292                      bytes = back->note.namesz - val_start,
2293                      name = (unsigned char *) back->note.namedata + val_start;
2294                    bytes--;)
2295                 {
2296                   byte = (* name ++) & 0xff;
2297                   back_val |= byte << shift;
2298                   shift += 8;
2299                 }
2300
2301               back_val += note_val;
2302               if (num_bytes (back_val) >= back->note.namesz - val_start)
2303                 {
2304                   /* We have a problem - the new value requires more bytes of
2305                      storage in the name field than are available.  Currently
2306                      we have no way of fixing this, so we just preserve both
2307                      notes.  */
2308                   continue;
2309                 }
2310
2311               /* Write the new val into back.  */
2312               name = (unsigned char *) back->note.namedata + val_start;
2313               while (name < (unsigned char *) back->note.namedata
2314                      + back->note.namesz)
2315                 {
2316                   byte = back_val & 0xff;
2317                   * name ++ = byte;
2318                   if (back_val == 0)
2319                     break;
2320                   back_val >>= 8;
2321                 }
2322
2323               duplicate_found = TRUE;
2324               pnote->note.type = 0;
2325               break;
2326             }
2327
2328           /* Rule 3 - combine identical open notes.  */
2329           if (back->note.namesz == pnote->note.namesz
2330               && memcmp (back->note.namedata,
2331                          pnote->note.namedata, back->note.namesz) == 0
2332               && ! gap_exists (back, pnote))
2333             {
2334               duplicate_found = TRUE;
2335               pnote->note.type = 0;
2336
2337               if (pnote->end > back->end)
2338                 back->end = pnote->end;
2339
2340               if (version_3_seen)
2341                 back->modified = TRUE;
2342               break;
2343             }
2344
2345           /* Rule 5 - Since we are keeping this note we must check to see
2346              if its description refers back to an earlier OPEN version
2347              note that has been scheduled for deletion.  If so then we
2348              must make sure that version note is also preserved.  */
2349           if (version_3_seen)
2350             {
2351               /* As of version 3 we can just
2352                  move the range into the note.  */
2353               pnote->modified = TRUE;
2354               pnote->note.type = NT_GNU_BUILD_ATTRIBUTE_FUNC;
2355               back->modified = TRUE;
2356               back->note.type = NT_GNU_BUILD_ATTRIBUTE_FUNC;
2357             }
2358           else
2359             {
2360               if (pnote->note.descsz == 0
2361                   && prev_open_with_range != NULL
2362                   && prev_open_with_range->note.type == 0)
2363                 prev_open_with_range->note.type = NT_GNU_BUILD_ATTRIBUTE_OPEN;
2364             }
2365
2366           /* We have found a similar attribute but the details do not match.
2367              Stop searching backwards.  */
2368           break;
2369         }
2370     }
2371
2372   if (duplicate_found)
2373     {
2374       bfd_byte *     new_contents;
2375       bfd_byte *     old;
2376       bfd_byte *     new;
2377       bfd_size_type  new_size;
2378       bfd_vma        prev_start = 0;
2379       bfd_vma        prev_end = 0;
2380
2381       /* Eliminate the duplicates.  */
2382       new = new_contents = xmalloc (size);
2383       for (pnote = pnotes, old = contents;
2384            pnote < pnotes_end;
2385            pnote ++)
2386         {
2387           bfd_size_type note_size = 12 + pnote->note.namesz + pnote->note.descsz;
2388
2389           if (pnote->note.type != 0)
2390             {
2391               if (pnote->modified)
2392                 {
2393                   /* If the note has been modified then we must copy it by
2394                      hand, potentially adding in a new description field.  */
2395                   if (pnote->start == prev_start && pnote->end == prev_end)
2396                     {
2397                       bfd_put_32 (abfd, pnote->note.namesz, new);
2398                       bfd_put_32 (abfd, 0, new + 4);
2399                       bfd_put_32 (abfd, pnote->note.type, new + 8);
2400                       new += 12;
2401                       memcpy (new, pnote->note.namedata, pnote->note.namesz);
2402                       new += pnote->note.namesz;
2403                     }
2404                   else
2405                     {
2406                       bfd_put_32 (abfd, pnote->note.namesz, new);
2407                       bfd_put_32 (abfd, is_64bit (abfd) ? 16 : 8, new + 4);
2408                       bfd_put_32 (abfd, pnote->note.type, new + 8);
2409                       new += 12;
2410                       memcpy (new, pnote->note.namedata, pnote->note.namesz);
2411                       new += pnote->note.namesz;
2412                       if (is_64bit (abfd))
2413                         {
2414                           bfd_put_64 (abfd, pnote->start, new);
2415                           bfd_put_64 (abfd, pnote->end, new + 8);
2416                           new += 16;
2417                         }
2418                       else
2419                         {
2420                           bfd_put_32 (abfd, pnote->start, new);
2421                           bfd_put_32 (abfd, pnote->end, new + 4);
2422                           new += 8;
2423                         }
2424                     }
2425                 }
2426               else
2427                 {
2428                   memcpy (new, old, note_size);
2429                   new += note_size;
2430                 }
2431               prev_start = pnote->start;
2432               prev_end = pnote->end;
2433             }
2434
2435           old += note_size;
2436         }
2437
2438       new_size = new - new_contents;
2439       memcpy (contents, new_contents, new_size);
2440       size = new_size;
2441       free (new_contents);
2442     }
2443
2444  done:
2445   if (err)
2446     {
2447       bfd_set_error (bfd_error_bad_value);
2448       bfd_nonfatal_message (NULL, abfd, sec, err);
2449       status = 1;
2450     }
2451
2452   free (pnotes);
2453   return size;
2454 }
2455
2456 /* Copy object file IBFD onto OBFD.
2457    Returns TRUE upon success, FALSE otherwise.  */
2458
2459 static bfd_boolean
2460 copy_object (bfd *ibfd, bfd *obfd, const bfd_arch_info_type *input_arch)
2461 {
2462   bfd_vma start;
2463   long symcount;
2464   asection **osections = NULL;
2465   asection *osec;
2466   asection *gnu_debuglink_section = NULL;
2467   bfd_size_type *gaps = NULL;
2468   bfd_size_type max_gap = 0;
2469   long symsize;
2470   void *dhandle;
2471   enum bfd_architecture iarch;
2472   unsigned int imach;
2473   unsigned int c, i;
2474
2475   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2476       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2477       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2478     {
2479       /* PR 17636: Call non-fatal so that we return to our parent who
2480          may need to tidy temporary files.  */
2481       non_fatal (_("Unable to change endianness of input file(s)"));
2482       return FALSE;
2483     }
2484
2485   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
2486     {
2487       bfd_nonfatal_message (NULL, obfd, NULL, NULL);
2488       return FALSE;
2489     }
2490
2491   if (ibfd->sections == NULL)
2492     {
2493       non_fatal (_("error: the input file '%s' has no sections"),
2494                  bfd_get_archive_filename (ibfd));
2495       return FALSE;
2496     }
2497
2498   if (ibfd->xvec->flavour != bfd_target_elf_flavour)
2499     {
2500       if ((do_debug_sections & compress) != 0
2501           && do_debug_sections != compress)
2502         {
2503           non_fatal (_("--compress-debug-sections=[zlib|zlib-gnu|zlib-gabi] is unsupported on `%s'"),
2504                      bfd_get_archive_filename (ibfd));
2505           return FALSE;
2506         }
2507
2508       if (do_elf_stt_common)
2509         {
2510           non_fatal (_("--elf-stt-common=[yes|no] is unsupported on `%s'"),
2511                      bfd_get_archive_filename (ibfd));
2512           return FALSE;
2513         }
2514     }
2515
2516   if (verbose)
2517     printf (_("copy from `%s' [%s] to `%s' [%s]\n"),
2518             bfd_get_archive_filename (ibfd), bfd_get_target (ibfd),
2519             bfd_get_filename (obfd), bfd_get_target (obfd));
2520
2521   if (extract_symbol)
2522     start = 0;
2523   else
2524     {
2525       if (set_start_set)
2526         start = set_start;
2527       else
2528         start = bfd_get_start_address (ibfd);
2529       start += change_start;
2530     }
2531
2532   /* Neither the start address nor the flags
2533      need to be set for a core file.  */
2534   if (bfd_get_format (obfd) != bfd_core)
2535     {
2536       flagword flags;
2537
2538       flags = bfd_get_file_flags (ibfd);
2539       flags |= bfd_flags_to_set;
2540       flags &= ~bfd_flags_to_clear;
2541       flags &= bfd_applicable_file_flags (obfd);
2542
2543       if (strip_symbols == STRIP_ALL)
2544         flags &= ~HAS_RELOC;
2545
2546       if (!bfd_set_start_address (obfd, start)
2547           || !bfd_set_file_flags (obfd, flags))
2548         {
2549           bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
2550           return FALSE;
2551         }
2552     }
2553
2554   /* Copy architecture of input file to output file.  */
2555   iarch = bfd_get_arch (ibfd);
2556   imach = bfd_get_mach (ibfd);
2557   if (input_arch)
2558     {
2559       if (bfd_get_arch_info (ibfd) == NULL
2560           || bfd_get_arch_info (ibfd)->arch == bfd_arch_unknown)
2561         {
2562           iarch = input_arch->arch;
2563           imach = input_arch->mach;
2564         }
2565       else
2566         non_fatal (_("Input file `%s' ignores binary architecture parameter."),
2567                    bfd_get_archive_filename (ibfd));
2568     }
2569   if (!bfd_set_arch_mach (obfd, iarch, imach)
2570       && (ibfd->target_defaulted
2571           || bfd_get_arch (ibfd) != bfd_get_arch (obfd)))
2572     {
2573       if (bfd_get_arch (ibfd) == bfd_arch_unknown)
2574         non_fatal (_("Unable to recognise the format of the input file `%s'"),
2575                    bfd_get_archive_filename (ibfd));
2576       else
2577         non_fatal (_("Output file cannot represent architecture `%s'"),
2578                    bfd_printable_arch_mach (bfd_get_arch (ibfd),
2579                                             bfd_get_mach (ibfd)));
2580       return FALSE;
2581     }
2582
2583   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
2584     {
2585       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
2586       return FALSE;
2587     }
2588
2589   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
2590       && bfd_pei_p (obfd))
2591     {
2592       /* Set up PE parameters.  */
2593       pe_data_type *pe = pe_data (obfd);
2594
2595       /* Copy PE parameters before changing them.  */
2596       if (ibfd->xvec->flavour == bfd_target_coff_flavour
2597           && bfd_pei_p (ibfd))
2598         pe->pe_opthdr = pe_data (ibfd)->pe_opthdr;
2599
2600       if (pe_file_alignment != (bfd_vma) -1)
2601         pe->pe_opthdr.FileAlignment = pe_file_alignment;
2602       else
2603         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
2604
2605       if (pe_heap_commit != (bfd_vma) -1)
2606         pe->pe_opthdr.SizeOfHeapCommit = pe_heap_commit;
2607
2608       if (pe_heap_reserve != (bfd_vma) -1)
2609         pe->pe_opthdr.SizeOfHeapCommit = pe_heap_reserve;
2610
2611       if (pe_image_base != (bfd_vma) -1)
2612         pe->pe_opthdr.ImageBase = pe_image_base;
2613
2614       if (pe_section_alignment != (bfd_vma) -1)
2615         pe->pe_opthdr.SectionAlignment = pe_section_alignment;
2616       else
2617         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
2618
2619       if (pe_stack_commit != (bfd_vma) -1)
2620         pe->pe_opthdr.SizeOfStackCommit = pe_stack_commit;
2621
2622       if (pe_stack_reserve != (bfd_vma) -1)
2623         pe->pe_opthdr.SizeOfStackCommit = pe_stack_reserve;
2624
2625       if (pe_subsystem != -1)
2626         pe->pe_opthdr.Subsystem = pe_subsystem;
2627
2628       if (pe_major_subsystem_version != -1)
2629         pe->pe_opthdr.MajorSubsystemVersion = pe_major_subsystem_version;
2630
2631       if (pe_minor_subsystem_version != -1)
2632         pe->pe_opthdr.MinorSubsystemVersion = pe_minor_subsystem_version;
2633
2634       if (pe_file_alignment > pe_section_alignment)
2635         {
2636           char file_alignment[20], section_alignment[20];
2637
2638           sprintf_vma (file_alignment, pe_file_alignment);
2639           sprintf_vma (section_alignment, pe_section_alignment);
2640           non_fatal (_("warning: file alignment (0x%s) > section alignment (0x%s)"),
2641
2642                      file_alignment, section_alignment);
2643         }
2644     }
2645
2646   if (isympp)
2647     free (isympp);
2648
2649   if (osympp != isympp)
2650     free (osympp);
2651
2652   isympp = NULL;
2653   osympp = NULL;
2654
2655   symsize = bfd_get_symtab_upper_bound (ibfd);
2656   if (symsize < 0)
2657     {
2658       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
2659       return FALSE;
2660     }
2661
2662   osympp = isympp = (asymbol **) xmalloc (symsize);
2663   symcount = bfd_canonicalize_symtab (ibfd, isympp);
2664   if (symcount < 0)
2665     {
2666       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
2667       return FALSE;
2668     }
2669   /* PR 17512: file:  d6323821
2670      If the symbol table could not be loaded do not pretend that we have
2671      any symbols.  This trips us up later on when we load the relocs.  */
2672   if (symcount == 0)
2673     {
2674       free (isympp);
2675       osympp = isympp = NULL;
2676     }
2677
2678   /* BFD mandates that all output sections be created and sizes set before
2679      any output is done.  Thus, we traverse all sections multiple times.  */
2680   bfd_map_over_sections (ibfd, setup_section, obfd);
2681
2682   if (!extract_symbol)
2683     setup_bfd_headers (ibfd, obfd);
2684
2685   if (add_sections != NULL)
2686     {
2687       struct section_add *padd;
2688       struct section_list *pset;
2689
2690       for (padd = add_sections; padd != NULL; padd = padd->next)
2691         {
2692           flagword flags;
2693
2694           pset = find_section_list (padd->name, FALSE,
2695                                     SECTION_CONTEXT_SET_FLAGS);
2696           if (pset != NULL)
2697             flags = pset->flags | SEC_HAS_CONTENTS;
2698           else
2699             flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
2700
2701           /* bfd_make_section_with_flags() does not return very helpful
2702              error codes, so check for the most likely user error first.  */
2703           if (bfd_get_section_by_name (obfd, padd->name))
2704             {
2705               bfd_nonfatal_message (NULL, obfd, NULL,
2706                                     _("can't add section '%s'"), padd->name);
2707               return FALSE;
2708             }
2709           else
2710             {
2711               /* We use LINKER_CREATED here so that the backend hooks
2712                  will create any special section type information,
2713                  instead of presuming we know what we're doing merely
2714                  because we set the flags.  */
2715               padd->section = bfd_make_section_with_flags
2716                 (obfd, padd->name, flags | SEC_LINKER_CREATED);
2717               if (padd->section == NULL)
2718                 {
2719                   bfd_nonfatal_message (NULL, obfd, NULL,
2720                                         _("can't create section `%s'"),
2721                                         padd->name);
2722                   return FALSE;
2723                 }
2724             }
2725
2726           if (! bfd_set_section_size (obfd, padd->section, padd->size))
2727             {
2728               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
2729               return FALSE;
2730             }
2731
2732           pset = find_section_list (padd->name, FALSE,
2733                                     SECTION_CONTEXT_SET_VMA | SECTION_CONTEXT_ALTER_VMA);
2734           if (pset != NULL
2735               && ! bfd_set_section_vma (obfd, padd->section, pset->vma_val))
2736             {
2737               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
2738               return FALSE;
2739             }
2740
2741           pset = find_section_list (padd->name, FALSE,
2742                                     SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_ALTER_LMA);
2743           if (pset != NULL)
2744             {
2745               padd->section->lma = pset->lma_val;
2746
2747               if (! bfd_set_section_alignment
2748                   (obfd, padd->section,
2749                    bfd_section_alignment (obfd, padd->section)))
2750                 {
2751                   bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
2752                   return FALSE;
2753                 }
2754             }
2755         }
2756     }
2757
2758   if (update_sections != NULL)
2759     {
2760       struct section_add *pupdate;
2761
2762       for (pupdate = update_sections;
2763            pupdate != NULL;
2764            pupdate = pupdate->next)
2765         {
2766           pupdate->section = bfd_get_section_by_name (ibfd, pupdate->name);
2767           if (pupdate->section == NULL)
2768             {
2769               non_fatal (_("error: %s not found, can't be updated"), pupdate->name);
2770               return FALSE;
2771             }
2772
2773           osec = pupdate->section->output_section;
2774           if (! bfd_set_section_size (obfd, osec, pupdate->size))
2775             {
2776               bfd_nonfatal_message (NULL, obfd, osec, NULL);
2777               return FALSE;
2778             }
2779         }
2780     }
2781
2782   if (merge_notes)
2783     {
2784       /* This palaver is necessary because we must set the output
2785          section size first, before its contents are ready.  */
2786       osec = bfd_get_section_by_name (ibfd, GNU_BUILD_ATTRS_SECTION_NAME);
2787       if (osec && is_merged_note_section (ibfd, osec))
2788         {
2789           bfd_size_type size;
2790
2791           size = bfd_get_section_size (osec);
2792           if (size == 0)
2793             {
2794               bfd_nonfatal_message (NULL, ibfd, osec, _("warning: note section is empty"));
2795               merge_notes = FALSE;
2796             }
2797           else if (! bfd_get_full_section_contents (ibfd, osec, & merged_notes))
2798             {
2799               bfd_nonfatal_message (NULL, ibfd, osec, _("warning: could not load note section"));
2800               free (merged_notes);
2801               merged_notes = NULL;
2802               merge_notes = FALSE;
2803             }
2804           else
2805             {
2806               merged_size = merge_gnu_build_notes (ibfd, osec, size, merged_notes);
2807               if (merged_size == size)
2808                 {
2809                   /* Merging achieves nothing.  */
2810                   free (merged_notes);
2811                   merged_notes = NULL;
2812                   merge_notes = FALSE;
2813                   merged_size = 0;
2814                 }
2815               else
2816                 {
2817                   if (osec->output_section == NULL
2818                       || ! bfd_set_section_size (obfd, osec->output_section, merged_size))
2819                     {
2820                       bfd_nonfatal_message (NULL, obfd, osec, _("warning: failed to set merged notes size"));
2821                       free (merged_notes);
2822                       merged_notes = NULL;
2823                       merge_notes = FALSE;
2824                       merged_size = 0;
2825                     }
2826                 }
2827             }
2828         }
2829     }
2830
2831   if (dump_sections != NULL)
2832     {
2833       struct section_add * pdump;
2834
2835       for (pdump = dump_sections; pdump != NULL; pdump = pdump->next)
2836         {
2837           osec = bfd_get_section_by_name (ibfd, pdump->name);
2838           if (osec == NULL)
2839             {
2840               bfd_nonfatal_message (NULL, ibfd, NULL,
2841                                     _("can't dump section '%s' - it does not exist"),
2842                                     pdump->name);
2843               continue;
2844             }
2845
2846           if ((bfd_get_section_flags (ibfd, osec) & SEC_HAS_CONTENTS) == 0)
2847             {
2848               bfd_nonfatal_message (NULL, ibfd, osec,
2849                                     _("can't dump section - it has no contents"));
2850               continue;
2851             }
2852
2853           bfd_size_type size = bfd_get_section_size (osec);
2854           if (size == 0)
2855             {
2856               bfd_nonfatal_message (NULL, ibfd, osec,
2857                                     _("can't dump section - it is empty"));
2858               continue;
2859             }
2860
2861           FILE * f;
2862           f = fopen (pdump->filename, FOPEN_WB);
2863           if (f == NULL)
2864             {
2865               bfd_nonfatal_message (pdump->filename, NULL, NULL,
2866                                     _("could not open section dump file"));
2867               continue;
2868             }
2869
2870           bfd_byte *contents;
2871           if (bfd_malloc_and_get_section (ibfd, osec, &contents))
2872             {
2873               if (fwrite (contents, 1, size, f) != size)
2874                 {
2875                   non_fatal (_("error writing section contents to %s (error: %s)"),
2876                              pdump->filename,
2877                              strerror (errno));
2878                   free (contents);
2879                   fclose (f);
2880                   return FALSE;
2881                 }
2882             }
2883           else
2884             bfd_nonfatal_message (NULL, ibfd, osec,
2885                                   _("could not retrieve section contents"));
2886
2887           fclose (f);
2888           free (contents);
2889         }
2890     }
2891
2892   if (gnu_debuglink_filename != NULL)
2893     {
2894       /* PR 15125: Give a helpful warning message if
2895          the debuglink section already exists, and
2896          allow the rest of the copy to complete.  */
2897       if (bfd_get_section_by_name (obfd, ".gnu_debuglink"))
2898         {
2899           non_fatal (_("%s: debuglink section already exists"),
2900                      bfd_get_filename (obfd));
2901           gnu_debuglink_filename = NULL;
2902         }
2903       else
2904         {
2905           gnu_debuglink_section = bfd_create_gnu_debuglink_section
2906             (obfd, gnu_debuglink_filename);
2907
2908           if (gnu_debuglink_section == NULL)
2909             {
2910               bfd_nonfatal_message (NULL, obfd, NULL,
2911                                     _("cannot create debug link section `%s'"),
2912                                     gnu_debuglink_filename);
2913               return FALSE;
2914             }
2915
2916           /* Special processing for PE format files.  We
2917              have no way to distinguish PE from COFF here.  */
2918           if (bfd_get_flavour (obfd) == bfd_target_coff_flavour)
2919             {
2920               bfd_vma debuglink_vma;
2921               asection * highest_section;
2922
2923               /* The PE spec requires that all sections be adjacent and sorted
2924                  in ascending order of VMA.  It also specifies that debug
2925                  sections should be last.  This is despite the fact that debug
2926                  sections are not loaded into memory and so in theory have no
2927                  use for a VMA.
2928
2929                  This means that the debuglink section must be given a non-zero
2930                  VMA which makes it contiguous with other debug sections.  So
2931                  walk the current section list, find the section with the
2932                  highest VMA and start the debuglink section after that one.  */
2933               for (osec = obfd->sections, highest_section = NULL;
2934                    osec != NULL;
2935                    osec = osec->next)
2936                 if (osec->vma > 0
2937                     && (highest_section == NULL
2938                         || osec->vma > highest_section->vma))
2939                   highest_section = osec;
2940
2941               if (highest_section)
2942                 debuglink_vma = BFD_ALIGN (highest_section->vma
2943                                            + highest_section->size,
2944                                            /* FIXME: We ought to be using
2945                                               COFF_PAGE_SIZE here or maybe
2946                                               bfd_get_section_alignment() (if it
2947                                               was set) but since this is for PE
2948                                               and we know the required alignment
2949                                               it is easier just to hard code it.  */
2950                                            0x1000);
2951               else
2952                 /* Umm, not sure what to do in this case.  */
2953                 debuglink_vma = 0x1000;
2954
2955               bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma);
2956             }
2957         }
2958     }
2959
2960   c = bfd_count_sections (obfd);
2961   if (c != 0
2962       && (gap_fill_set || pad_to_set))
2963     {
2964       asection **set;
2965
2966       /* We must fill in gaps between the sections and/or we must pad
2967          the last section to a specified address.  We do this by
2968          grabbing a list of the sections, sorting them by VMA, and
2969          increasing the section sizes as required to fill the gaps.
2970          We write out the gap contents below.  */
2971
2972       osections = (asection **) xmalloc (c * sizeof (asection *));
2973       set = osections;
2974       bfd_map_over_sections (obfd, get_sections, &set);
2975
2976       qsort (osections, c, sizeof (asection *), compare_section_lma);
2977
2978       gaps = (bfd_size_type *) xmalloc (c * sizeof (bfd_size_type));
2979       memset (gaps, 0, c * sizeof (bfd_size_type));
2980
2981       if (gap_fill_set)
2982         {
2983           for (i = 0; i < c - 1; i++)
2984             {
2985               flagword flags;
2986               bfd_size_type size;
2987               bfd_vma gap_start, gap_stop;
2988
2989               flags = bfd_get_section_flags (obfd, osections[i]);
2990               if ((flags & SEC_HAS_CONTENTS) == 0
2991                   || (flags & SEC_LOAD) == 0)
2992                 continue;
2993
2994               size = bfd_section_size (obfd, osections[i]);
2995               gap_start = bfd_section_lma (obfd, osections[i]) + size;
2996               gap_stop = bfd_section_lma (obfd, osections[i + 1]);
2997               if (gap_start < gap_stop)
2998                 {
2999                   if (! bfd_set_section_size (obfd, osections[i],
3000                                               size + (gap_stop - gap_start)))
3001                     {
3002                       bfd_nonfatal_message (NULL, obfd, osections[i],
3003                                             _("Can't fill gap after section"));
3004                       status = 1;
3005                       break;
3006                     }
3007                   gaps[i] = gap_stop - gap_start;
3008                   if (max_gap < gap_stop - gap_start)
3009                     max_gap = gap_stop - gap_start;
3010                 }
3011             }
3012         }
3013
3014       if (pad_to_set)
3015         {
3016           bfd_vma lma;
3017           bfd_size_type size;
3018
3019           lma = bfd_section_lma (obfd, osections[c - 1]);
3020           size = bfd_section_size (obfd, osections[c - 1]);
3021           if (lma + size < pad_to)
3022             {
3023               if (! bfd_set_section_size (obfd, osections[c - 1],
3024                                           pad_to - lma))
3025                 {
3026                   bfd_nonfatal_message (NULL, obfd, osections[c - 1],
3027                                         _("can't add padding"));
3028                   status = 1;
3029                 }
3030               else
3031                 {
3032                   gaps[c - 1] = pad_to - (lma + size);
3033                   if (max_gap < pad_to - (lma + size))
3034                     max_gap = pad_to - (lma + size);
3035                 }
3036             }
3037         }
3038     }
3039
3040   /* Symbol filtering must happen after the output sections
3041      have been created, but before their contents are set.  */
3042   dhandle = NULL;
3043   if (convert_debugging)
3044     dhandle = read_debugging_info (ibfd, isympp, symcount, FALSE);
3045
3046   if (strip_symbols == STRIP_DEBUG
3047       || strip_symbols == STRIP_ALL
3048       || strip_symbols == STRIP_UNNEEDED
3049       || strip_symbols == STRIP_NONDEBUG
3050       || strip_symbols == STRIP_DWO
3051       || strip_symbols == STRIP_NONDWO
3052       || discard_locals != LOCALS_UNDEF
3053       || localize_hidden
3054       || htab_elements (strip_specific_htab) != 0
3055       || htab_elements (keep_specific_htab) != 0
3056       || htab_elements (localize_specific_htab) != 0
3057       || htab_elements (globalize_specific_htab) != 0
3058       || htab_elements (keepglobal_specific_htab) != 0
3059       || htab_elements (weaken_specific_htab) != 0
3060       || htab_elements (redefine_specific_htab) != 0
3061       || prefix_symbols_string
3062       || sections_removed
3063       || sections_copied
3064       || convert_debugging
3065       || change_leading_char
3066       || remove_leading_char
3067       || section_rename_list
3068       || weaken
3069       || add_symbols)
3070     {
3071       /* Mark symbols used in output relocations so that they
3072          are kept, even if they are local labels or static symbols.
3073
3074          Note we iterate over the input sections examining their
3075          relocations since the relocations for the output sections
3076          haven't been set yet.  mark_symbols_used_in_relocations will
3077          ignore input sections which have no corresponding output
3078          section.  */
3079       if (strip_symbols != STRIP_ALL)
3080         {
3081           bfd_set_error (bfd_error_no_error);
3082           bfd_map_over_sections (ibfd,
3083                                  mark_symbols_used_in_relocations,
3084                                  isympp);
3085           if (bfd_get_error () != bfd_error_no_error)
3086             {
3087               status = 1;
3088               return FALSE;
3089             }
3090         }
3091
3092       osympp = (asymbol **) xmalloc ((symcount + add_symbols + 1) * sizeof (asymbol *));
3093       symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
3094     }
3095
3096   if (convert_debugging && dhandle != NULL)
3097     {
3098       bfd_boolean res;
3099
3100       res = write_debugging_info (obfd, dhandle, &symcount, &osympp);
3101
3102       free (dhandle);
3103       dhandle = NULL; /* Paranoia...  */
3104
3105       if (! res)
3106         {
3107           status = 1;
3108           return FALSE;
3109         }
3110     }
3111
3112   bfd_set_symtab (obfd, osympp, symcount);
3113
3114   /* This has to happen before section positions are set.  */
3115   bfd_map_over_sections (ibfd, copy_relocations_in_section, obfd);
3116
3117   /* This has to happen after the symbol table has been set.  */
3118   bfd_map_over_sections (ibfd, copy_section, obfd);
3119
3120   if (add_sections != NULL)
3121     {
3122       struct section_add *padd;
3123
3124       for (padd = add_sections; padd != NULL; padd = padd->next)
3125         {
3126           if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
3127                                           0, padd->size))
3128             {
3129               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
3130               return FALSE;
3131             }
3132         }
3133     }
3134
3135   if (update_sections != NULL)
3136     {
3137       struct section_add *pupdate;
3138
3139       for (pupdate = update_sections;
3140            pupdate != NULL;
3141            pupdate = pupdate->next)
3142         {
3143           osec = pupdate->section->output_section;
3144           if (! bfd_set_section_contents (obfd, osec, pupdate->contents,
3145                                           0, pupdate->size))
3146             {
3147               bfd_nonfatal_message (NULL, obfd, osec, NULL);
3148               return FALSE;
3149             }
3150         }
3151     }
3152
3153   if (merge_notes)
3154     {
3155       osec = bfd_get_section_by_name (obfd, GNU_BUILD_ATTRS_SECTION_NAME);
3156       if (osec && is_merged_note_section (obfd, osec))
3157         {
3158           if (! bfd_set_section_contents (obfd, osec, merged_notes, 0, merged_size))
3159             {
3160               bfd_nonfatal_message (NULL, obfd, osec, _("error: failed to copy merged notes into output"));
3161               return FALSE;
3162             }
3163         }
3164       else if (! is_strip)
3165         bfd_nonfatal_message (NULL, obfd, osec, _("could not find any mergeable note sections"));
3166       free (merged_notes);
3167       merged_notes = NULL;
3168       merge_notes = FALSE;
3169     }
3170
3171   if (gnu_debuglink_filename != NULL)
3172     {
3173       if (! bfd_fill_in_gnu_debuglink_section
3174           (obfd, gnu_debuglink_section, gnu_debuglink_filename))
3175         {
3176           bfd_nonfatal_message (NULL, obfd, NULL,
3177                                 _("cannot fill debug link section `%s'"),
3178                                 gnu_debuglink_filename);
3179           return FALSE;
3180         }
3181     }
3182
3183   if (gap_fill_set || pad_to_set)
3184     {
3185       bfd_byte *buf;
3186
3187       /* Fill in the gaps.  */
3188       if (max_gap > 8192)
3189         max_gap = 8192;
3190       buf = (bfd_byte *) xmalloc (max_gap);
3191       memset (buf, gap_fill, max_gap);
3192
3193       c = bfd_count_sections (obfd);
3194       for (i = 0; i < c; i++)
3195         {
3196           if (gaps[i] != 0)
3197             {
3198               bfd_size_type left;
3199               file_ptr off;
3200
3201               left = gaps[i];
3202               off = bfd_section_size (obfd, osections[i]) - left;
3203
3204               while (left > 0)
3205                 {
3206                   bfd_size_type now;
3207
3208                   if (left > 8192)
3209                     now = 8192;
3210                   else
3211                     now = left;
3212
3213                   if (! bfd_set_section_contents (obfd, osections[i], buf,
3214                                                   off, now))
3215                     {
3216                       bfd_nonfatal_message (NULL, obfd, osections[i], NULL);
3217                       free (buf);
3218                       return FALSE;
3219                     }
3220
3221                   left -= now;
3222                   off += now;
3223                 }
3224             }
3225         }
3226
3227       free (buf);
3228       free (gaps);
3229       gaps = NULL;
3230     }
3231
3232   /* Allow the BFD backend to copy any private data it understands
3233      from the input BFD to the output BFD.  This is done last to
3234      permit the routine to look at the filtered symbol table, which is
3235      important for the ECOFF code at least.  */
3236   if (! bfd_copy_private_bfd_data (ibfd, obfd))
3237     {
3238       bfd_nonfatal_message (NULL, obfd, NULL,
3239                             _("error copying private BFD data"));
3240       return FALSE;
3241     }
3242
3243   /* Switch to the alternate machine code.  We have to do this at the
3244      very end, because we only initialize the header when we create
3245      the first section.  */
3246   if (use_alt_mach_code != 0)
3247     {
3248       if (! bfd_alt_mach_code (obfd, use_alt_mach_code))
3249         {
3250           non_fatal (_("this target does not support %lu alternative machine codes"),
3251                      use_alt_mach_code);
3252           if (bfd_get_flavour (obfd) == bfd_target_elf_flavour)
3253             {
3254               non_fatal (_("treating that number as an absolute e_machine value instead"));
3255               elf_elfheader (obfd)->e_machine = use_alt_mach_code;
3256             }
3257           else
3258             non_fatal (_("ignoring the alternative value"));
3259         }
3260     }
3261
3262   return TRUE;
3263 }
3264
3265 /* Read each archive element in turn from IBFD, copy the
3266    contents to temp file, and keep the temp file handle.
3267    If 'force_output_target' is TRUE then make sure that
3268    all elements in the new archive are of the type
3269    'output_target'.  */
3270
3271 static void
3272 copy_archive (bfd *ibfd, bfd *obfd, const char *output_target,
3273               bfd_boolean force_output_target,
3274               const bfd_arch_info_type *input_arch)
3275 {
3276   struct name_list
3277     {
3278       struct name_list *next;
3279       const char *name;
3280       bfd *obfd;
3281     } *list, *l;
3282   bfd **ptr = &obfd->archive_head;
3283   bfd *this_element;
3284   char *dir;
3285   const char *filename;
3286
3287   /* PR 24281: It is not clear what should happen when copying a thin archive.
3288      One part is straight forward - if the output archive is in a different
3289      directory from the input archive then any relative paths in the library
3290      should be adjusted to the new location.  But if any transformation
3291      options are active (eg strip, rename, add, etc) then the implication is
3292      that these should be applied to the files pointed to by the archive.
3293      But since objcopy is not destructive, this means that new files must be
3294      created, and there is no guidance for the names of the new files.  (Plus
3295      this conflicts with one of the goals of thin libraries - only taking up
3296      a  minimal amount of space in the file system).
3297
3298      So for now we fail if an attempt is made to copy such libraries.  */
3299   if (ibfd->is_thin_archive)
3300     {
3301       status = 1;
3302       bfd_set_error (bfd_error_invalid_operation);
3303       bfd_nonfatal_message (NULL, ibfd, NULL,
3304                             _("sorry: copying thin archives is not currently supported"));
3305       return;
3306     }
3307
3308   /* Make a temp directory to hold the contents.  */
3309   dir = make_tempdir (bfd_get_filename (obfd));
3310   if (dir == NULL)
3311     fatal (_("cannot create tempdir for archive copying (error: %s)"),
3312            strerror (errno));
3313
3314   if (strip_symbols == STRIP_ALL)
3315     obfd->has_armap = FALSE;
3316   else
3317     obfd->has_armap = ibfd->has_armap;
3318   obfd->is_thin_archive = ibfd->is_thin_archive;
3319
3320   if (deterministic)
3321     obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
3322
3323   list = NULL;
3324
3325   this_element = bfd_openr_next_archived_file (ibfd, NULL);
3326
3327   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
3328     {
3329       status = 1;
3330       bfd_nonfatal_message (NULL, obfd, NULL, NULL);
3331       goto cleanup_and_exit;
3332     }
3333
3334   while (!status && this_element != NULL)
3335     {
3336       char *output_name;
3337       bfd *output_bfd;
3338       bfd *last_element;
3339       struct stat buf;
3340       int stat_status = 0;
3341       bfd_boolean del = TRUE;
3342       bfd_boolean ok_object;
3343
3344       /* PR binutils/17533: Do not allow directory traversal
3345          outside of the current directory tree by archive members.  */
3346       if (! is_valid_archive_path (bfd_get_filename (this_element)))
3347         {
3348           non_fatal (_("illegal pathname found in archive member: %s"),
3349                      bfd_get_filename (this_element));
3350           status = 1;
3351           goto cleanup_and_exit;
3352         }
3353
3354       /* Create an output file for this member.  */
3355       output_name = concat (dir, "/",
3356                             bfd_get_filename (this_element), (char *) 0);
3357
3358       /* If the file already exists, make another temp dir.  */
3359       if (stat (output_name, &buf) >= 0)
3360         {
3361           char * tmpdir = make_tempdir (output_name);
3362
3363           free (output_name);
3364           if (tmpdir == NULL)
3365             {
3366               non_fatal (_("cannot create tempdir for archive copying (error: %s)"),
3367                          strerror (errno));
3368               status = 1;
3369               goto cleanup_and_exit;
3370             }
3371
3372           l = (struct name_list *) xmalloc (sizeof (struct name_list));
3373           l->name = tmpdir;
3374           l->next = list;
3375           l->obfd = NULL;
3376           list = l;
3377           output_name = concat (tmpdir, "/",
3378                                 bfd_get_filename (this_element), (char *) 0);
3379         }
3380
3381       if (preserve_dates)
3382         {
3383           stat_status = bfd_stat_arch_elt (this_element, &buf);
3384
3385           if (stat_status != 0)
3386             non_fatal (_("internal stat error on %s"),
3387                        bfd_get_filename (this_element));
3388         }
3389
3390       l = (struct name_list *) xmalloc (sizeof (struct name_list));
3391       l->name = output_name;
3392       l->next = list;
3393       l->obfd = NULL;
3394       list = l;
3395
3396       ok_object = bfd_check_format (this_element, bfd_object);
3397       if (!ok_object)
3398         bfd_nonfatal_message (NULL, this_element, NULL,
3399                               _("Unable to recognise the format of file"));
3400
3401       /* PR binutils/3110: Cope with archives
3402          containing multiple target types.  */
3403       if (force_output_target || !ok_object)
3404         output_bfd = bfd_openw (output_name, output_target);
3405       else
3406         output_bfd = bfd_openw (output_name, bfd_get_target (this_element));
3407
3408       if (output_bfd == NULL)
3409         {
3410           bfd_nonfatal_message (output_name, NULL, NULL, NULL);
3411           status = 1;
3412           goto cleanup_and_exit;
3413         }
3414
3415       if (ok_object)
3416         {
3417           del = !copy_object (this_element, output_bfd, input_arch);
3418
3419           if (del && bfd_get_arch (this_element) == bfd_arch_unknown)
3420             /* Try again as an unknown object file.  */
3421             ok_object = FALSE;
3422           else if (!bfd_close (output_bfd))
3423             {
3424               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
3425               /* Error in new object file. Don't change archive.  */
3426               status = 1;
3427             }
3428         }
3429
3430       if (!ok_object)
3431         {
3432           del = !copy_unknown_object (this_element, output_bfd);
3433           if (!bfd_close_all_done (output_bfd))
3434             {
3435               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
3436               /* Error in new object file. Don't change archive.  */
3437               status = 1;
3438             }
3439         }
3440
3441       if (del)
3442         {
3443           unlink (output_name);
3444           status = 1;
3445         }
3446       else
3447         {
3448           if (preserve_dates && stat_status == 0)
3449             set_times (output_name, &buf);
3450
3451           /* Open the newly output file and attach to our list.  */
3452           output_bfd = bfd_openr (output_name, output_target);
3453
3454           l->obfd = output_bfd;
3455
3456           *ptr = output_bfd;
3457           ptr = &output_bfd->archive_next;
3458
3459           last_element = this_element;
3460
3461           this_element = bfd_openr_next_archived_file (ibfd, last_element);
3462
3463           bfd_close (last_element);
3464         }
3465     }
3466   *ptr = NULL;
3467
3468   filename = bfd_get_filename (obfd);
3469   if (!bfd_close (obfd))
3470     {
3471       status = 1;
3472       bfd_nonfatal_message (filename, NULL, NULL, NULL);
3473     }
3474
3475   filename = bfd_get_filename (ibfd);
3476   if (!bfd_close (ibfd))
3477     {
3478       status = 1;
3479       bfd_nonfatal_message (filename, NULL, NULL, NULL);
3480     }
3481
3482  cleanup_and_exit:
3483   /* Delete all the files that we opened.  */
3484   {
3485     struct name_list * next;
3486
3487     for (l = list; l != NULL; l = next)
3488       {
3489         if (l->obfd == NULL)
3490           rmdir (l->name);
3491         else
3492           {
3493             bfd_close (l->obfd);
3494             unlink (l->name);
3495           }
3496         next = l->next;
3497         free (l);
3498       }
3499   }
3500
3501   rmdir (dir);
3502 }
3503
3504 static void
3505 set_long_section_mode (bfd *output_bfd, bfd *input_bfd, enum long_section_name_handling style)
3506 {
3507   /* This is only relevant to Coff targets.  */
3508   if (bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
3509     {
3510       if (style == KEEP
3511           && bfd_get_flavour (input_bfd) == bfd_target_coff_flavour)
3512         style = bfd_coff_long_section_names (input_bfd) ? ENABLE : DISABLE;
3513       bfd_coff_set_long_section_names (output_bfd, style != DISABLE);
3514     }
3515 }
3516
3517 /* The top-level control.  */
3518
3519 static void
3520 copy_file (const char *input_filename, const char *output_filename,
3521            const char *input_target,   const char *output_target,
3522            const bfd_arch_info_type *input_arch)
3523 {
3524   bfd *ibfd;
3525   char **obj_matching;
3526   char **core_matching;
3527   off_t size = get_file_size (input_filename);
3528
3529   if (size < 1)
3530     {
3531       if (size == 0)
3532         non_fatal (_("error: the input file '%s' is empty"),
3533                    input_filename);
3534       status = 1;
3535       return;
3536     }
3537
3538   /* To allow us to do "strip *" without dying on the first
3539      non-object file, failures are nonfatal.  */
3540   ibfd = bfd_openr (input_filename, input_target);
3541   if (ibfd == NULL)
3542     {
3543       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
3544       status = 1;
3545       return;
3546     }
3547
3548   switch (do_debug_sections)
3549     {
3550     case compress:
3551     case compress_zlib:
3552     case compress_gnu_zlib:
3553     case compress_gabi_zlib:
3554       ibfd->flags |= BFD_COMPRESS;
3555       /* Don't check if input is ELF here since this information is
3556          only available after bfd_check_format_matches is called.  */
3557       if (do_debug_sections != compress_gnu_zlib)
3558         ibfd->flags |= BFD_COMPRESS_GABI;
3559       break;
3560     case decompress:
3561       ibfd->flags |= BFD_DECOMPRESS;
3562       break;
3563     default:
3564       break;
3565     }
3566
3567   switch (do_elf_stt_common)
3568     {
3569     case elf_stt_common:
3570       ibfd->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON;
3571       break;
3572       break;
3573     case no_elf_stt_common:
3574       ibfd->flags |= BFD_CONVERT_ELF_COMMON;
3575       break;
3576     default:
3577       break;
3578     }
3579
3580   if (bfd_check_format (ibfd, bfd_archive))
3581     {
3582       bfd_boolean force_output_target;
3583       bfd *obfd;
3584
3585       /* bfd_get_target does not return the correct value until
3586          bfd_check_format succeeds.  */
3587       if (output_target == NULL)
3588         {
3589           output_target = bfd_get_target (ibfd);
3590           force_output_target = FALSE;
3591         }
3592       else
3593         force_output_target = TRUE;
3594
3595       obfd = bfd_openw (output_filename, output_target);
3596       if (obfd == NULL)
3597         {
3598           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
3599           status = 1;
3600           return;
3601         }
3602       /* This is a no-op on non-Coff targets.  */
3603       set_long_section_mode (obfd, ibfd, long_section_names);
3604
3605       copy_archive (ibfd, obfd, output_target, force_output_target, input_arch);
3606     }
3607   else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
3608     {
3609       bfd *obfd;
3610     do_copy:
3611
3612       /* bfd_get_target does not return the correct value until
3613          bfd_check_format succeeds.  */
3614       if (output_target == NULL)
3615         output_target = bfd_get_target (ibfd);
3616
3617       obfd = bfd_openw (output_filename, output_target);
3618       if (obfd == NULL)
3619         {
3620           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
3621           status = 1;
3622           return;
3623         }
3624       /* This is a no-op on non-Coff targets.  */
3625       set_long_section_mode (obfd, ibfd, long_section_names);
3626
3627       if (! copy_object (ibfd, obfd, input_arch))
3628         status = 1;
3629
3630       /* PR 17512: file: 0f15796a.
3631          If the file could not be copied it may not be in a writeable
3632          state.  So use bfd_close_all_done to avoid the possibility of
3633          writing uninitialised data into the file.  */
3634       if (! (status ? bfd_close_all_done (obfd) : bfd_close (obfd)))
3635         {
3636           status = 1;
3637           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
3638           return;
3639         }
3640
3641       if (!bfd_close (ibfd))
3642         {
3643           status = 1;
3644           bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
3645           return;
3646         }
3647     }
3648   else
3649     {
3650       bfd_error_type obj_error = bfd_get_error ();
3651       bfd_error_type core_error;
3652
3653       if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
3654         {
3655           /* This probably can't happen..  */
3656           if (obj_error == bfd_error_file_ambiguously_recognized)
3657             free (obj_matching);
3658           goto do_copy;
3659         }
3660
3661       core_error = bfd_get_error ();
3662       /* Report the object error in preference to the core error.  */
3663       if (obj_error != core_error)
3664         bfd_set_error (obj_error);
3665
3666       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
3667
3668       if (obj_error == bfd_error_file_ambiguously_recognized)
3669         {
3670           list_matching_formats (obj_matching);
3671           free (obj_matching);
3672         }
3673       if (core_error == bfd_error_file_ambiguously_recognized)
3674         {
3675           list_matching_formats (core_matching);
3676           free (core_matching);
3677         }
3678
3679       status = 1;
3680     }
3681 }
3682
3683 /* Add a name to the section renaming list.  */
3684
3685 static void
3686 add_section_rename (const char * old_name, const char * new_name,
3687                     flagword flags)
3688 {
3689   section_rename * srename;
3690
3691   /* Check for conflicts first.  */
3692   for (srename = section_rename_list; srename != NULL; srename = srename->next)
3693     if (strcmp (srename->old_name, old_name) == 0)
3694       {
3695         /* Silently ignore duplicate definitions.  */
3696         if (strcmp (srename->new_name, new_name) == 0
3697             && srename->flags == flags)
3698           return;
3699
3700         fatal (_("Multiple renames of section %s"), old_name);
3701       }
3702
3703   srename = (section_rename *) xmalloc (sizeof (* srename));
3704
3705   srename->old_name = old_name;
3706   srename->new_name = new_name;
3707   srename->flags    = flags;
3708   srename->next     = section_rename_list;
3709
3710   section_rename_list = srename;
3711 }
3712
3713 /* Check the section rename list for a new name of the input section
3714    called OLD_NAME.  Returns the new name if one is found and sets
3715    RETURNED_FLAGS if non-NULL to the flags to be used for this section.  */
3716
3717 static const char *
3718 find_section_rename (const char *old_name, flagword *returned_flags)
3719 {
3720   const section_rename *srename;
3721
3722   for (srename = section_rename_list; srename != NULL; srename = srename->next)
3723     if (strcmp (srename->old_name, old_name) == 0)
3724       {
3725         if (returned_flags != NULL && srename->flags != (flagword) -1)
3726           *returned_flags = srename->flags;
3727
3728         return srename->new_name;
3729       }
3730
3731   return old_name;
3732 }
3733
3734 /* Once each of the sections is copied, we may still need to do some
3735    finalization work for private section headers.  Do that here.  */
3736
3737 static void
3738 setup_bfd_headers (bfd *ibfd, bfd *obfd)
3739 {
3740   /* Allow the BFD backend to copy any private data it understands
3741      from the input section to the output section.  */
3742   if (! bfd_copy_private_header_data (ibfd, obfd))
3743     {
3744       status = 1;
3745       bfd_nonfatal_message (NULL, ibfd, NULL,
3746                             _("error in private header data"));
3747       return;
3748     }
3749
3750   /* All went well.  */
3751   return;
3752 }
3753
3754 /* Create a section in OBFD with the same
3755    name and attributes as ISECTION in IBFD.  */
3756
3757 static void
3758 setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
3759 {
3760   bfd *obfd = (bfd *) obfdarg;
3761   struct section_list *p;
3762   sec_ptr osection;
3763   bfd_size_type size;
3764   bfd_vma vma;
3765   bfd_vma lma;
3766   flagword flags;
3767   const char *err;
3768   const char * name;
3769   char *prefix = NULL;
3770   bfd_boolean make_nobits;
3771
3772   if (is_strip_section (ibfd, isection))
3773     return;
3774
3775   /* Get the, possibly new, name of the output section.  */
3776   name = bfd_section_name (ibfd, isection);
3777   flags = bfd_get_section_flags (ibfd, isection);
3778   name = find_section_rename (name, &flags);
3779
3780   /* Prefix sections.  */
3781   if ((prefix_alloc_sections_string)
3782       && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
3783     prefix = prefix_alloc_sections_string;
3784   else if (prefix_sections_string)
3785     prefix = prefix_sections_string;
3786
3787   if (prefix)
3788     {
3789       char *n;
3790
3791       n = (char *) xmalloc (strlen (prefix) + strlen (name) + 1);
3792       strcpy (n, prefix);
3793       strcat (n, name);
3794       name = n;
3795     }
3796
3797   make_nobits = FALSE;
3798
3799   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
3800                          SECTION_CONTEXT_SET_FLAGS);
3801   if (p != NULL)
3802     flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
3803   else if (strip_symbols == STRIP_NONDEBUG
3804            && (flags & (SEC_ALLOC | SEC_GROUP)) != 0
3805            && !is_nondebug_keep_contents_section (ibfd, isection))
3806     {
3807       flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
3808       if (obfd->xvec->flavour == bfd_target_elf_flavour)
3809         {
3810           make_nobits = TRUE;
3811
3812           /* Twiddle the input section flags so that it seems to
3813              elf.c:copy_private_bfd_data that section flags have not
3814              changed between input and output sections.  This hack
3815              prevents wholesale rewriting of the program headers.  */
3816           isection->flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
3817         }
3818     }
3819
3820   osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
3821
3822   if (osection == NULL)
3823     {
3824       err = _("failed to create output section");
3825       goto loser;
3826     }
3827
3828   if (make_nobits)
3829     elf_section_type (osection) = SHT_NOBITS;
3830
3831   size = bfd_section_size (ibfd, isection);
3832   size = bfd_convert_section_size (ibfd, isection, obfd, size);
3833   if (copy_byte >= 0)
3834     size = (size + interleave - 1) / interleave * copy_width;
3835   else if (extract_symbol)
3836     size = 0;
3837   if (! bfd_set_section_size (obfd, osection, size))
3838     {
3839       err = _("failed to set size");
3840       goto loser;
3841     }
3842
3843   vma = bfd_section_vma (ibfd, isection);
3844   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
3845                          SECTION_CONTEXT_ALTER_VMA | SECTION_CONTEXT_SET_VMA);
3846   if (p != NULL)
3847     {
3848       if (p->context & SECTION_CONTEXT_SET_VMA)
3849         vma = p->vma_val;
3850       else
3851         vma += p->vma_val;
3852     }
3853   else
3854     vma += change_section_address;
3855
3856   if (! bfd_set_section_vma (obfd, osection, vma))
3857     {
3858       err = _("failed to set vma");
3859       goto loser;
3860     }
3861
3862   lma = isection->lma;
3863   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
3864                          SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_SET_LMA);
3865   if (p != NULL)
3866     {
3867       if (p->context & SECTION_CONTEXT_ALTER_LMA)
3868         lma += p->lma_val;
3869       else
3870         lma = p->lma_val;
3871     }
3872   else
3873     lma += change_section_address;
3874
3875   osection->lma = lma;
3876
3877   /* FIXME: This is probably not enough.  If we change the LMA we
3878      may have to recompute the header for the file as well.  */
3879   if (!bfd_set_section_alignment (obfd,
3880                                   osection,
3881                                   bfd_section_alignment (ibfd, isection)))
3882     {
3883       err = _("failed to set alignment");
3884       goto loser;
3885     }
3886
3887   /* Copy merge entity size.  */
3888   osection->entsize = isection->entsize;
3889
3890   /* Copy compress status.  */
3891   osection->compress_status = isection->compress_status;
3892
3893   /* This used to be mangle_section; we do here to avoid using
3894      bfd_get_section_by_name since some formats allow multiple
3895      sections with the same name.  */
3896   isection->output_section = osection;
3897   isection->output_offset = 0;
3898
3899   if ((isection->flags & SEC_GROUP) != 0)
3900     {
3901       asymbol *gsym = group_signature (isection);
3902
3903       if (gsym != NULL)
3904         {
3905           gsym->flags |= BSF_KEEP;
3906           if (ibfd->xvec->flavour == bfd_target_elf_flavour)
3907             elf_group_id (isection) = gsym;
3908         }
3909     }
3910
3911   /* Allow the BFD backend to copy any private data it understands
3912      from the input section to the output section.  */
3913   if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
3914     {
3915       err = _("failed to copy private data");
3916       goto loser;
3917     }
3918
3919   /* All went well.  */
3920   return;
3921
3922  loser:
3923   status = 1;
3924   bfd_nonfatal_message (NULL, obfd, osection, err);
3925 }
3926
3927 /* Return TRUE if input section ISECTION should be skipped.  */
3928
3929 static bfd_boolean
3930 skip_section (bfd *ibfd, sec_ptr isection, bfd_boolean skip_copy)
3931 {
3932   sec_ptr osection;
3933   bfd_size_type size;
3934   flagword flags;
3935
3936   /* If we have already failed earlier on,
3937      do not keep on generating complaints now.  */
3938   if (status != 0)
3939     return TRUE;
3940
3941   if (extract_symbol)
3942     return TRUE;
3943
3944   if (is_strip_section (ibfd, isection))
3945     return TRUE;
3946
3947   if (is_update_section (ibfd, isection))
3948     return TRUE;
3949
3950   /* When merging a note section we skip the copying of the contents,
3951      but not the copying of the relocs associated with the contents.  */
3952   if (skip_copy && is_merged_note_section (ibfd, isection))
3953     return TRUE;
3954
3955   flags = bfd_get_section_flags (ibfd, isection);
3956   if ((flags & SEC_GROUP) != 0)
3957     return TRUE;
3958
3959   osection = isection->output_section;
3960   size = bfd_get_section_size (isection);
3961
3962   if (size == 0 || osection == 0)
3963     return TRUE;
3964
3965   return FALSE;
3966 }
3967
3968 /* Add section SECTION_PATTERN to the list of sections that will have their
3969    relocations removed.  */
3970
3971 static void
3972 handle_remove_relocations_option (const char *section_pattern)
3973 {
3974   find_section_list (section_pattern, TRUE, SECTION_CONTEXT_REMOVE_RELOCS);
3975 }
3976
3977 /* Return TRUE if ISECTION from IBFD should have its relocations removed,
3978    otherwise return FALSE.  If the user has requested that relocations be
3979    removed from a section that does not have relocations then this
3980    function will still return TRUE.  */
3981
3982 static bfd_boolean
3983 discard_relocations (bfd *ibfd ATTRIBUTE_UNUSED, asection *isection)
3984 {
3985   return (find_section_list (bfd_section_name (ibfd, isection), FALSE,
3986                              SECTION_CONTEXT_REMOVE_RELOCS) != NULL);
3987 }
3988
3989 /* Wrapper for dealing with --remove-section (-R) command line arguments.
3990    A special case is detected here, if the user asks to remove a relocation
3991    section (one starting with ".rela" or ".rel") then this removal must
3992    be done using a different technique in a relocatable object.  */
3993
3994 static void
3995 handle_remove_section_option (const char *section_pattern)
3996 {
3997   find_section_list (section_pattern, TRUE, SECTION_CONTEXT_REMOVE);
3998   if (strncmp (section_pattern, ".rel", 4) == 0)
3999     {
4000       section_pattern += 4;
4001       if (*section_pattern == 'a')
4002         section_pattern++;
4003       if (*section_pattern)
4004         handle_remove_relocations_option (section_pattern);
4005     }
4006   sections_removed = TRUE;
4007 }
4008
4009 /* Copy relocations in input section ISECTION of IBFD to an output
4010    section with the same name in OBFDARG.  If stripping then don't
4011    copy any relocation info.  */
4012
4013 static void
4014 copy_relocations_in_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
4015 {
4016   bfd *obfd = (bfd *) obfdarg;
4017   long relsize;
4018   arelent **relpp;
4019   long relcount;
4020   sec_ptr osection;
4021
4022  if (skip_section (ibfd, isection, FALSE))
4023     return;
4024
4025   osection = isection->output_section;
4026
4027   /* Core files and DWO files do not need to be relocated.  */
4028   if (bfd_get_format (obfd) == bfd_core
4029       || strip_symbols == STRIP_NONDWO
4030       || discard_relocations (ibfd, isection))
4031     relsize = 0;
4032   else
4033     {
4034       relsize = bfd_get_reloc_upper_bound (ibfd, isection);
4035
4036       if (relsize < 0)
4037         {
4038           /* Do not complain if the target does not support relocations.  */
4039           if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
4040             relsize = 0;
4041           else
4042             {
4043               status = 1;
4044               bfd_nonfatal_message (NULL, ibfd, isection, NULL);
4045               return;
4046             }
4047         }
4048     }
4049
4050   if (relsize == 0)
4051     {
4052       bfd_set_reloc (obfd, osection, NULL, 0);
4053       osection->flags &= ~SEC_RELOC;
4054     }
4055   else
4056     {
4057       if (isection->orelocation != NULL)
4058         {
4059           /* Some other function has already set up the output relocs
4060              for us, so scan those instead of the default relocs.  */
4061           relcount = isection->reloc_count;
4062           relpp = isection->orelocation;
4063         }
4064       else
4065         {
4066           relpp = (arelent **) xmalloc (relsize);
4067           relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
4068           if (relcount < 0)
4069             {
4070               status = 1;
4071               bfd_nonfatal_message (NULL, ibfd, isection,
4072                                     _("relocation count is negative"));
4073               return;
4074             }
4075         }
4076
4077       if (strip_symbols == STRIP_ALL)
4078         {
4079           /* Remove relocations which are not in
4080              keep_strip_specific_list.  */
4081           arelent **temp_relpp;
4082           long temp_relcount = 0;
4083           long i;
4084
4085           temp_relpp = (arelent **) xmalloc (relsize);
4086           for (i = 0; i < relcount; i++)
4087             {
4088               /* PR 17512: file: 9e907e0c.  */
4089               if (relpp[i]->sym_ptr_ptr
4090                   /* PR 20096 */
4091                   && * relpp[i]->sym_ptr_ptr)
4092                 if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
4093                                          keep_specific_htab))
4094                   temp_relpp [temp_relcount++] = relpp [i];
4095             }
4096           relcount = temp_relcount;
4097           if (isection->orelocation == NULL)
4098             free (relpp);
4099           relpp = temp_relpp;
4100         }
4101
4102       bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
4103       if (relcount == 0)
4104         {
4105           osection->flags &= ~SEC_RELOC;
4106           free (relpp);
4107         }
4108     }
4109 }
4110
4111 /* Copy the data of input section ISECTION of IBFD
4112    to an output section with the same name in OBFD.  */
4113
4114 static void
4115 copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
4116 {
4117   bfd *obfd = (bfd *) obfdarg;
4118   struct section_list *p;
4119   sec_ptr osection;
4120   bfd_size_type size;
4121
4122   if (skip_section (ibfd, isection, TRUE))
4123     return;
4124
4125   osection = isection->output_section;
4126   /* The output SHF_COMPRESSED section size is different from input if
4127      ELF classes of input and output aren't the same.  We can't use
4128      the output section size since --interleave will shrink the output
4129      section.   Size will be updated if the section is converted.   */
4130   size = bfd_get_section_size (isection);
4131
4132   if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
4133       && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
4134     {
4135       bfd_byte *memhunk = NULL;
4136
4137       if (!bfd_get_full_section_contents (ibfd, isection, &memhunk)
4138           || !bfd_convert_section_contents (ibfd, isection, obfd,
4139                                             &memhunk, &size))
4140         {
4141           status = 1;
4142           bfd_nonfatal_message (NULL, ibfd, isection, NULL);
4143           free (memhunk);
4144           return;
4145         }
4146
4147       if (reverse_bytes)
4148         {
4149           /* We don't handle leftover bytes (too many possible behaviors,
4150              and we don't know what the user wants).  The section length
4151              must be a multiple of the number of bytes to swap.  */
4152           if ((size % reverse_bytes) == 0)
4153             {
4154               unsigned long i, j;
4155               bfd_byte b;
4156
4157               for (i = 0; i < size; i += reverse_bytes)
4158                 for (j = 0; j < (unsigned long)(reverse_bytes / 2); j++)
4159                   {
4160                     bfd_byte *m = (bfd_byte *) memhunk;
4161
4162                     b = m[i + j];
4163                     m[i + j] = m[(i + reverse_bytes) - (j + 1)];
4164                     m[(i + reverse_bytes) - (j + 1)] = b;
4165                   }
4166             }
4167           else
4168             /* User must pad the section up in order to do this.  */
4169             fatal (_("cannot reverse bytes: length of section %s must be evenly divisible by %d"),
4170                    bfd_section_name (ibfd, isection), reverse_bytes);
4171         }
4172
4173       if (copy_byte >= 0)
4174         {
4175           /* Keep only every `copy_byte'th byte in MEMHUNK.  */
4176           char *from = (char *) memhunk + copy_byte;
4177           char *to = (char *) memhunk;
4178           char *end = (char *) memhunk + size;
4179           int i;
4180
4181           /* If the section address is not exactly divisible by the interleave,
4182              then we must bias the from address.  If the copy_byte is less than
4183              the bias, then we must skip forward one interleave, and increment
4184              the final lma.  */
4185           int extra = isection->lma % interleave;
4186           from -= extra;
4187           if (copy_byte < extra)
4188             from += interleave;
4189
4190           for (; from < end; from += interleave)
4191             for (i = 0; i < copy_width; i++)
4192               {
4193                 if (&from[i] >= end)
4194                   break;
4195                 *to++ = from[i];
4196               }
4197
4198           size = (size + interleave - 1 - copy_byte) / interleave * copy_width;
4199           osection->lma /= interleave;
4200           if (copy_byte < extra)
4201             osection->lma++;
4202         }
4203
4204       if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
4205         {
4206           status = 1;
4207           bfd_nonfatal_message (NULL, obfd, osection, NULL);
4208           free (memhunk);
4209           return;
4210         }
4211       free (memhunk);
4212     }
4213   else if ((p = find_section_list (bfd_get_section_name (ibfd, isection),
4214                                    FALSE, SECTION_CONTEXT_SET_FLAGS)) != NULL
4215            && (p->flags & SEC_HAS_CONTENTS) != 0)
4216     {
4217       void *memhunk = xmalloc (size);
4218
4219       /* We don't permit the user to turn off the SEC_HAS_CONTENTS
4220          flag--they can just remove the section entirely and add it
4221          back again.  However, we do permit them to turn on the
4222          SEC_HAS_CONTENTS flag, and take it to mean that the section
4223          contents should be zeroed out.  */
4224
4225       memset (memhunk, 0, size);
4226       if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
4227         {
4228           status = 1;
4229           bfd_nonfatal_message (NULL, obfd, osection, NULL);
4230           free (memhunk);
4231           return;
4232         }
4233       free (memhunk);
4234     }
4235 }
4236
4237 /* Get all the sections.  This is used when --gap-fill or --pad-to is
4238    used.  */
4239
4240 static void
4241 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
4242 {
4243   asection ***secppp = (asection ***) secppparg;
4244
4245   **secppp = osection;
4246   ++(*secppp);
4247 }
4248
4249 /* Sort sections by VMA.  This is called via qsort, and is used when
4250    --gap-fill or --pad-to is used.  We force non loadable or empty
4251    sections to the front, where they are easier to ignore.  */
4252
4253 static int
4254 compare_section_lma (const void *arg1, const void *arg2)
4255 {
4256   const asection *const *sec1 = (const asection * const *) arg1;
4257   const asection *const *sec2 = (const asection * const *) arg2;
4258   flagword flags1, flags2;
4259
4260   /* Sort non loadable sections to the front.  */
4261   flags1 = (*sec1)->flags;
4262   flags2 = (*sec2)->flags;
4263   if ((flags1 & SEC_HAS_CONTENTS) == 0
4264       || (flags1 & SEC_LOAD) == 0)
4265     {
4266       if ((flags2 & SEC_HAS_CONTENTS) != 0
4267           && (flags2 & SEC_LOAD) != 0)
4268         return -1;
4269     }
4270   else
4271     {
4272       if ((flags2 & SEC_HAS_CONTENTS) == 0
4273           || (flags2 & SEC_LOAD) == 0)
4274         return 1;
4275     }
4276
4277   /* Sort sections by LMA.  */
4278   if ((*sec1)->lma > (*sec2)->lma)
4279     return 1;
4280   else if ((*sec1)->lma < (*sec2)->lma)
4281     return -1;
4282
4283   /* Sort sections with the same LMA by size.  */
4284   if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
4285     return 1;
4286   else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
4287     return -1;
4288
4289   return 0;
4290 }
4291
4292 /* Mark all the symbols which will be used in output relocations with
4293    the BSF_KEEP flag so that those symbols will not be stripped.
4294
4295    Ignore relocations which will not appear in the output file.  */
4296
4297 static void
4298 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
4299 {
4300   asymbol **symbols = (asymbol **) symbolsarg;
4301   long relsize;
4302   arelent **relpp;
4303   long relcount, i;
4304
4305   /* Ignore an input section with no corresponding output section.  */
4306   if (isection->output_section == NULL)
4307     return;
4308
4309   relsize = bfd_get_reloc_upper_bound (ibfd, isection);
4310   if (relsize < 0)
4311     {
4312       /* Do not complain if the target does not support relocations.  */
4313       if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
4314         return;
4315       bfd_fatal (bfd_get_filename (ibfd));
4316     }
4317
4318   if (relsize == 0)
4319     return;
4320
4321   relpp = (arelent **) xmalloc (relsize);
4322   relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
4323   if (relcount < 0)
4324     bfd_fatal (bfd_get_filename (ibfd));
4325
4326   /* Examine each symbol used in a relocation.  If it's not one of the
4327      special bfd section symbols, then mark it with BSF_KEEP.  */
4328   for (i = 0; i < relcount; i++)
4329     {
4330       /* See PRs 20923 and 20930 for reproducers for the NULL tests.  */
4331       if (relpp[i]->sym_ptr_ptr != NULL
4332           && * relpp[i]->sym_ptr_ptr != NULL
4333           && *relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
4334           && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
4335           && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
4336         (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
4337     }
4338
4339   if (relpp != NULL)
4340     free (relpp);
4341 }
4342
4343 /* Write out debugging information.  */
4344
4345 static bfd_boolean
4346 write_debugging_info (bfd *obfd, void *dhandle,
4347                       long *symcountp ATTRIBUTE_UNUSED,
4348                       asymbol ***symppp ATTRIBUTE_UNUSED)
4349 {
4350   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
4351       || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
4352     {
4353       bfd_byte *syms, *strings = NULL;
4354       bfd_size_type symsize, stringsize;
4355       asection *stabsec, *stabstrsec;
4356       flagword flags;
4357
4358       if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
4359                                                     &symsize, &strings,
4360                                                     &stringsize))
4361         return FALSE;
4362
4363       flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
4364       stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
4365       stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
4366       if (stabsec == NULL
4367           || stabstrsec == NULL
4368           || ! bfd_set_section_size (obfd, stabsec, symsize)
4369           || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
4370           || ! bfd_set_section_alignment (obfd, stabsec, 2)
4371           || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
4372         {
4373           bfd_nonfatal_message (NULL, obfd, NULL,
4374                                 _("can't create debugging section"));
4375           free (strings);
4376           return FALSE;
4377         }
4378
4379       /* We can get away with setting the section contents now because
4380          the next thing the caller is going to do is copy over the
4381          real sections.  We may someday have to split the contents
4382          setting out of this function.  */
4383       if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
4384           || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
4385                                          stringsize))
4386         {
4387           bfd_nonfatal_message (NULL, obfd, NULL,
4388                                 _("can't set debugging section contents"));
4389           free (strings);
4390           return FALSE;
4391         }
4392
4393       return TRUE;
4394     }
4395
4396   bfd_nonfatal_message (NULL, obfd, NULL,
4397                         _("don't know how to write debugging information for %s"),
4398                         bfd_get_target (obfd));
4399   return FALSE;
4400 }
4401
4402 /* If neither -D nor -U was specified explicitly,
4403    then use the configured default.  */
4404 static void
4405 default_deterministic (void)
4406 {
4407   if (deterministic < 0)
4408     deterministic = DEFAULT_AR_DETERMINISTIC;
4409 }
4410
4411 static int
4412 strip_main (int argc, char *argv[])
4413 {
4414   char *input_target = NULL;
4415   char *output_target = NULL;
4416   bfd_boolean show_version = FALSE;
4417   bfd_boolean formats_info = FALSE;
4418   int c;
4419   int i;
4420   char *output_file = NULL;
4421   bfd_boolean merge_notes_set = FALSE;
4422
4423   while ((c = getopt_long (argc, argv, "I:O:F:K:MN:R:o:sSpdgxXHhVvwDU",
4424                            strip_options, (int *) 0)) != EOF)
4425     {
4426       switch (c)
4427         {
4428         case 'I':
4429           input_target = optarg;
4430           break;
4431         case 'O':
4432           output_target = optarg;
4433           break;
4434         case 'F':
4435           input_target = output_target = optarg;
4436           break;
4437         case 'R':
4438           handle_remove_section_option (optarg);
4439           break;
4440         case OPTION_REMOVE_RELOCS:
4441           handle_remove_relocations_option (optarg);
4442           break;
4443         case 's':
4444           strip_symbols = STRIP_ALL;
4445           break;
4446         case 'S':
4447         case 'g':
4448         case 'd':       /* Historic BSD alias for -g.  Used by early NetBSD.  */
4449           strip_symbols = STRIP_DEBUG;
4450           break;
4451         case OPTION_STRIP_DWO:
4452           strip_symbols = STRIP_DWO;
4453           break;
4454         case OPTION_STRIP_UNNEEDED:
4455           strip_symbols = STRIP_UNNEEDED;
4456           break;
4457         case 'K':
4458           add_specific_symbol (optarg, keep_specific_htab);
4459           break;
4460         case 'M':
4461           merge_notes = TRUE;
4462           merge_notes_set = TRUE;
4463           break;
4464         case OPTION_NO_MERGE_NOTES:
4465           merge_notes = FALSE;
4466           merge_notes_set = TRUE;
4467           break;
4468         case 'N':
4469           add_specific_symbol (optarg, strip_specific_htab);
4470           break;
4471         case 'o':
4472           output_file = optarg;
4473           break;
4474         case 'p':
4475           preserve_dates = TRUE;
4476           break;
4477         case 'D':
4478           deterministic = TRUE;
4479           break;
4480         case 'U':
4481           deterministic = FALSE;
4482           break;
4483         case 'x':
4484           discard_locals = LOCALS_ALL;
4485           break;
4486         case 'X':
4487           discard_locals = LOCALS_START_L;
4488           break;
4489         case 'v':
4490           verbose = TRUE;
4491           break;
4492         case 'V':
4493           show_version = TRUE;
4494           break;
4495         case OPTION_FORMATS_INFO:
4496           formats_info = TRUE;
4497           break;
4498         case OPTION_ONLY_KEEP_DEBUG:
4499           strip_symbols = STRIP_NONDEBUG;
4500           break;
4501         case OPTION_KEEP_FILE_SYMBOLS:
4502           keep_file_symbols = 1;
4503           break;
4504         case 0:
4505           /* We've been given a long option.  */
4506           break;
4507         case 'w':
4508           wildcard = TRUE;
4509           break;
4510         case 'H':
4511         case 'h':
4512           strip_usage (stdout, 0);
4513         default:
4514           strip_usage (stderr, 1);
4515         }
4516     }
4517
4518   /* If the user has not expressly chosen to merge/not-merge ELF notes
4519      then enable the merging unless we are stripping debug or dwo info.  */
4520   if (! merge_notes_set
4521       && (strip_symbols == STRIP_UNDEF
4522           || strip_symbols == STRIP_ALL
4523           || strip_symbols == STRIP_UNNEEDED
4524           || strip_symbols == STRIP_NONDEBUG
4525           || strip_symbols == STRIP_NONDWO))
4526     merge_notes = TRUE;
4527
4528   if (formats_info)
4529     {
4530       display_info ();
4531       return 0;
4532     }
4533
4534   if (show_version)
4535     print_version ("strip");
4536
4537   default_deterministic ();
4538
4539   /* Default is to strip all symbols.  */
4540   if (strip_symbols == STRIP_UNDEF
4541       && discard_locals == LOCALS_UNDEF
4542       && htab_elements (strip_specific_htab) == 0)
4543     strip_symbols = STRIP_ALL;
4544
4545   if (output_target == NULL)
4546     output_target = input_target;
4547
4548   i = optind;
4549   if (i == argc
4550       || (output_file != NULL && (i + 1) < argc))
4551     strip_usage (stderr, 1);
4552
4553   for (; i < argc; i++)
4554     {
4555       int hold_status = status;
4556       struct stat statbuf;
4557       char *tmpname;
4558
4559       if (get_file_size (argv[i]) < 1)
4560         {
4561           status = 1;
4562           continue;
4563         }
4564
4565       if (preserve_dates)
4566         /* No need to check the return value of stat().
4567            It has already been checked in get_file_size().  */
4568         stat (argv[i], &statbuf);
4569
4570       if (output_file == NULL
4571           || filename_cmp (argv[i], output_file) == 0)
4572         tmpname = make_tempname (argv[i]);
4573       else
4574         tmpname = output_file;
4575
4576       if (tmpname == NULL)
4577         {
4578           bfd_nonfatal_message (argv[i], NULL, NULL,
4579                                 _("could not create temporary file to hold stripped copy"));
4580           status = 1;
4581           continue;
4582         }
4583
4584       status = 0;
4585       copy_file (argv[i], tmpname, input_target, output_target, NULL);
4586       if (status == 0)
4587         {
4588           if (preserve_dates)
4589             set_times (tmpname, &statbuf);
4590           if (output_file != tmpname)
4591             status = (smart_rename (tmpname,
4592                                     output_file ? output_file : argv[i],
4593                                     preserve_dates) != 0);
4594           if (status == 0)
4595             status = hold_status;
4596         }
4597       else
4598         unlink_if_ordinary (tmpname);
4599       if (output_file != tmpname)
4600         free (tmpname);
4601     }
4602
4603   return status;
4604 }
4605
4606 /* Set up PE subsystem.  */
4607
4608 static void
4609 set_pe_subsystem (const char *s)
4610 {
4611   const char *version, *subsystem;
4612   size_t i;
4613   static const struct
4614     {
4615       const char *name;
4616       const char set_def;
4617       const short value;
4618     }
4619   v[] =
4620     {
4621       { "native", 0, IMAGE_SUBSYSTEM_NATIVE },
4622       { "windows", 0, IMAGE_SUBSYSTEM_WINDOWS_GUI },
4623       { "console", 0, IMAGE_SUBSYSTEM_WINDOWS_CUI },
4624       { "posix", 0, IMAGE_SUBSYSTEM_POSIX_CUI },
4625       { "wince", 0, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI },
4626       { "efi-app", 1, IMAGE_SUBSYSTEM_EFI_APPLICATION },
4627       { "efi-bsd", 1, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER },
4628       { "efi-rtd", 1, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER },
4629       { "sal-rtd", 1, IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER },
4630       { "xbox", 0, IMAGE_SUBSYSTEM_XBOX }
4631     };
4632   short value;
4633   char *copy;
4634   int set_def = -1;
4635
4636   /* Check for the presence of a version number.  */
4637   version = strchr (s, ':');
4638   if (version == NULL)
4639     subsystem = s;
4640   else
4641     {
4642       int len = version - s;
4643       copy = xstrdup (s);
4644       subsystem = copy;
4645       copy[len] = '\0';
4646       version = copy + 1 + len;
4647       pe_major_subsystem_version = strtoul (version, &copy, 0);
4648       if (*copy == '.')
4649         pe_minor_subsystem_version = strtoul (copy + 1, &copy, 0);
4650       if (*copy != '\0')
4651         non_fatal (_("%s: bad version in PE subsystem"), s);
4652     }
4653
4654   /* Check for numeric subsystem.  */
4655   value = (short) strtol (subsystem, &copy, 0);
4656   if (*copy == '\0')
4657     {
4658       for (i = 0; i < ARRAY_SIZE (v); i++)
4659         if (v[i].value == value)
4660           {
4661             pe_subsystem = value;
4662             set_def = v[i].set_def;
4663             break;
4664           }
4665     }
4666   else
4667     {
4668       /* Search for subsystem by name.  */
4669       for (i = 0; i < ARRAY_SIZE (v); i++)
4670         if (strcmp (subsystem, v[i].name) == 0)
4671           {
4672             pe_subsystem = v[i].value;
4673             set_def = v[i].set_def;
4674             break;
4675           }
4676     }
4677
4678   switch (set_def)
4679     {
4680     case -1:
4681       fatal (_("unknown PE subsystem: %s"), s);
4682       break;
4683     case 0:
4684       break;
4685     default:
4686       if (pe_file_alignment == (bfd_vma) -1)
4687         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
4688       if (pe_section_alignment == (bfd_vma) -1)
4689         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
4690       break;
4691     }
4692   if (s != subsystem)
4693     free ((char *) subsystem);
4694 }
4695
4696 /* Convert EFI target to PEI target.  */
4697
4698 static void
4699 convert_efi_target (char *efi)
4700 {
4701   efi[0] = 'p';
4702   efi[1] = 'e';
4703   efi[2] = 'i';
4704
4705   if (strcmp (efi + 4, "ia32") == 0)
4706     {
4707       /* Change ia32 to i386.  */
4708       efi[5]= '3';
4709       efi[6]= '8';
4710       efi[7]= '6';
4711     }
4712   else if (strcmp (efi + 4, "x86_64") == 0)
4713     {
4714       /* Change x86_64 to x86-64.  */
4715       efi[7] = '-';
4716     }
4717 }
4718
4719 /* Allocate and return a pointer to a struct section_add, initializing the
4720    structure using ARG, a string in the format "sectionname=filename".
4721    The returned structure will have its next pointer set to NEXT.  The
4722    OPTION field is the name of the command line option currently being
4723    parsed, and is only used if an error needs to be reported.  */
4724
4725 static struct section_add *
4726 init_section_add (const char *arg,
4727                   struct section_add *next,
4728                   const char *option)
4729 {
4730   struct section_add *pa;
4731   const char *s;
4732
4733   s = strchr (arg, '=');
4734   if (s == NULL)
4735     fatal (_("bad format for %s"), option);
4736
4737   pa = (struct section_add *) xmalloc (sizeof (struct section_add));
4738   pa->name = xstrndup (arg, s - arg);
4739   pa->filename = s + 1;
4740   pa->next = next;
4741   pa->contents = NULL;
4742   pa->size = 0;
4743
4744   return pa;
4745 }
4746
4747 /* Load the file specified in PA, allocating memory to hold the file
4748    contents, and store a pointer to the allocated memory in the contents
4749    field of PA.  The size field of PA is also updated.  All errors call
4750    FATAL.  */
4751
4752 static void
4753 section_add_load_file (struct section_add *pa)
4754 {
4755   size_t off, alloc;
4756   FILE *f;
4757
4758   /* We don't use get_file_size so that we can do
4759      --add-section .note.GNU_stack=/dev/null
4760      get_file_size doesn't work on /dev/null.  */
4761
4762   f = fopen (pa->filename, FOPEN_RB);
4763   if (f == NULL)
4764     fatal (_("cannot open: %s: %s"),
4765            pa->filename, strerror (errno));
4766
4767   off = 0;
4768   alloc = 4096;
4769   pa->contents = (bfd_byte *) xmalloc (alloc);
4770   while (!feof (f))
4771     {
4772       off_t got;
4773
4774       if (off == alloc)
4775         {
4776           alloc <<= 1;
4777           pa->contents = (bfd_byte *) xrealloc (pa->contents, alloc);
4778         }
4779
4780       got = fread (pa->contents + off, 1, alloc - off, f);
4781       if (ferror (f))
4782         fatal (_("%s: fread failed"), pa->filename);
4783
4784       off += got;
4785     }
4786
4787   pa->size = off;
4788
4789   fclose (f);
4790 }
4791
4792 static int
4793 copy_main (int argc, char *argv[])
4794 {
4795   char *input_filename = NULL;
4796   char *output_filename = NULL;
4797   char *tmpname;
4798   char *input_target = NULL;
4799   char *output_target = NULL;
4800   bfd_boolean show_version = FALSE;
4801   bfd_boolean change_warn = TRUE;
4802   bfd_boolean formats_info = FALSE;
4803   bfd_boolean use_globalize = FALSE;
4804   bfd_boolean use_keep_global = FALSE;
4805   int c;
4806   struct stat statbuf;
4807   const bfd_arch_info_type *input_arch = NULL;
4808
4809   while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:MN:s:O:d:F:L:G:R:SpgxXHhVvW:wDU",
4810                            copy_options, (int *) 0)) != EOF)
4811     {
4812       switch (c)
4813         {
4814         case 'b':
4815           copy_byte = atoi (optarg);
4816           if (copy_byte < 0)
4817             fatal (_("byte number must be non-negative"));
4818           break;
4819
4820         case 'B':
4821           input_arch = bfd_scan_arch (optarg);
4822           if (input_arch == NULL)
4823             fatal (_("architecture %s unknown"), optarg);
4824           break;
4825
4826         case 'i':
4827           if (optarg)
4828             {
4829               interleave = atoi (optarg);
4830               if (interleave < 1)
4831                 fatal (_("interleave must be positive"));
4832             }
4833           else
4834             interleave = 4;
4835           break;
4836
4837         case OPTION_INTERLEAVE_WIDTH:
4838           copy_width = atoi (optarg);
4839           if (copy_width < 1)
4840             fatal(_("interleave width must be positive"));
4841           break;
4842
4843         case 'I':
4844         case 's':               /* "source" - 'I' is preferred */
4845           input_target = optarg;
4846           break;
4847
4848         case 'O':
4849         case 'd':               /* "destination" - 'O' is preferred */
4850           output_target = optarg;
4851           break;
4852
4853         case 'F':
4854           input_target = output_target = optarg;
4855           break;
4856
4857         case 'j':
4858           find_section_list (optarg, TRUE, SECTION_CONTEXT_COPY);
4859           sections_copied = TRUE;
4860           break;
4861
4862         case 'R':
4863           handle_remove_section_option (optarg);
4864           break;
4865
4866         case OPTION_REMOVE_RELOCS:
4867           handle_remove_relocations_option (optarg);
4868           break;
4869
4870         case 'S':
4871           strip_symbols = STRIP_ALL;
4872           break;
4873
4874         case 'g':
4875           strip_symbols = STRIP_DEBUG;
4876           break;
4877
4878         case OPTION_STRIP_DWO:
4879           strip_symbols = STRIP_DWO;
4880           break;
4881
4882         case OPTION_STRIP_UNNEEDED:
4883           strip_symbols = STRIP_UNNEEDED;
4884           break;
4885
4886         case OPTION_ONLY_KEEP_DEBUG:
4887           strip_symbols = STRIP_NONDEBUG;
4888           break;
4889
4890         case OPTION_KEEP_FILE_SYMBOLS:
4891           keep_file_symbols = 1;
4892           break;
4893
4894         case OPTION_ADD_GNU_DEBUGLINK:
4895           long_section_names = ENABLE ;
4896           gnu_debuglink_filename = optarg;
4897           break;
4898
4899         case 'K':
4900           add_specific_symbol (optarg, keep_specific_htab);
4901           break;
4902
4903         case 'M':
4904           merge_notes = TRUE;
4905           break;
4906         case OPTION_NO_MERGE_NOTES:
4907           merge_notes = FALSE;
4908           break;
4909
4910         case 'N':
4911           add_specific_symbol (optarg, strip_specific_htab);
4912           break;
4913
4914         case OPTION_STRIP_UNNEEDED_SYMBOL:
4915           add_specific_symbol (optarg, strip_unneeded_htab);
4916           break;
4917
4918         case 'L':
4919           add_specific_symbol (optarg, localize_specific_htab);
4920           break;
4921
4922         case OPTION_GLOBALIZE_SYMBOL:
4923           use_globalize = TRUE;
4924           add_specific_symbol (optarg, globalize_specific_htab);
4925           break;
4926
4927         case 'G':
4928           use_keep_global = TRUE;
4929           add_specific_symbol (optarg, keepglobal_specific_htab);
4930           break;
4931
4932         case 'W':
4933           add_specific_symbol (optarg, weaken_specific_htab);
4934           break;
4935
4936         case 'p':
4937           preserve_dates = TRUE;
4938           break;
4939
4940         case 'D':
4941           deterministic = TRUE;
4942           break;
4943
4944         case 'U':
4945           deterministic = FALSE;
4946           break;
4947
4948         case 'w':
4949           wildcard = TRUE;
4950           break;
4951
4952         case 'x':
4953           discard_locals = LOCALS_ALL;
4954           break;
4955
4956         case 'X':
4957           discard_locals = LOCALS_START_L;
4958           break;
4959
4960         case 'v':
4961           verbose = TRUE;
4962           break;
4963
4964         case 'V':
4965           show_version = TRUE;
4966           break;
4967
4968         case OPTION_FORMATS_INFO:
4969           formats_info = TRUE;
4970           break;
4971
4972         case OPTION_WEAKEN:
4973           weaken = TRUE;
4974           break;
4975
4976         case OPTION_ADD_SECTION:
4977           add_sections = init_section_add (optarg, add_sections,
4978                                            "--add-section");
4979           section_add_load_file (add_sections);
4980           break;
4981
4982         case OPTION_UPDATE_SECTION:
4983           update_sections = init_section_add (optarg, update_sections,
4984                                               "--update-section");
4985           section_add_load_file (update_sections);
4986           break;
4987
4988         case OPTION_DUMP_SECTION:
4989           dump_sections = init_section_add (optarg, dump_sections,
4990                                             "--dump-section");
4991           break;
4992
4993         case OPTION_ADD_SYMBOL:
4994           {
4995             char *s, *t;
4996             struct addsym_node *newsym = xmalloc (sizeof *newsym);
4997
4998             newsym->next = NULL;
4999             s = strchr (optarg, '=');
5000             if (s == NULL)
5001               fatal (_("bad format for %s"), "--add-symbol");
5002             t = strchr (s + 1, ':');
5003
5004             newsym->symdef = xstrndup (optarg, s - optarg);
5005             if (t)
5006               {
5007                 newsym->section = xstrndup (s + 1, t - (s + 1));
5008                 newsym->symval = strtol (t + 1, NULL, 0);
5009               }
5010             else
5011               {
5012                 newsym->section = NULL;
5013                 newsym->symval = strtol (s + 1, NULL, 0);
5014                 t = s;
5015               }
5016
5017             t = strchr (t + 1, ',');
5018             newsym->othersym = NULL;
5019             if (t)
5020               newsym->flags = parse_symflags (t+1, &newsym->othersym);
5021             else
5022               newsym->flags = BSF_GLOBAL;
5023
5024             /* Keep 'othersym' symbols at the front of the list.  */
5025             if (newsym->othersym)
5026               {
5027                 newsym->next = add_sym_list;
5028                 if (!add_sym_list)
5029                   add_sym_tail = &newsym->next;
5030                 add_sym_list = newsym;
5031               }
5032             else
5033               {
5034                 *add_sym_tail = newsym;
5035                 add_sym_tail = &newsym->next;
5036               }
5037             add_symbols++;
5038           }
5039           break;
5040
5041         case OPTION_CHANGE_START:
5042           change_start = parse_vma (optarg, "--change-start");
5043           break;
5044
5045         case OPTION_CHANGE_SECTION_ADDRESS:
5046         case OPTION_CHANGE_SECTION_LMA:
5047         case OPTION_CHANGE_SECTION_VMA:
5048           {
5049             struct section_list * p;
5050             unsigned int context = 0;
5051             const char *s;
5052             int len;
5053             char *name;
5054             char *option = NULL;
5055             bfd_vma val;
5056
5057             switch (c)
5058               {
5059               case OPTION_CHANGE_SECTION_ADDRESS:
5060                 option = "--change-section-address";
5061                 context = SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_ALTER_VMA;
5062                 break;
5063               case OPTION_CHANGE_SECTION_LMA:
5064                 option = "--change-section-lma";
5065                 context = SECTION_CONTEXT_ALTER_LMA;
5066                 break;
5067               case OPTION_CHANGE_SECTION_VMA:
5068                 option = "--change-section-vma";
5069                 context = SECTION_CONTEXT_ALTER_VMA;
5070                 break;
5071               }
5072
5073             s = strchr (optarg, '=');
5074             if (s == NULL)
5075               {
5076                 s = strchr (optarg, '+');
5077                 if (s == NULL)
5078                   {
5079                     s = strchr (optarg, '-');
5080                     if (s == NULL)
5081                       fatal (_("bad format for %s"), option);
5082                   }
5083               }
5084             else
5085               {
5086                 /* Correct the context.  */
5087                 switch (c)
5088                   {
5089                   case OPTION_CHANGE_SECTION_ADDRESS:
5090                     context = SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_SET_VMA;
5091                     break;
5092                   case OPTION_CHANGE_SECTION_LMA:
5093                     context = SECTION_CONTEXT_SET_LMA;
5094                     break;
5095                   case OPTION_CHANGE_SECTION_VMA:
5096                     context = SECTION_CONTEXT_SET_VMA;
5097                     break;
5098                   }
5099               }
5100
5101             len = s - optarg;
5102             name = (char *) xmalloc (len + 1);
5103             strncpy (name, optarg, len);
5104             name[len] = '\0';
5105
5106             p = find_section_list (name, TRUE, context);
5107
5108             val = parse_vma (s + 1, option);
5109             if (*s == '-')
5110               val = - val;
5111
5112             switch (c)
5113               {
5114               case OPTION_CHANGE_SECTION_ADDRESS:
5115                 p->vma_val = val;
5116                 /* Fall through.  */
5117
5118               case OPTION_CHANGE_SECTION_LMA:
5119                 p->lma_val = val;
5120                 break;
5121
5122               case OPTION_CHANGE_SECTION_VMA:
5123                 p->vma_val = val;
5124                 break;
5125               }
5126           }
5127           break;
5128
5129         case OPTION_CHANGE_ADDRESSES:
5130           change_section_address = parse_vma (optarg, "--change-addresses");
5131           change_start = change_section_address;
5132           break;
5133
5134         case OPTION_CHANGE_WARNINGS:
5135           change_warn = TRUE;
5136           break;
5137
5138         case OPTION_CHANGE_LEADING_CHAR:
5139           change_leading_char = TRUE;
5140           break;
5141
5142         case OPTION_COMPRESS_DEBUG_SECTIONS:
5143           if (optarg)
5144             {
5145               if (strcasecmp (optarg, "none") == 0)
5146                 do_debug_sections = decompress;
5147               else if (strcasecmp (optarg, "zlib") == 0)
5148                 do_debug_sections = compress_zlib;
5149               else if (strcasecmp (optarg, "zlib-gnu") == 0)
5150                 do_debug_sections = compress_gnu_zlib;
5151               else if (strcasecmp (optarg, "zlib-gabi") == 0)
5152                 do_debug_sections = compress_gabi_zlib;
5153               else
5154                 fatal (_("unrecognized --compress-debug-sections type `%s'"),
5155                        optarg);
5156             }
5157           else
5158             do_debug_sections = compress;
5159           break;
5160
5161         case OPTION_DEBUGGING:
5162           convert_debugging = TRUE;
5163           break;
5164
5165         case OPTION_DECOMPRESS_DEBUG_SECTIONS:
5166           do_debug_sections = decompress;
5167           break;
5168
5169         case OPTION_ELF_STT_COMMON:
5170           if (strcasecmp (optarg, "yes") == 0)
5171             do_elf_stt_common = elf_stt_common;
5172           else if (strcasecmp (optarg, "no") == 0)
5173             do_elf_stt_common = no_elf_stt_common;
5174           else
5175             fatal (_("unrecognized --elf-stt-common= option `%s'"),
5176                    optarg);
5177           break;
5178
5179         case OPTION_GAP_FILL:
5180           {
5181             bfd_vma gap_fill_vma;
5182
5183             gap_fill_vma = parse_vma (optarg, "--gap-fill");
5184             gap_fill = (bfd_byte) gap_fill_vma;
5185             if ((bfd_vma) gap_fill != gap_fill_vma)
5186               {
5187                 char buff[20];
5188
5189                 sprintf_vma (buff, gap_fill_vma);
5190
5191                 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
5192                            buff, gap_fill);
5193               }
5194             gap_fill_set = TRUE;
5195           }
5196           break;
5197
5198         case OPTION_NO_CHANGE_WARNINGS:
5199           change_warn = FALSE;
5200           break;
5201
5202         case OPTION_PAD_TO:
5203           pad_to = parse_vma (optarg, "--pad-to");
5204           pad_to_set = TRUE;
5205           break;
5206
5207         case OPTION_REMOVE_LEADING_CHAR:
5208           remove_leading_char = TRUE;
5209           break;
5210
5211         case OPTION_REDEFINE_SYM:
5212           {
5213             /* Insert this redefinition onto redefine_specific_htab.  */
5214
5215             int len;
5216             const char *s;
5217             const char *nextarg;
5218             char *source, *target;
5219
5220             s = strchr (optarg, '=');
5221             if (s == NULL)
5222               fatal (_("bad format for %s"), "--redefine-sym");
5223
5224             len = s - optarg;
5225             source = (char *) xmalloc (len + 1);
5226             strncpy (source, optarg, len);
5227             source[len] = '\0';
5228
5229             nextarg = s + 1;
5230             len = strlen (nextarg);
5231             target = (char *) xmalloc (len + 1);
5232             strcpy (target, nextarg);
5233
5234             add_redefine_and_check ("--redefine-sym", source, target);
5235
5236             free (source);
5237             free (target);
5238           }
5239           break;
5240
5241         case OPTION_REDEFINE_SYMS:
5242           add_redefine_syms_file (optarg);
5243           break;
5244
5245         case OPTION_SET_SECTION_FLAGS:
5246           {
5247             struct section_list *p;
5248             const char *s;
5249             int len;
5250             char *name;
5251
5252             s = strchr (optarg, '=');
5253             if (s == NULL)
5254               fatal (_("bad format for %s"), "--set-section-flags");
5255
5256             len = s - optarg;
5257             name = (char *) xmalloc (len + 1);
5258             strncpy (name, optarg, len);
5259             name[len] = '\0';
5260
5261             p = find_section_list (name, TRUE, SECTION_CONTEXT_SET_FLAGS);
5262
5263             p->flags = parse_flags (s + 1);
5264           }
5265           break;
5266
5267         case OPTION_RENAME_SECTION:
5268           {
5269             flagword flags;
5270             const char *eq, *fl;
5271             char *old_name;
5272             char *new_name;
5273             unsigned int len;
5274
5275             eq = strchr (optarg, '=');
5276             if (eq == NULL)
5277               fatal (_("bad format for %s"), "--rename-section");
5278
5279             len = eq - optarg;
5280             if (len == 0)
5281               fatal (_("bad format for %s"), "--rename-section");
5282
5283             old_name = (char *) xmalloc (len + 1);
5284             strncpy (old_name, optarg, len);
5285             old_name[len] = 0;
5286
5287             eq++;
5288             fl = strchr (eq, ',');
5289             if (fl)
5290               {
5291                 flags = parse_flags (fl + 1);
5292                 len = fl - eq;
5293               }
5294             else
5295               {
5296                 flags = -1;
5297                 len = strlen (eq);
5298               }
5299
5300             if (len == 0)
5301               fatal (_("bad format for %s"), "--rename-section");
5302
5303             new_name = (char *) xmalloc (len + 1);
5304             strncpy (new_name, eq, len);
5305             new_name[len] = 0;
5306
5307             add_section_rename (old_name, new_name, flags);
5308           }
5309           break;
5310
5311         case OPTION_SET_START:
5312           set_start = parse_vma (optarg, "--set-start");
5313           set_start_set = TRUE;
5314           break;
5315
5316         case OPTION_SREC_LEN:
5317           _bfd_srec_len = parse_vma (optarg, "--srec-len");
5318           break;
5319
5320         case OPTION_SREC_FORCES3:
5321           _bfd_srec_forceS3 = TRUE;
5322           break;
5323
5324         case OPTION_STRIP_SYMBOLS:
5325           add_specific_symbols (optarg, strip_specific_htab,
5326                                 &strip_specific_buffer);
5327           break;
5328
5329         case OPTION_STRIP_UNNEEDED_SYMBOLS:
5330           add_specific_symbols (optarg, strip_unneeded_htab,
5331                                 &strip_unneeded_buffer);
5332           break;
5333
5334         case OPTION_KEEP_SYMBOLS:
5335           add_specific_symbols (optarg, keep_specific_htab,
5336                                 &keep_specific_buffer);
5337           break;
5338
5339         case OPTION_LOCALIZE_HIDDEN:
5340           localize_hidden = TRUE;
5341           break;
5342
5343         case OPTION_LOCALIZE_SYMBOLS:
5344           add_specific_symbols (optarg, localize_specific_htab,
5345                                 &localize_specific_buffer);
5346           break;
5347
5348         case OPTION_LONG_SECTION_NAMES:
5349           if (!strcmp ("enable", optarg))
5350             long_section_names = ENABLE;
5351           else if (!strcmp ("disable", optarg))
5352             long_section_names = DISABLE;
5353           else if (!strcmp ("keep", optarg))
5354             long_section_names = KEEP;
5355           else
5356             fatal (_("unknown long section names option '%s'"), optarg);
5357           break;
5358
5359         case OPTION_GLOBALIZE_SYMBOLS:
5360           use_globalize = TRUE;
5361           add_specific_symbols (optarg, globalize_specific_htab,
5362                                 &globalize_specific_buffer);
5363           break;
5364
5365         case OPTION_KEEPGLOBAL_SYMBOLS:
5366           use_keep_global = TRUE;
5367           add_specific_symbols (optarg, keepglobal_specific_htab,
5368                                 &keepglobal_specific_buffer);
5369           break;
5370
5371         case OPTION_WEAKEN_SYMBOLS:
5372           add_specific_symbols (optarg, weaken_specific_htab,
5373                                 &weaken_specific_buffer);
5374           break;
5375
5376         case OPTION_ALT_MACH_CODE:
5377           use_alt_mach_code = strtoul (optarg, NULL, 0);
5378           if (use_alt_mach_code == 0)
5379             fatal (_("unable to parse alternative machine code"));
5380           break;
5381
5382         case OPTION_PREFIX_SYMBOLS:
5383           prefix_symbols_string = optarg;
5384           break;
5385
5386         case OPTION_PREFIX_SECTIONS:
5387           prefix_sections_string = optarg;
5388           break;
5389
5390         case OPTION_PREFIX_ALLOC_SECTIONS:
5391           prefix_alloc_sections_string = optarg;
5392           break;
5393
5394         case OPTION_READONLY_TEXT:
5395           bfd_flags_to_set |= WP_TEXT;
5396           bfd_flags_to_clear &= ~WP_TEXT;
5397           break;
5398
5399         case OPTION_WRITABLE_TEXT:
5400           bfd_flags_to_clear |= WP_TEXT;
5401           bfd_flags_to_set &= ~WP_TEXT;
5402           break;
5403
5404         case OPTION_PURE:
5405           bfd_flags_to_set |= D_PAGED;
5406           bfd_flags_to_clear &= ~D_PAGED;
5407           break;
5408
5409         case OPTION_IMPURE:
5410           bfd_flags_to_clear |= D_PAGED;
5411           bfd_flags_to_set &= ~D_PAGED;
5412           break;
5413
5414         case OPTION_EXTRACT_DWO:
5415           strip_symbols = STRIP_NONDWO;
5416           break;
5417
5418         case OPTION_EXTRACT_SYMBOL:
5419           extract_symbol = TRUE;
5420           break;
5421
5422         case OPTION_REVERSE_BYTES:
5423           {
5424             int prev = reverse_bytes;
5425
5426             reverse_bytes = atoi (optarg);
5427             if ((reverse_bytes <= 0) || ((reverse_bytes % 2) != 0))
5428               fatal (_("number of bytes to reverse must be positive and even"));
5429
5430             if (prev && prev != reverse_bytes)
5431               non_fatal (_("Warning: ignoring previous --reverse-bytes value of %d"),
5432                          prev);
5433             break;
5434           }
5435
5436         case OPTION_FILE_ALIGNMENT:
5437           pe_file_alignment = parse_vma (optarg, "--file-alignment");
5438           break;
5439
5440         case OPTION_HEAP:
5441           {
5442             char *end;
5443             pe_heap_reserve = strtoul (optarg, &end, 0);
5444             if (end == optarg
5445                 || (*end != '.' && *end != '\0'))
5446               non_fatal (_("%s: invalid reserve value for --heap"),
5447                          optarg);
5448             else if (*end != '\0')
5449               {
5450                 pe_heap_commit = strtoul (end + 1, &end, 0);
5451                 if (*end != '\0')
5452                   non_fatal (_("%s: invalid commit value for --heap"),
5453                              optarg);
5454               }
5455           }
5456           break;
5457
5458         case OPTION_IMAGE_BASE:
5459           pe_image_base = parse_vma (optarg, "--image-base");
5460           break;
5461
5462         case OPTION_SECTION_ALIGNMENT:
5463           pe_section_alignment = parse_vma (optarg,
5464                                             "--section-alignment");
5465           break;
5466
5467         case OPTION_SUBSYSTEM:
5468           set_pe_subsystem (optarg);
5469           break;
5470
5471         case OPTION_STACK:
5472           {
5473             char *end;
5474             pe_stack_reserve = strtoul (optarg, &end, 0);
5475             if (end == optarg
5476                 || (*end != '.' && *end != '\0'))
5477               non_fatal (_("%s: invalid reserve value for --stack"),
5478                          optarg);
5479             else if (*end != '\0')
5480               {
5481                 pe_stack_commit = strtoul (end + 1, &end, 0);
5482                 if (*end != '\0')
5483                   non_fatal (_("%s: invalid commit value for --stack"),
5484                              optarg);
5485               }
5486           }
5487           break;
5488
5489         case OPTION_VERILOG_DATA_WIDTH:
5490           VerilogDataWidth = parse_vma (optarg, "--verilog-data-width");
5491           if (VerilogDataWidth < 1)
5492             fatal (_("verilog data width must be at least 1 byte"));
5493           break;
5494
5495         case 0:
5496           /* We've been given a long option.  */
5497           break;
5498
5499         case 'H':
5500         case 'h':
5501           copy_usage (stdout, 0);
5502
5503         default:
5504           copy_usage (stderr, 1);
5505         }
5506     }
5507
5508   if (use_globalize && use_keep_global)
5509     fatal(_("--globalize-symbol(s) is incompatible with -G/--keep-global-symbol(s)"));
5510
5511   if (formats_info)
5512     {
5513       display_info ();
5514       return 0;
5515     }
5516
5517   if (show_version)
5518     print_version ("objcopy");
5519
5520   if (interleave && copy_byte == -1)
5521     fatal (_("interleave start byte must be set with --byte"));
5522
5523   if (copy_byte >= interleave)
5524     fatal (_("byte number must be less than interleave"));
5525
5526   if (copy_width > interleave - copy_byte)
5527     fatal (_("interleave width must be less than or equal to interleave - byte`"));
5528
5529   if (optind == argc || optind + 2 < argc)
5530     copy_usage (stderr, 1);
5531
5532   input_filename = argv[optind];
5533   if (optind + 1 < argc)
5534     output_filename = argv[optind + 1];
5535
5536   default_deterministic ();
5537
5538   /* Default is to strip no symbols.  */
5539   if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
5540     strip_symbols = STRIP_NONE;
5541
5542   if (output_target == NULL)
5543     output_target = input_target;
5544
5545   /* Convert input EFI target to PEI target.  */
5546   if (input_target != NULL
5547       && strncmp (input_target, "efi-", 4) == 0)
5548     {
5549       char *efi;
5550
5551       efi = xstrdup (output_target + 4);
5552       if (strncmp (efi, "bsdrv-", 6) == 0
5553           || strncmp (efi, "rtdrv-", 6) == 0)
5554         efi += 2;
5555       else if (strncmp (efi, "app-", 4) != 0)
5556         fatal (_("unknown input EFI target: %s"), input_target);
5557
5558       input_target = efi;
5559       convert_efi_target (efi);
5560     }
5561
5562   /* Convert output EFI target to PEI target.  */
5563   if (output_target != NULL
5564       && strncmp (output_target, "efi-", 4) == 0)
5565     {
5566       char *efi;
5567
5568       efi = xstrdup (output_target + 4);
5569       if (strncmp (efi, "app-", 4) == 0)
5570         {
5571           if (pe_subsystem == -1)
5572             pe_subsystem = IMAGE_SUBSYSTEM_EFI_APPLICATION;
5573         }
5574       else if (strncmp (efi, "bsdrv-", 6) == 0)
5575         {
5576           if (pe_subsystem == -1)
5577             pe_subsystem = IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER;
5578           efi += 2;
5579         }
5580       else if (strncmp (efi, "rtdrv-", 6) == 0)
5581         {
5582           if (pe_subsystem == -1)
5583             pe_subsystem = IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER;
5584           efi += 2;
5585         }
5586       else
5587         fatal (_("unknown output EFI target: %s"), output_target);
5588
5589       if (pe_file_alignment == (bfd_vma) -1)
5590         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
5591       if (pe_section_alignment == (bfd_vma) -1)
5592         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
5593
5594       output_target = efi;
5595       convert_efi_target (efi);
5596     }
5597
5598   if (preserve_dates)
5599     if (stat (input_filename, & statbuf) < 0)
5600       fatal (_("warning: could not locate '%s'.  System error message: %s"),
5601              input_filename, strerror (errno));
5602
5603   /* If there is no destination file, or the source and destination files
5604      are the same, then create a temp and rename the result into the input.  */
5605   if (output_filename == NULL
5606       || filename_cmp (input_filename, output_filename) == 0)
5607     tmpname = make_tempname (input_filename);
5608   else
5609     tmpname = output_filename;
5610
5611   if (tmpname == NULL)
5612     fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"),
5613            input_filename, strerror (errno));
5614
5615   copy_file (input_filename, tmpname, input_target, output_target, input_arch);
5616   if (status == 0)
5617     {
5618       if (preserve_dates)
5619         set_times (tmpname, &statbuf);
5620       if (tmpname != output_filename)
5621         status = (smart_rename (tmpname, input_filename,
5622                                 preserve_dates) != 0);
5623     }
5624   else
5625     unlink_if_ordinary (tmpname);
5626
5627   if (tmpname != output_filename)
5628     free (tmpname);
5629
5630   if (change_warn)
5631     {
5632       struct section_list *p;
5633
5634       for (p = change_sections; p != NULL; p = p->next)
5635         {
5636           if (! p->used)
5637             {
5638               if (p->context & (SECTION_CONTEXT_SET_VMA | SECTION_CONTEXT_ALTER_VMA))
5639                 {
5640                   char buff [20];
5641
5642                   sprintf_vma (buff, p->vma_val);
5643
5644                   /* xgettext:c-format */
5645                   non_fatal (_("%s %s%c0x%s never used"),
5646                              "--change-section-vma",
5647                              p->pattern,
5648                              p->context & SECTION_CONTEXT_SET_VMA ? '=' : '+',
5649                              buff);
5650                 }
5651
5652               if (p->context & (SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_ALTER_LMA))
5653                 {
5654                   char buff [20];
5655
5656                   sprintf_vma (buff, p->lma_val);
5657
5658                   /* xgettext:c-format */
5659                   non_fatal (_("%s %s%c0x%s never used"),
5660                              "--change-section-lma",
5661                              p->pattern,
5662                              p->context & SECTION_CONTEXT_SET_LMA ? '=' : '+',
5663                              buff);
5664                 }
5665             }
5666         }
5667     }
5668
5669   if (strip_specific_buffer)
5670     free (strip_specific_buffer);
5671
5672   if (strip_unneeded_buffer)
5673     free (strip_unneeded_buffer);
5674
5675   if (keep_specific_buffer)
5676     free (keep_specific_buffer);
5677
5678   if (localize_specific_buffer)
5679     free (globalize_specific_buffer);
5680
5681   if (globalize_specific_buffer)
5682     free (globalize_specific_buffer);
5683
5684   if (keepglobal_specific_buffer)
5685     free (keepglobal_specific_buffer);
5686
5687   if (weaken_specific_buffer)
5688     free (weaken_specific_buffer);
5689
5690   return 0;
5691 }
5692
5693 int
5694 main (int argc, char *argv[])
5695 {
5696 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
5697   setlocale (LC_MESSAGES, "");
5698 #endif
5699 #if defined (HAVE_SETLOCALE)
5700   setlocale (LC_CTYPE, "");
5701 #endif
5702   bindtextdomain (PACKAGE, LOCALEDIR);
5703   textdomain (PACKAGE);
5704
5705   program_name = argv[0];
5706   xmalloc_set_program_name (program_name);
5707
5708   START_PROGRESS (program_name, 0);
5709
5710   expandargv (&argc, &argv);
5711
5712   strip_symbols = STRIP_UNDEF;
5713   discard_locals = LOCALS_UNDEF;
5714
5715   if (bfd_init () != BFD_INIT_MAGIC)
5716     fatal (_("fatal error: libbfd ABI mismatch"));
5717   set_default_bfd_target ();
5718
5719   if (is_strip < 0)
5720     {
5721       int i = strlen (program_name);
5722 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5723       /* Drop the .exe suffix, if any.  */
5724       if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
5725         {
5726           i -= 4;
5727           program_name[i] = '\0';
5728         }
5729 #endif
5730       is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
5731     }
5732
5733   create_symbol_htabs ();
5734
5735   if (argv != NULL)
5736     bfd_set_error_program_name (argv[0]);
5737
5738   if (is_strip)
5739     strip_main (argc, argv);
5740   else
5741     copy_main (argc, argv);
5742
5743   END_PROGRESS (program_name);
5744
5745   return status;
5746 }