binutils/objcopy.c

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