binutils/objcopy.c

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