binutils/objcopy.c

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