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