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               *to++ = from[i];
2827
2828           size = (size + interleave - 1 - copy_byte) / interleave * copy_width;
2829           osection->lma /= interleave;
2830         }
2831
2832       if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2833         {
2834           status = 1;
2835           bfd_nonfatal_message (NULL, obfd, osection, NULL);
2836           return;
2837         }
2838       free (memhunk);
2839     }
2840   else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
2841     {
2842       void *memhunk = xmalloc (size);
2843
2844       /* We don't permit the user to turn off the SEC_HAS_CONTENTS
2845          flag--they can just remove the section entirely and add it
2846          back again.  However, we do permit them to turn on the
2847          SEC_HAS_CONTENTS flag, and take it to mean that the section
2848          contents should be zeroed out.  */
2849
2850       memset (memhunk, 0, size);
2851       if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2852         {
2853           status = 1;
2854           bfd_nonfatal_message (NULL, obfd, osection, NULL);
2855           return;
2856         }
2857       free (memhunk);
2858     }
2859 }
2860
2861 /* Get all the sections.  This is used when --gap-fill or --pad-to is
2862    used.  */
2863
2864 static void
2865 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
2866 {
2867   asection ***secppp = (asection ***) secppparg;
2868
2869   **secppp = osection;
2870   ++(*secppp);
2871 }
2872
2873 /* Sort sections by VMA.  This is called via qsort, and is used when
2874    --gap-fill or --pad-to is used.  We force non loadable or empty
2875    sections to the front, where they are easier to ignore.  */
2876
2877 static int
2878 compare_section_lma (const void *arg1, const void *arg2)
2879 {
2880   const asection *const *sec1 = (const asection * const *) arg1;
2881   const asection *const *sec2 = (const asection * const *) arg2;
2882   flagword flags1, flags2;
2883
2884   /* Sort non loadable sections to the front.  */
2885   flags1 = (*sec1)->flags;
2886   flags2 = (*sec2)->flags;
2887   if ((flags1 & SEC_HAS_CONTENTS) == 0
2888       || (flags1 & SEC_LOAD) == 0)
2889     {
2890       if ((flags2 & SEC_HAS_CONTENTS) != 0
2891           && (flags2 & SEC_LOAD) != 0)
2892         return -1;
2893     }
2894   else
2895     {
2896       if ((flags2 & SEC_HAS_CONTENTS) == 0
2897           || (flags2 & SEC_LOAD) == 0)
2898         return 1;
2899     }
2900
2901   /* Sort sections by LMA.  */
2902   if ((*sec1)->lma > (*sec2)->lma)
2903     return 1;
2904   else if ((*sec1)->lma < (*sec2)->lma)
2905     return -1;
2906
2907   /* Sort sections with the same LMA by size.  */
2908   if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
2909     return 1;
2910   else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
2911     return -1;
2912
2913   return 0;
2914 }
2915
2916 /* Mark all the symbols which will be used in output relocations with
2917    the BSF_KEEP flag so that those symbols will not be stripped.
2918
2919    Ignore relocations which will not appear in the output file.  */
2920
2921 static void
2922 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
2923 {
2924   asymbol **symbols = (asymbol **) symbolsarg;
2925   long relsize;
2926   arelent **relpp;
2927   long relcount, i;
2928
2929   /* Ignore an input section with no corresponding output section.  */
2930   if (isection->output_section == NULL)
2931     return;
2932
2933   relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2934   if (relsize < 0)
2935     {
2936       /* Do not complain if the target does not support relocations.  */
2937       if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2938         return;
2939       bfd_fatal (bfd_get_filename (ibfd));
2940     }
2941
2942   if (relsize == 0)
2943     return;
2944
2945   relpp = (arelent **) xmalloc (relsize);
2946   relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
2947   if (relcount < 0)
2948     bfd_fatal (bfd_get_filename (ibfd));
2949
2950   /* Examine each symbol used in a relocation.  If it's not one of the
2951      special bfd section symbols, then mark it with BSF_KEEP.  */
2952   for (i = 0; i < relcount; i++)
2953     {
2954       if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
2955           && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
2956           && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
2957         (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
2958     }
2959
2960   if (relpp != NULL)
2961     free (relpp);
2962 }
2963
2964 /* Write out debugging information.  */
2965
2966 static bfd_boolean
2967 write_debugging_info (bfd *obfd, void *dhandle,
2968                       long *symcountp ATTRIBUTE_UNUSED,
2969                       asymbol ***symppp ATTRIBUTE_UNUSED)
2970 {
2971   if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
2972     return write_ieee_debugging_info (obfd, dhandle);
2973
2974   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
2975       || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2976     {
2977       bfd_byte *syms, *strings;
2978       bfd_size_type symsize, stringsize;
2979       asection *stabsec, *stabstrsec;
2980       flagword flags;
2981
2982       if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
2983                                                     &symsize, &strings,
2984                                                     &stringsize))
2985         return FALSE;
2986
2987       flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
2988       stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
2989       stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
2990       if (stabsec == NULL
2991           || stabstrsec == NULL
2992           || ! bfd_set_section_size (obfd, stabsec, symsize)
2993           || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
2994           || ! bfd_set_section_alignment (obfd, stabsec, 2)
2995           || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
2996         {
2997           bfd_nonfatal_message (NULL, obfd, NULL,
2998                                 _("can't create debugging section"));
2999           return FALSE;
3000         }
3001
3002       /* We can get away with setting the section contents now because
3003          the next thing the caller is going to do is copy over the
3004          real sections.  We may someday have to split the contents
3005          setting out of this function.  */
3006       if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
3007           || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
3008                                          stringsize))
3009         {
3010           bfd_nonfatal_message (NULL, obfd, NULL,
3011                                 _("can't set debugging section contents"));
3012           return FALSE;
3013         }
3014
3015       return TRUE;
3016     }
3017
3018   bfd_nonfatal_message (NULL, obfd, NULL,
3019                         _("don't know how to write debugging information for %s"),
3020              bfd_get_target (obfd));
3021   return FALSE;
3022 }
3023
3024 static int
3025 strip_main (int argc, char *argv[])
3026 {
3027   char *input_target = NULL;
3028   char *output_target = NULL;
3029   bfd_boolean show_version = FALSE;
3030   bfd_boolean formats_info = FALSE;
3031   int c;
3032   int i;
3033   struct section_list *p;
3034   char *output_file = NULL;
3035
3036   while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
3037                            strip_options, (int *) 0)) != EOF)
3038     {
3039       switch (c)
3040         {
3041         case 'I':
3042           input_target = optarg;
3043           break;
3044         case 'O':
3045           output_target = optarg;
3046           break;
3047         case 'F':
3048           input_target = output_target = optarg;
3049           break;
3050         case 'R':
3051           p = find_section_list (optarg, TRUE);
3052           p->remove = TRUE;
3053           sections_removed = TRUE;
3054           break;
3055         case 's':
3056           strip_symbols = STRIP_ALL;
3057           break;
3058         case 'S':
3059         case 'g':
3060         case 'd':       /* Historic BSD alias for -g.  Used by early NetBSD.  */
3061           strip_symbols = STRIP_DEBUG;
3062           break;
3063         case OPTION_STRIP_DWO:
3064           strip_symbols = STRIP_DWO;
3065           break;
3066         case OPTION_STRIP_UNNEEDED:
3067           strip_symbols = STRIP_UNNEEDED;
3068           break;
3069         case 'K':
3070           add_specific_symbol (optarg, keep_specific_htab);
3071           break;
3072         case 'N':
3073           add_specific_symbol (optarg, strip_specific_htab);
3074           break;
3075         case 'o':
3076           output_file = optarg;
3077           break;
3078         case 'p':
3079           preserve_dates = TRUE;
3080           break;
3081         case 'D':
3082           deterministic = TRUE;
3083           break;
3084         case 'x':
3085           discard_locals = LOCALS_ALL;
3086           break;
3087         case 'X':
3088           discard_locals = LOCALS_START_L;
3089           break;
3090         case 'v':
3091           verbose = TRUE;
3092           break;
3093         case 'V':
3094           show_version = TRUE;
3095           break;
3096         case OPTION_FORMATS_INFO:
3097           formats_info = TRUE;
3098           break;
3099         case OPTION_ONLY_KEEP_DEBUG:
3100           strip_symbols = STRIP_NONDEBUG;
3101           break;
3102         case OPTION_KEEP_FILE_SYMBOLS:
3103           keep_file_symbols = 1;
3104           break;
3105         case 0:
3106           /* We've been given a long option.  */
3107           break;
3108         case 'w':
3109           wildcard = TRUE;
3110           break;
3111         case 'H':
3112         case 'h':
3113           strip_usage (stdout, 0);
3114         default:
3115           strip_usage (stderr, 1);
3116         }
3117     }
3118
3119   if (formats_info)
3120     {
3121       display_info ();
3122       return 0;
3123     }
3124
3125   if (show_version)
3126     print_version ("strip");
3127
3128   /* Default is to strip all symbols.  */
3129   if (strip_symbols == STRIP_UNDEF
3130       && discard_locals == LOCALS_UNDEF
3131       && htab_elements (strip_specific_htab) == 0)
3132     strip_symbols = STRIP_ALL;
3133
3134   if (output_target == NULL)
3135     output_target = input_target;
3136
3137   i = optind;
3138   if (i == argc
3139       || (output_file != NULL && (i + 1) < argc))
3140     strip_usage (stderr, 1);
3141
3142   for (; i < argc; i++)
3143     {
3144       int hold_status = status;
3145       struct stat statbuf;
3146       char *tmpname;
3147
3148       if (get_file_size (argv[i]) < 1)
3149         {
3150           status = 1;
3151           continue;
3152         }
3153
3154       if (preserve_dates)
3155         /* No need to check the return value of stat().
3156            It has already been checked in get_file_size().  */
3157         stat (argv[i], &statbuf);
3158
3159       if (output_file == NULL
3160           || filename_cmp (argv[i], output_file) == 0)
3161         tmpname = make_tempname (argv[i]);
3162       else
3163         tmpname = output_file;
3164
3165       if (tmpname == NULL)
3166         {
3167           bfd_nonfatal_message (argv[i], NULL, NULL,
3168                                 _("could not create temporary file to hold stripped copy"));
3169           status = 1;
3170           continue;
3171         }
3172
3173       status = 0;
3174       copy_file (argv[i], tmpname, input_target, output_target, NULL);
3175       if (status == 0)
3176         {
3177           if (preserve_dates)
3178             set_times (tmpname, &statbuf);
3179           if (output_file != tmpname)
3180             status = (smart_rename (tmpname,
3181                                     output_file ? output_file : argv[i],
3182                                     preserve_dates) != 0);
3183           if (status == 0)
3184             status = hold_status;
3185         }
3186       else
3187         unlink_if_ordinary (tmpname);
3188       if (output_file != tmpname)
3189         free (tmpname);
3190     }
3191
3192   return status;
3193 }
3194
3195 /* Set up PE subsystem.  */
3196
3197 static void
3198 set_pe_subsystem (const char *s)
3199 {
3200   const char *version, *subsystem;
3201   size_t i;
3202   static const struct
3203     {
3204       const char *name;
3205       const char set_def;
3206       const short value;
3207     }
3208   v[] =
3209     {
3210       { "native", 0, IMAGE_SUBSYSTEM_NATIVE },
3211       { "windows", 0, IMAGE_SUBSYSTEM_WINDOWS_GUI },
3212       { "console", 0, IMAGE_SUBSYSTEM_WINDOWS_CUI },
3213       { "posix", 0, IMAGE_SUBSYSTEM_POSIX_CUI },
3214       { "wince", 0, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI },
3215       { "efi-app", 1, IMAGE_SUBSYSTEM_EFI_APPLICATION },
3216       { "efi-bsd", 1, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER },
3217       { "efi-rtd", 1, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER },
3218       { "sal-rtd", 1, IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER },
3219       { "xbox", 0, IMAGE_SUBSYSTEM_XBOX }
3220     };
3221   short value;
3222   char *copy;
3223   int set_def = -1;
3224
3225   /* Check for the presence of a version number.  */
3226   version = strchr (s, ':');
3227   if (version == NULL)
3228     subsystem = s;
3229   else
3230     {
3231       int len = version - s;
3232       copy = xstrdup (s);
3233       subsystem = copy;
3234       copy[len] = '\0';
3235       version = copy + 1 + len;
3236       pe_major_subsystem_version = strtoul (version, &copy, 0);
3237       if (*copy == '.')
3238         pe_minor_subsystem_version = strtoul (copy + 1, &copy, 0);
3239       if (*copy != '\0')
3240         non_fatal (_("%s: bad version in PE subsystem"), s);
3241     }
3242
3243   /* Check for numeric subsystem.  */
3244   value = (short) strtol (subsystem, &copy, 0);
3245   if (*copy == '\0')
3246     {
3247       for (i = 0; i < ARRAY_SIZE (v); i++)
3248         if (v[i].value == value)
3249           {
3250             pe_subsystem = value;
3251             set_def = v[i].set_def;
3252             break;
3253           }
3254     }
3255   else
3256     {
3257       /* Search for subsystem by name.  */
3258       for (i = 0; i < ARRAY_SIZE (v); i++)
3259         if (strcmp (subsystem, v[i].name) == 0)
3260           {
3261             pe_subsystem = v[i].value;
3262             set_def = v[i].set_def;
3263             break;
3264           }
3265     }
3266
3267   switch (set_def)
3268     {
3269     case -1:
3270       fatal (_("unknown PE subsystem: %s"), s);
3271       break;
3272     case 0:
3273       break;
3274     default:
3275       if (pe_file_alignment == (bfd_vma) -1)
3276         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
3277       if (pe_section_alignment == (bfd_vma) -1)
3278         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
3279       break;
3280     }
3281   if (s != subsystem)
3282     free ((char *) subsystem);
3283 }
3284
3285 /* Convert EFI target to PEI target.  */
3286
3287 static void
3288 convert_efi_target (char *efi)
3289 {
3290   efi[0] = 'p';
3291   efi[1] = 'e';
3292   efi[2] = 'i';
3293
3294   if (strcmp (efi + 4, "ia32") == 0)
3295     {
3296       /* Change ia32 to i386.  */
3297       efi[5]= '3';
3298       efi[6]= '8';
3299       efi[7]= '6';
3300     }
3301   else if (strcmp (efi + 4, "x86_64") == 0)
3302     {
3303       /* Change x86_64 to x86-64.  */
3304       efi[7] = '-';
3305     }
3306 }
3307
3308 static int
3309 copy_main (int argc, char *argv[])
3310 {
3311   char *input_filename = NULL;
3312   char *output_filename = NULL;
3313   char *tmpname;
3314   char *input_target = NULL;
3315   char *output_target = NULL;
3316   bfd_boolean show_version = FALSE;
3317   bfd_boolean change_warn = TRUE;
3318   bfd_boolean formats_info = FALSE;
3319   int c;
3320   struct section_list *p;
3321   struct stat statbuf;
3322   const bfd_arch_info_type *input_arch = NULL;
3323
3324   while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
3325                            copy_options, (int *) 0)) != EOF)
3326     {
3327       switch (c)
3328         {
3329         case 'b':
3330           copy_byte = atoi (optarg);
3331           if (copy_byte < 0)
3332             fatal (_("byte number must be non-negative"));
3333           break;
3334
3335         case 'B':
3336           input_arch = bfd_scan_arch (optarg);
3337           if (input_arch == NULL)
3338             fatal (_("architecture %s unknown"), optarg);
3339           break;
3340
3341         case 'i':
3342           if (optarg)
3343             {
3344               interleave = atoi (optarg);
3345               if (interleave < 1)
3346                 fatal (_("interleave must be positive"));
3347             }
3348           else
3349             interleave = 4;
3350           break;
3351
3352         case OPTION_INTERLEAVE_WIDTH:
3353           copy_width = atoi (optarg);
3354           if (copy_width < 1)
3355             fatal(_("interleave width must be positive"));
3356           break;
3357
3358         case 'I':
3359         case 's':               /* "source" - 'I' is preferred */
3360           input_target = optarg;
3361           break;
3362
3363         case 'O':
3364         case 'd':               /* "destination" - 'O' is preferred */
3365           output_target = optarg;
3366           break;
3367
3368         case 'F':
3369           input_target = output_target = optarg;
3370           break;
3371
3372         case 'j':
3373           p = find_section_list (optarg, TRUE);
3374           if (p->remove)
3375             fatal (_("%s both copied and removed"), optarg);
3376           p->copy = TRUE;
3377           sections_copied = TRUE;
3378           break;
3379
3380         case 'R':
3381           p = find_section_list (optarg, TRUE);
3382           if (p->copy)
3383             fatal (_("%s both copied and removed"), optarg);
3384           p->remove = TRUE;
3385           sections_removed = TRUE;
3386           break;
3387
3388         case 'S':
3389           strip_symbols = STRIP_ALL;
3390           break;
3391
3392         case 'g':
3393           strip_symbols = STRIP_DEBUG;
3394           break;
3395
3396         case OPTION_STRIP_DWO:
3397           strip_symbols = STRIP_DWO;
3398           break;
3399
3400         case OPTION_STRIP_UNNEEDED:
3401           strip_symbols = STRIP_UNNEEDED;
3402           break;
3403
3404         case OPTION_ONLY_KEEP_DEBUG:
3405           strip_symbols = STRIP_NONDEBUG;
3406           break;
3407
3408         case OPTION_KEEP_FILE_SYMBOLS:
3409           keep_file_symbols = 1;
3410           break;
3411
3412         case OPTION_ADD_GNU_DEBUGLINK:
3413           gnu_debuglink_filename = optarg;
3414           break;
3415
3416         case 'K':
3417           add_specific_symbol (optarg, keep_specific_htab);
3418           break;
3419
3420         case 'N':
3421           add_specific_symbol (optarg, strip_specific_htab);
3422           break;
3423
3424         case OPTION_STRIP_UNNEEDED_SYMBOL:
3425           add_specific_symbol (optarg, strip_unneeded_htab);
3426           break;
3427
3428         case 'L':
3429           add_specific_symbol (optarg, localize_specific_htab);
3430           break;
3431
3432         case OPTION_GLOBALIZE_SYMBOL:
3433           add_specific_symbol (optarg, globalize_specific_htab);
3434           break;
3435
3436         case 'G':
3437           add_specific_symbol (optarg, keepglobal_specific_htab);
3438           break;
3439
3440         case 'W':
3441           add_specific_symbol (optarg, weaken_specific_htab);
3442           break;
3443
3444         case 'p':
3445           preserve_dates = TRUE;
3446           break;
3447
3448         case 'D':
3449           deterministic = TRUE;
3450           break;
3451
3452         case 'w':
3453           wildcard = TRUE;
3454           break;
3455
3456         case 'x':
3457           discard_locals = LOCALS_ALL;
3458           break;
3459
3460         case 'X':
3461           discard_locals = LOCALS_START_L;
3462           break;
3463
3464         case 'v':
3465           verbose = TRUE;
3466           break;
3467
3468         case 'V':
3469           show_version = TRUE;
3470           break;
3471
3472         case OPTION_FORMATS_INFO:
3473           formats_info = TRUE;
3474           break;
3475
3476         case OPTION_WEAKEN:
3477           weaken = TRUE;
3478           break;
3479
3480         case OPTION_ADD_SECTION:
3481           {
3482             const char *s;
3483             size_t off, alloc;
3484             struct section_add *pa;
3485             FILE *f;
3486
3487             s = strchr (optarg, '=');
3488
3489             if (s == NULL)
3490               fatal (_("bad format for %s"), "--add-section");
3491
3492             pa = (struct section_add *) xmalloc (sizeof (struct section_add));
3493             pa->name = xstrndup (optarg, s - optarg);
3494             pa->filename = s + 1;
3495
3496             /* We don't use get_file_size so that we can do
3497                  --add-section .note.GNU_stack=/dev/null
3498                get_file_size doesn't work on /dev/null.  */
3499
3500             f = fopen (pa->filename, FOPEN_RB);
3501             if (f == NULL)
3502               fatal (_("cannot open: %s: %s"),
3503                      pa->filename, strerror (errno));
3504
3505             off = 0;
3506             alloc = 4096;
3507             pa->contents = (bfd_byte *) xmalloc (alloc);
3508             while (!feof (f))
3509               {
3510                 off_t got;
3511
3512                 if (off == alloc)
3513                   {
3514                     alloc <<= 1;
3515                     pa->contents = (bfd_byte *) xrealloc (pa->contents, alloc);
3516                   }
3517
3518                 got = fread (pa->contents + off, 1, alloc - off, f);
3519                 if (ferror (f))
3520                   fatal (_("%s: fread failed"), pa->filename);
3521
3522                 off += got;
3523               }
3524
3525             pa->size = off;
3526
3527             fclose (f);
3528
3529             pa->next = add_sections;
3530             add_sections = pa;
3531           }
3532           break;
3533
3534         case OPTION_CHANGE_START:
3535           change_start = parse_vma (optarg, "--change-start");
3536           break;
3537
3538         case OPTION_CHANGE_SECTION_ADDRESS:
3539         case OPTION_CHANGE_SECTION_LMA:
3540         case OPTION_CHANGE_SECTION_VMA:
3541           {
3542             const char *s;
3543             int len;
3544             char *name;
3545             char *option = NULL;
3546             bfd_vma val;
3547             enum change_action what = CHANGE_IGNORE;
3548
3549             switch (c)
3550               {
3551               case OPTION_CHANGE_SECTION_ADDRESS:
3552                 option = "--change-section-address";
3553                 break;
3554               case OPTION_CHANGE_SECTION_LMA:
3555                 option = "--change-section-lma";
3556                 break;
3557               case OPTION_CHANGE_SECTION_VMA:
3558                 option = "--change-section-vma";
3559                 break;
3560               }
3561
3562             s = strchr (optarg, '=');
3563             if (s == NULL)
3564               {
3565                 s = strchr (optarg, '+');
3566                 if (s == NULL)
3567                   {
3568                     s = strchr (optarg, '-');
3569                     if (s == NULL)
3570                       fatal (_("bad format for %s"), option);
3571                   }
3572               }
3573
3574             len = s - optarg;
3575             name = (char *) xmalloc (len + 1);
3576             strncpy (name, optarg, len);
3577             name[len] = '\0';
3578
3579             p = find_section_list (name, TRUE);
3580
3581             val = parse_vma (s + 1, option);
3582
3583             switch (*s)
3584               {
3585               case '=': what = CHANGE_SET; break;
3586               case '-': val  = - val; /* Drop through.  */
3587               case '+': what = CHANGE_MODIFY; break;
3588               }
3589
3590             switch (c)
3591               {
3592               case OPTION_CHANGE_SECTION_ADDRESS:
3593                 p->change_vma = what;
3594                 p->vma_val    = val;
3595                 /* Drop through.  */
3596
3597               case OPTION_CHANGE_SECTION_LMA:
3598                 p->change_lma = what;
3599                 p->lma_val    = val;
3600                 break;
3601
3602               case OPTION_CHANGE_SECTION_VMA:
3603                 p->change_vma = what;
3604                 p->vma_val    = val;
3605                 break;
3606               }
3607           }
3608           break;
3609
3610         case OPTION_CHANGE_ADDRESSES:
3611           change_section_address = parse_vma (optarg, "--change-addresses");
3612           change_start = change_section_address;
3613           break;
3614
3615         case OPTION_CHANGE_WARNINGS:
3616           change_warn = TRUE;
3617           break;
3618
3619         case OPTION_CHANGE_LEADING_CHAR:
3620           change_leading_char = TRUE;
3621           break;
3622
3623         case OPTION_COMPRESS_DEBUG_SECTIONS:
3624           do_debug_sections = compress;
3625           break;
3626
3627         case OPTION_DEBUGGING:
3628           convert_debugging = TRUE;
3629           break;
3630
3631         case OPTION_DECOMPRESS_DEBUG_SECTIONS:
3632           do_debug_sections = decompress;
3633           break;
3634
3635         case OPTION_GAP_FILL:
3636           {
3637             bfd_vma gap_fill_vma;
3638
3639             gap_fill_vma = parse_vma (optarg, "--gap-fill");
3640             gap_fill = (bfd_byte) gap_fill_vma;
3641             if ((bfd_vma) gap_fill != gap_fill_vma)
3642               {
3643                 char buff[20];
3644
3645                 sprintf_vma (buff, gap_fill_vma);
3646
3647                 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
3648                            buff, gap_fill);
3649               }
3650             gap_fill_set = TRUE;
3651           }
3652           break;
3653
3654         case OPTION_NO_CHANGE_WARNINGS:
3655           change_warn = FALSE;
3656           break;
3657
3658         case OPTION_PAD_TO:
3659           pad_to = parse_vma (optarg, "--pad-to");
3660           pad_to_set = TRUE;
3661           break;
3662
3663         case OPTION_REMOVE_LEADING_CHAR:
3664           remove_leading_char = TRUE;
3665           break;
3666
3667         case OPTION_REDEFINE_SYM:
3668           {
3669             /* Push this redefinition onto redefine_symbol_list.  */
3670
3671             int len;
3672             const char *s;
3673             const char *nextarg;
3674             char *source, *target;
3675
3676             s = strchr (optarg, '=');
3677             if (s == NULL)
3678               fatal (_("bad format for %s"), "--redefine-sym");
3679
3680             len = s - optarg;
3681             source = (char *) xmalloc (len + 1);
3682             strncpy (source, optarg, len);
3683             source[len] = '\0';
3684
3685             nextarg = s + 1;
3686             len = strlen (nextarg);
3687             target = (char *) xmalloc (len + 1);
3688             strcpy (target, nextarg);
3689
3690             redefine_list_append ("--redefine-sym", source, target);
3691
3692             free (source);
3693             free (target);
3694           }
3695           break;
3696
3697         case OPTION_REDEFINE_SYMS:
3698           add_redefine_syms_file (optarg);
3699           break;
3700
3701         case OPTION_SET_SECTION_FLAGS:
3702           {
3703             const char *s;
3704             int len;
3705             char *name;
3706
3707             s = strchr (optarg, '=');
3708             if (s == NULL)
3709               fatal (_("bad format for %s"), "--set-section-flags");
3710
3711             len = s - optarg;
3712             name = (char *) xmalloc (len + 1);
3713             strncpy (name, optarg, len);
3714             name[len] = '\0';
3715
3716             p = find_section_list (name, TRUE);
3717
3718             p->set_flags = TRUE;
3719             p->flags = parse_flags (s + 1);
3720           }
3721           break;
3722
3723         case OPTION_RENAME_SECTION:
3724           {
3725             flagword flags;
3726             const char *eq, *fl;
3727             char *old_name;
3728             char *new_name;
3729             unsigned int len;
3730
3731             eq = strchr (optarg, '=');
3732             if (eq == NULL)
3733               fatal (_("bad format for %s"), "--rename-section");
3734
3735             len = eq - optarg;
3736             if (len == 0)
3737               fatal (_("bad format for %s"), "--rename-section");
3738
3739             old_name = (char *) xmalloc (len + 1);
3740             strncpy (old_name, optarg, len);
3741             old_name[len] = 0;
3742
3743             eq++;
3744             fl = strchr (eq, ',');
3745             if (fl)
3746               {
3747                 flags = parse_flags (fl + 1);
3748                 len = fl - eq;
3749               }
3750             else
3751               {
3752                 flags = -1;
3753                 len = strlen (eq);
3754               }
3755
3756             if (len == 0)
3757               fatal (_("bad format for %s"), "--rename-section");
3758
3759             new_name = (char *) xmalloc (len + 1);
3760             strncpy (new_name, eq, len);
3761             new_name[len] = 0;
3762
3763             add_section_rename (old_name, new_name, flags);
3764           }
3765           break;
3766
3767         case OPTION_SET_START:
3768           set_start = parse_vma (optarg, "--set-start");
3769           set_start_set = TRUE;
3770           break;
3771
3772         case OPTION_SREC_LEN:
3773           Chunk = parse_vma (optarg, "--srec-len");
3774           break;
3775
3776         case OPTION_SREC_FORCES3:
3777           S3Forced = TRUE;
3778           break;
3779
3780         case OPTION_STRIP_SYMBOLS:
3781           add_specific_symbols (optarg, strip_specific_htab);
3782           break;
3783
3784         case OPTION_STRIP_UNNEEDED_SYMBOLS:
3785           add_specific_symbols (optarg, strip_unneeded_htab);
3786           break;
3787
3788         case OPTION_KEEP_SYMBOLS:
3789           add_specific_symbols (optarg, keep_specific_htab);
3790           break;
3791
3792         case OPTION_LOCALIZE_HIDDEN:
3793           localize_hidden = TRUE;
3794           break;
3795
3796         case OPTION_LOCALIZE_SYMBOLS:
3797           add_specific_symbols (optarg, localize_specific_htab);
3798           break;
3799
3800         case OPTION_LONG_SECTION_NAMES:
3801           if (!strcmp ("enable", optarg))
3802             long_section_names = ENABLE;
3803           else if (!strcmp ("disable", optarg))
3804             long_section_names = DISABLE;
3805           else if (!strcmp ("keep", optarg))
3806             long_section_names = KEEP;
3807           else
3808             fatal (_("unknown long section names option '%s'"), optarg);
3809           break;
3810
3811         case OPTION_GLOBALIZE_SYMBOLS:
3812           add_specific_symbols (optarg, globalize_specific_htab);
3813           break;
3814
3815         case OPTION_KEEPGLOBAL_SYMBOLS:
3816           add_specific_symbols (optarg, keepglobal_specific_htab);
3817           break;
3818
3819         case OPTION_WEAKEN_SYMBOLS:
3820           add_specific_symbols (optarg, weaken_specific_htab);
3821           break;
3822
3823         case OPTION_ALT_MACH_CODE:
3824           use_alt_mach_code = strtoul (optarg, NULL, 0);
3825           if (use_alt_mach_code == 0)
3826             fatal (_("unable to parse alternative machine code"));
3827           break;
3828
3829         case OPTION_PREFIX_SYMBOLS:
3830           prefix_symbols_string = optarg;
3831           break;
3832
3833         case OPTION_PREFIX_SECTIONS:
3834           prefix_sections_string = optarg;
3835           break;
3836
3837         case OPTION_PREFIX_ALLOC_SECTIONS:
3838           prefix_alloc_sections_string = optarg;
3839           break;
3840
3841         case OPTION_READONLY_TEXT:
3842           bfd_flags_to_set |= WP_TEXT;
3843           bfd_flags_to_clear &= ~WP_TEXT;
3844           break;
3845
3846         case OPTION_WRITABLE_TEXT:
3847           bfd_flags_to_clear |= WP_TEXT;
3848           bfd_flags_to_set &= ~WP_TEXT;
3849           break;
3850
3851         case OPTION_PURE:
3852           bfd_flags_to_set |= D_PAGED;
3853           bfd_flags_to_clear &= ~D_PAGED;
3854           break;
3855
3856         case OPTION_IMPURE:
3857           bfd_flags_to_clear |= D_PAGED;
3858           bfd_flags_to_set &= ~D_PAGED;
3859           break;
3860
3861         case OPTION_EXTRACT_DWO:
3862           strip_symbols = STRIP_NONDWO;
3863           break;
3864
3865         case OPTION_EXTRACT_SYMBOL:
3866           extract_symbol = TRUE;
3867           break;
3868
3869         case OPTION_REVERSE_BYTES:
3870           {
3871             int prev = reverse_bytes;
3872
3873             reverse_bytes = atoi (optarg);
3874             if ((reverse_bytes <= 0) || ((reverse_bytes % 2) != 0))
3875               fatal (_("number of bytes to reverse must be positive and even"));
3876
3877             if (prev && prev != reverse_bytes)
3878               non_fatal (_("Warning: ignoring previous --reverse-bytes value of %d"),
3879                          prev);
3880             break;
3881           }
3882
3883         case OPTION_FILE_ALIGNMENT:
3884           pe_file_alignment = parse_vma (optarg, "--file-alignment");
3885           break;
3886
3887         case OPTION_HEAP:
3888             {
3889               char *end;
3890               pe_heap_reserve = strtoul (optarg, &end, 0);
3891               if (end == optarg
3892                   || (*end != '.' && *end != '\0'))
3893                 non_fatal (_("%s: invalid reserve value for --heap"),
3894                            optarg);
3895               else if (*end != '\0')
3896                 {
3897                   pe_heap_commit = strtoul (end + 1, &end, 0);
3898                   if (*end != '\0')
3899                     non_fatal (_("%s: invalid commit value for --heap"),
3900                                optarg);
3901                 }
3902             }
3903           break;
3904
3905         case OPTION_IMAGE_BASE:
3906           pe_image_base = parse_vma (optarg, "--image-base");
3907           break;
3908
3909         case OPTION_SECTION_ALIGNMENT:
3910           pe_section_alignment = parse_vma (optarg,
3911                                             "--section-alignment");
3912           break;
3913
3914         case OPTION_SUBSYSTEM:
3915           set_pe_subsystem (optarg);
3916           break;
3917
3918         case OPTION_STACK:
3919             {
3920               char *end;
3921               pe_stack_reserve = strtoul (optarg, &end, 0);
3922               if (end == optarg
3923                   || (*end != '.' && *end != '\0'))
3924                 non_fatal (_("%s: invalid reserve value for --stack"),
3925                            optarg);
3926               else if (*end != '\0')
3927                 {
3928                   pe_stack_commit = strtoul (end + 1, &end, 0);
3929                   if (*end != '\0')
3930                     non_fatal (_("%s: invalid commit value for --stack"),
3931                                optarg);
3932                 }
3933             }
3934           break;
3935
3936         case 0:
3937           /* We've been given a long option.  */
3938           break;
3939
3940         case 'H':
3941         case 'h':
3942           copy_usage (stdout, 0);
3943
3944         default:
3945           copy_usage (stderr, 1);
3946         }
3947     }
3948
3949   if (formats_info)
3950     {
3951       display_info ();
3952       return 0;
3953     }
3954
3955   if (show_version)
3956     print_version ("objcopy");
3957
3958   if (interleave && copy_byte == -1)
3959     fatal (_("interleave start byte must be set with --byte"));
3960
3961   if (copy_byte >= interleave)
3962     fatal (_("byte number must be less than interleave"));
3963
3964   if (copy_width > interleave - copy_byte)
3965     fatal (_("interleave width must be less than or equal to interleave - byte`"));
3966
3967   if (optind == argc || optind + 2 < argc)
3968     copy_usage (stderr, 1);
3969
3970   input_filename = argv[optind];
3971   if (optind + 1 < argc)
3972     output_filename = argv[optind + 1];
3973
3974   /* Default is to strip no symbols.  */
3975   if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
3976     strip_symbols = STRIP_NONE;
3977
3978   if (output_target == NULL)
3979     output_target = input_target;
3980
3981   /* Convert input EFI target to PEI target.  */
3982   if (input_target != NULL
3983       && strncmp (input_target, "efi-", 4) == 0)
3984     {
3985       char *efi;
3986
3987       efi = xstrdup (output_target + 4);
3988       if (strncmp (efi, "bsdrv-", 6) == 0
3989           || strncmp (efi, "rtdrv-", 6) == 0)
3990         efi += 2;
3991       else if (strncmp (efi, "app-", 4) != 0)
3992         fatal (_("unknown input EFI target: %s"), input_target);
3993
3994       input_target = efi;
3995       convert_efi_target (efi);
3996     }
3997
3998   /* Convert output EFI target to PEI target.  */
3999   if (output_target != NULL
4000       && strncmp (output_target, "efi-", 4) == 0)
4001     {
4002       char *efi;
4003
4004       efi = xstrdup (output_target + 4);
4005       if (strncmp (efi, "app-", 4) == 0)
4006         {
4007           if (pe_subsystem == -1)
4008             pe_subsystem = IMAGE_SUBSYSTEM_EFI_APPLICATION;
4009         }
4010       else if (strncmp (efi, "bsdrv-", 6) == 0)
4011         {
4012           if (pe_subsystem == -1)
4013             pe_subsystem = IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER;
4014           efi += 2;
4015         }
4016       else if (strncmp (efi, "rtdrv-", 6) == 0)
4017         {
4018           if (pe_subsystem == -1)
4019             pe_subsystem = IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER;
4020           efi += 2;
4021         }
4022       else
4023         fatal (_("unknown output EFI target: %s"), output_target);
4024
4025       if (pe_file_alignment == (bfd_vma) -1)
4026         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
4027       if (pe_section_alignment == (bfd_vma) -1)
4028         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
4029
4030       output_target = efi;
4031       convert_efi_target (efi);
4032     }
4033
4034   if (preserve_dates)
4035     if (stat (input_filename, & statbuf) < 0)
4036       fatal (_("warning: could not locate '%s'.  System error message: %s"),
4037              input_filename, strerror (errno));
4038
4039   /* If there is no destination file, or the source and destination files
4040      are the same, then create a temp and rename the result into the input.  */
4041   if (output_filename == NULL
4042       || filename_cmp (input_filename, output_filename) == 0)
4043     tmpname = make_tempname (input_filename);
4044   else
4045     tmpname = output_filename;
4046
4047   if (tmpname == NULL)
4048     fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"),
4049            input_filename, strerror (errno));
4050
4051   copy_file (input_filename, tmpname, input_target, output_target, input_arch);
4052   if (status == 0)
4053     {
4054       if (preserve_dates)
4055         set_times (tmpname, &statbuf);
4056       if (tmpname != output_filename)
4057         status = (smart_rename (tmpname, input_filename,
4058                                 preserve_dates) != 0);
4059     }
4060   else
4061     unlink_if_ordinary (tmpname);
4062
4063   if (change_warn)
4064     {
4065       for (p = change_sections; p != NULL; p = p->next)
4066         {
4067           if (! p->used)
4068             {
4069               if (p->change_vma != CHANGE_IGNORE)
4070                 {
4071                   char buff [20];
4072
4073                   sprintf_vma (buff, p->vma_val);
4074
4075                   /* xgettext:c-format */
4076                   non_fatal (_("%s %s%c0x%s never used"),
4077                              "--change-section-vma",
4078                              p->name,
4079                              p->change_vma == CHANGE_SET ? '=' : '+',
4080                              buff);
4081                 }
4082
4083               if (p->change_lma != CHANGE_IGNORE)
4084                 {
4085                   char buff [20];
4086
4087                   sprintf_vma (buff, p->lma_val);
4088
4089                   /* xgettext:c-format */
4090                   non_fatal (_("%s %s%c0x%s never used"),
4091                              "--change-section-lma",
4092                              p->name,
4093                              p->change_lma == CHANGE_SET ? '=' : '+',
4094                              buff);
4095                 }
4096             }
4097         }
4098     }
4099
4100   return 0;
4101 }
4102
4103 int
4104 main (int argc, char *argv[])
4105 {
4106 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
4107   setlocale (LC_MESSAGES, "");
4108 #endif
4109 #if defined (HAVE_SETLOCALE)
4110   setlocale (LC_CTYPE, "");
4111 #endif
4112   bindtextdomain (PACKAGE, LOCALEDIR);
4113   textdomain (PACKAGE);
4114
4115   program_name = argv[0];
4116   xmalloc_set_program_name (program_name);
4117
4118   START_PROGRESS (program_name, 0);
4119
4120   expandargv (&argc, &argv);
4121
4122   strip_symbols = STRIP_UNDEF;
4123   discard_locals = LOCALS_UNDEF;
4124
4125   bfd_init ();
4126   set_default_bfd_target ();
4127
4128   if (is_strip < 0)
4129     {
4130       int i = strlen (program_name);
4131 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4132       /* Drop the .exe suffix, if any.  */
4133       if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
4134         {
4135           i -= 4;
4136           program_name[i] = '\0';
4137         }
4138 #endif
4139       is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
4140     }
4141
4142   create_symbol_htabs ();
4143
4144   if (is_strip)
4145     strip_main (argc, argv);
4146   else
4147     copy_main (argc, argv);
4148
4149   END_PROGRESS (program_name);
4150
4151   return status;
4152 }