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