binutils/objcopy.c

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