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