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       gnu_debuglink_section = bfd_create_gnu_debuglink_section
1767         (obfd, gnu_debuglink_filename);
1768
1769       if (gnu_debuglink_section == NULL)
1770         {
1771           bfd_nonfatal_message (NULL, obfd, NULL,
1772                                 _("cannot create debug link section `%s'"),
1773                                 gnu_debuglink_filename);
1774           return FALSE;
1775         }
1776
1777       /* Special processing for PE format files.  We
1778          have no way to distinguish PE from COFF here.  */
1779       if (bfd_get_flavour (obfd) == bfd_target_coff_flavour)
1780         {
1781           bfd_vma debuglink_vma;
1782           asection * highest_section;
1783           asection * sec;
1784
1785           /* The PE spec requires that all sections be adjacent and sorted
1786              in ascending order of VMA.  It also specifies that debug
1787              sections should be last.  This is despite the fact that debug
1788              sections are not loaded into memory and so in theory have no
1789              use for a VMA.
1790
1791              This means that the debuglink section must be given a non-zero
1792              VMA which makes it contiguous with other debug sections.  So
1793              walk the current section list, find the section with the
1794              highest VMA and start the debuglink section after that one.  */
1795           for (sec = obfd->sections, highest_section = NULL;
1796                sec != NULL;
1797                sec = sec->next)
1798             if (sec->vma > 0
1799                 && (highest_section == NULL
1800                     || sec->vma > highest_section->vma))
1801               highest_section = sec;
1802
1803           if (highest_section)
1804             debuglink_vma = BFD_ALIGN (highest_section->vma
1805                                        + highest_section->size,
1806                                        /* FIXME: We ought to be using
1807                                           COFF_PAGE_SIZE here or maybe
1808                                           bfd_get_section_alignment() (if it
1809                                           was set) but since this is for PE
1810                                           and we know the required alignment
1811                                           it is easier just to hard code it.  */
1812                                        0x1000);
1813           else
1814             /* Umm, not sure what to do in this case.  */
1815             debuglink_vma = 0x1000;
1816
1817           bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma);
1818         }
1819     }
1820
1821   if (bfd_count_sections (obfd) != 0
1822       && (gap_fill_set || pad_to_set))
1823     {
1824       asection **set;
1825       unsigned int c, i;
1826
1827       /* We must fill in gaps between the sections and/or we must pad
1828          the last section to a specified address.  We do this by
1829          grabbing a list of the sections, sorting them by VMA, and
1830          increasing the section sizes as required to fill the gaps.
1831          We write out the gap contents below.  */
1832
1833       c = bfd_count_sections (obfd);
1834       osections = (asection **) xmalloc (c * sizeof (asection *));
1835       set = osections;
1836       bfd_map_over_sections (obfd, get_sections, &set);
1837
1838       qsort (osections, c, sizeof (asection *), compare_section_lma);
1839
1840       gaps = (bfd_size_type *) xmalloc (c * sizeof (bfd_size_type));
1841       memset (gaps, 0, c * sizeof (bfd_size_type));
1842
1843       if (gap_fill_set)
1844         {
1845           for (i = 0; i < c - 1; i++)
1846             {
1847               flagword flags;
1848               bfd_size_type size;
1849               bfd_vma gap_start, gap_stop;
1850
1851               flags = bfd_get_section_flags (obfd, osections[i]);
1852               if ((flags & SEC_HAS_CONTENTS) == 0
1853                   || (flags & SEC_LOAD) == 0)
1854                 continue;
1855
1856               size = bfd_section_size (obfd, osections[i]);
1857               gap_start = bfd_section_lma (obfd, osections[i]) + size;
1858               gap_stop = bfd_section_lma (obfd, osections[i + 1]);
1859               if (gap_start < gap_stop)
1860                 {
1861                   if (! bfd_set_section_size (obfd, osections[i],
1862                                               size + (gap_stop - gap_start)))
1863                     {
1864                       bfd_nonfatal_message (NULL, obfd, osections[i],
1865                                             _("Can't fill gap after section"));
1866                       status = 1;
1867                       break;
1868                     }
1869                   gaps[i] = gap_stop - gap_start;
1870                   if (max_gap < gap_stop - gap_start)
1871                     max_gap = gap_stop - gap_start;
1872                 }
1873             }
1874         }
1875
1876       if (pad_to_set)
1877         {
1878           bfd_vma lma;
1879           bfd_size_type size;
1880
1881           lma = bfd_section_lma (obfd, osections[c - 1]);
1882           size = bfd_section_size (obfd, osections[c - 1]);
1883           if (lma + size < pad_to)
1884             {
1885               if (! bfd_set_section_size (obfd, osections[c - 1],
1886                                           pad_to - lma))
1887                 {
1888                   bfd_nonfatal_message (NULL, obfd, osections[c - 1],
1889                                         _("can't add padding"));
1890                   status = 1;
1891                 }
1892               else
1893                 {
1894                   gaps[c - 1] = pad_to - (lma + size);
1895                   if (max_gap < pad_to - (lma + size))
1896                     max_gap = pad_to - (lma + size);
1897                 }
1898             }
1899         }
1900     }
1901
1902   /* Symbol filtering must happen after the output sections
1903      have been created, but before their contents are set.  */
1904   dhandle = NULL;
1905   if (convert_debugging)
1906     dhandle = read_debugging_info (ibfd, isympp, symcount, FALSE);
1907
1908   if (strip_symbols == STRIP_DEBUG
1909       || strip_symbols == STRIP_ALL
1910       || strip_symbols == STRIP_UNNEEDED
1911       || strip_symbols == STRIP_NONDEBUG
1912       || strip_symbols == STRIP_DWO
1913       || strip_symbols == STRIP_NONDWO
1914       || discard_locals != LOCALS_UNDEF
1915       || localize_hidden
1916       || htab_elements (strip_specific_htab) != 0
1917       || htab_elements (keep_specific_htab) != 0
1918       || htab_elements (localize_specific_htab) != 0
1919       || htab_elements (globalize_specific_htab) != 0
1920       || htab_elements (keepglobal_specific_htab) != 0
1921       || htab_elements (weaken_specific_htab) != 0
1922       || prefix_symbols_string
1923       || sections_removed
1924       || sections_copied
1925       || convert_debugging
1926       || change_leading_char
1927       || remove_leading_char
1928       || redefine_sym_list
1929       || weaken)
1930     {
1931       /* Mark symbols used in output relocations so that they
1932          are kept, even if they are local labels or static symbols.
1933
1934          Note we iterate over the input sections examining their
1935          relocations since the relocations for the output sections
1936          haven't been set yet.  mark_symbols_used_in_relocations will
1937          ignore input sections which have no corresponding output
1938          section.  */
1939       if (strip_symbols != STRIP_ALL)
1940         bfd_map_over_sections (ibfd,
1941                                mark_symbols_used_in_relocations,
1942                                isympp);
1943       osympp = (asymbol **) xmalloc ((symcount + 1) * sizeof (asymbol *));
1944       symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
1945     }
1946
1947   if (convert_debugging && dhandle != NULL)
1948     {
1949       if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
1950         {
1951           status = 1;
1952           return FALSE;
1953         }
1954     }
1955
1956   bfd_set_symtab (obfd, osympp, symcount);
1957
1958   /* This has to happen before section positions are set.  */
1959   bfd_map_over_sections (ibfd, copy_relocations_in_section, obfd);
1960
1961   /* This has to happen after the symbol table has been set.  */
1962   bfd_map_over_sections (ibfd, copy_section, obfd);
1963
1964   if (add_sections != NULL)
1965     {
1966       struct section_add *padd;
1967
1968       for (padd = add_sections; padd != NULL; padd = padd->next)
1969         {
1970           if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
1971                                           0, padd->size))
1972             {
1973               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
1974               return FALSE;
1975             }
1976         }
1977     }
1978
1979   if (gnu_debuglink_filename != NULL)
1980     {
1981       if (! bfd_fill_in_gnu_debuglink_section
1982           (obfd, gnu_debuglink_section, gnu_debuglink_filename))
1983         {
1984           bfd_nonfatal_message (NULL, obfd, NULL,
1985                                 _("cannot fill debug link section `%s'"),
1986                                 gnu_debuglink_filename);
1987           return FALSE;
1988         }
1989     }
1990
1991   if (gap_fill_set || pad_to_set)
1992     {
1993       bfd_byte *buf;
1994       int c, i;
1995
1996       /* Fill in the gaps.  */
1997       if (max_gap > 8192)
1998         max_gap = 8192;
1999       buf = (bfd_byte *) xmalloc (max_gap);
2000       memset (buf, gap_fill, max_gap);
2001
2002       c = bfd_count_sections (obfd);
2003       for (i = 0; i < c; i++)
2004         {
2005           if (gaps[i] != 0)
2006             {
2007               bfd_size_type left;
2008               file_ptr off;
2009
2010               left = gaps[i];
2011               off = bfd_section_size (obfd, osections[i]) - left;
2012
2013               while (left > 0)
2014                 {
2015                   bfd_size_type now;
2016
2017                   if (left > 8192)
2018                     now = 8192;
2019                   else
2020                     now = left;
2021
2022                   if (! bfd_set_section_contents (obfd, osections[i], buf,
2023                                                   off, now))
2024                     {
2025                       bfd_nonfatal_message (NULL, obfd, osections[i], NULL);
2026                       return FALSE;
2027                     }
2028
2029                   left -= now;
2030                   off += now;
2031                 }
2032             }
2033         }
2034     }
2035
2036   /* Do not copy backend data if --extract-symbol is passed; anything
2037      that needs to look at the section contents will fail.  */
2038   if (extract_symbol)
2039     return TRUE;
2040
2041   /* Allow the BFD backend to copy any private data it understands
2042      from the input BFD to the output BFD.  This is done last to
2043      permit the routine to look at the filtered symbol table, which is
2044      important for the ECOFF code at least.  */
2045   if (! bfd_copy_private_bfd_data (ibfd, obfd))
2046     {
2047       bfd_nonfatal_message (NULL, obfd, NULL,
2048                             _("error copying private BFD data"));
2049       return FALSE;
2050     }
2051
2052   /* Switch to the alternate machine code.  We have to do this at the
2053      very end, because we only initialize the header when we create
2054      the first section.  */
2055   if (use_alt_mach_code != 0)
2056     {
2057       if (! bfd_alt_mach_code (obfd, use_alt_mach_code))
2058         {
2059           non_fatal (_("this target does not support %lu alternative machine codes"),
2060                      use_alt_mach_code);
2061           if (bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2062             {
2063               non_fatal (_("treating that number as an absolute e_machine value instead"));
2064               elf_elfheader (obfd)->e_machine = use_alt_mach_code;
2065             }
2066           else
2067             non_fatal (_("ignoring the alternative value"));
2068         }
2069     }
2070
2071   return TRUE;
2072 }
2073
2074 /* Read each archive element in turn from IBFD, copy the
2075    contents to temp file, and keep the temp file handle.
2076    If 'force_output_target' is TRUE then make sure that
2077    all elements in the new archive are of the type
2078    'output_target'.  */
2079
2080 static void
2081 copy_archive (bfd *ibfd, bfd *obfd, const char *output_target,
2082               bfd_boolean force_output_target,
2083               const bfd_arch_info_type *input_arch)
2084 {
2085   struct name_list
2086     {
2087       struct name_list *next;
2088       const char *name;
2089       bfd *obfd;
2090     } *list, *l;
2091   bfd **ptr = &obfd->archive_head;
2092   bfd *this_element;
2093   char *dir;
2094   const char *filename;
2095
2096   /* Make a temp directory to hold the contents.  */
2097   dir = make_tempdir (bfd_get_filename (obfd));
2098   if (dir == NULL)
2099       fatal (_("cannot create tempdir for archive copying (error: %s)"),
2100            strerror (errno));
2101
2102   if (strip_symbols == STRIP_ALL)
2103     obfd->has_armap = FALSE;
2104   else
2105     obfd->has_armap = ibfd->has_armap;
2106   obfd->is_thin_archive = ibfd->is_thin_archive;
2107
2108   if (deterministic)
2109     obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
2110
2111   list = NULL;
2112
2113   this_element = bfd_openr_next_archived_file (ibfd, NULL);
2114
2115   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
2116     {
2117       status = 1;
2118       bfd_nonfatal_message (NULL, obfd, NULL, NULL);
2119       return;
2120     }
2121
2122   while (!status && this_element != NULL)
2123     {
2124       char *output_name;
2125       bfd *output_bfd;
2126       bfd *last_element;
2127       struct stat buf;
2128       int stat_status = 0;
2129       bfd_boolean del = TRUE;
2130       bfd_boolean ok_object;
2131
2132       /* Create an output file for this member.  */
2133       output_name = concat (dir, "/",
2134                             bfd_get_filename (this_element), (char *) 0);
2135
2136       /* If the file already exists, make another temp dir.  */
2137       if (stat (output_name, &buf) >= 0)
2138         {
2139           output_name = make_tempdir (output_name);
2140           if (output_name == NULL)
2141             fatal (_("cannot create tempdir for archive copying (error: %s)"),
2142                    strerror (errno));
2143
2144           l = (struct name_list *) xmalloc (sizeof (struct name_list));
2145           l->name = output_name;
2146           l->next = list;
2147           l->obfd = NULL;
2148           list = l;
2149           output_name = concat (output_name, "/",
2150                                 bfd_get_filename (this_element), (char *) 0);
2151         }
2152
2153       if (preserve_dates)
2154         {
2155           stat_status = bfd_stat_arch_elt (this_element, &buf);
2156
2157           if (stat_status != 0)
2158             non_fatal (_("internal stat error on %s"),
2159                        bfd_get_filename (this_element));
2160         }
2161
2162       l = (struct name_list *) xmalloc (sizeof (struct name_list));
2163       l->name = output_name;
2164       l->next = list;
2165       l->obfd = NULL;
2166       list = l;
2167
2168       ok_object = bfd_check_format (this_element, bfd_object);
2169       if (!ok_object)
2170         bfd_nonfatal_message (NULL, this_element, NULL,
2171                               _("Unable to recognise the format of file"));
2172
2173       /* PR binutils/3110: Cope with archives
2174          containing multiple target types.  */
2175       if (force_output_target || !ok_object)
2176         output_bfd = bfd_openw (output_name, output_target);
2177       else
2178         output_bfd = bfd_openw (output_name, bfd_get_target (this_element));
2179
2180       if (output_bfd == NULL)
2181         {
2182           bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2183           status = 1;
2184           return;
2185         }
2186
2187       if (ok_object)
2188         {
2189           del = !copy_object (this_element, output_bfd, input_arch);
2190
2191           if (del && bfd_get_arch (this_element) == bfd_arch_unknown)
2192             /* Try again as an unknown object file.  */
2193             ok_object = FALSE;
2194           else if (!bfd_close (output_bfd))
2195             {
2196               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2197               /* Error in new object file. Don't change archive.  */
2198               status = 1;
2199             }
2200         }
2201
2202       if (!ok_object)
2203         {
2204           del = !copy_unknown_object (this_element, output_bfd);
2205           if (!bfd_close_all_done (output_bfd))
2206             {
2207               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2208               /* Error in new object file. Don't change archive.  */
2209               status = 1;
2210             }
2211         }
2212
2213       if (del)
2214         {
2215           unlink (output_name);
2216           status = 1;
2217         }
2218       else
2219         {
2220           if (preserve_dates && stat_status == 0)
2221             set_times (output_name, &buf);
2222
2223           /* Open the newly output file and attach to our list.  */
2224           output_bfd = bfd_openr (output_name, output_target);
2225
2226           l->obfd = output_bfd;
2227
2228           *ptr = output_bfd;
2229           ptr = &output_bfd->archive_next;
2230
2231           last_element = this_element;
2232
2233           this_element = bfd_openr_next_archived_file (ibfd, last_element);
2234
2235           bfd_close (last_element);
2236         }
2237     }
2238   *ptr = NULL;
2239
2240   filename = bfd_get_filename (obfd);
2241   if (!bfd_close (obfd))
2242     {
2243       status = 1;
2244       bfd_nonfatal_message (filename, NULL, NULL, NULL);
2245       return;
2246     }
2247
2248   filename = bfd_get_filename (ibfd);
2249   if (!bfd_close (ibfd))
2250     {
2251       status = 1;
2252       bfd_nonfatal_message (filename, NULL, NULL, NULL);
2253       return;
2254     }
2255
2256   /* Delete all the files that we opened.  */
2257   for (l = list; l != NULL; l = l->next)
2258     {
2259       if (l->obfd == NULL)
2260         rmdir (l->name);
2261       else
2262         {
2263           bfd_close (l->obfd);
2264           unlink (l->name);
2265         }
2266     }
2267   rmdir (dir);
2268 }
2269
2270 static void
2271 set_long_section_mode (bfd *output_bfd, bfd *input_bfd, enum long_section_name_handling style)
2272 {
2273   /* This is only relevant to Coff targets.  */
2274   if (bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
2275     {
2276       if (style == KEEP
2277           && bfd_get_flavour (input_bfd) == bfd_target_coff_flavour)
2278         style = bfd_coff_long_section_names (input_bfd) ? ENABLE : DISABLE;
2279       bfd_coff_set_long_section_names (output_bfd, style != DISABLE);
2280     }
2281 }
2282
2283 /* The top-level control.  */
2284
2285 static void
2286 copy_file (const char *input_filename, const char *output_filename,
2287            const char *input_target,   const char *output_target,
2288            const bfd_arch_info_type *input_arch)
2289 {
2290   bfd *ibfd;
2291   char **obj_matching;
2292   char **core_matching;
2293   off_t size = get_file_size (input_filename);
2294
2295   if (size < 1)
2296     {
2297       if (size == 0)
2298         non_fatal (_("error: the input file '%s' is empty"),
2299                    input_filename);
2300       status = 1;
2301       return;
2302     }
2303
2304   /* To allow us to do "strip *" without dying on the first
2305      non-object file, failures are nonfatal.  */
2306   ibfd = bfd_openr (input_filename, input_target);
2307   if (ibfd == NULL)
2308     {
2309       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2310       status = 1;
2311       return;
2312     }
2313
2314   switch (do_debug_sections)
2315     {
2316     case compress:
2317       ibfd->flags |= BFD_COMPRESS;
2318       break;
2319     case decompress:
2320       ibfd->flags |= BFD_DECOMPRESS;
2321       break;
2322     default:
2323       break;
2324     }
2325
2326   if (bfd_check_format (ibfd, bfd_archive))
2327     {
2328       bfd_boolean force_output_target;
2329       bfd *obfd;
2330
2331       /* bfd_get_target does not return the correct value until
2332          bfd_check_format succeeds.  */
2333       if (output_target == NULL)
2334         {
2335           output_target = bfd_get_target (ibfd);
2336           force_output_target = FALSE;
2337         }
2338       else
2339         force_output_target = TRUE;
2340
2341       obfd = bfd_openw (output_filename, output_target);
2342       if (obfd == NULL)
2343         {
2344           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2345           status = 1;
2346           return;
2347         }
2348       /* This is a no-op on non-Coff targets.  */
2349       set_long_section_mode (obfd, ibfd, long_section_names);
2350
2351       copy_archive (ibfd, obfd, output_target, force_output_target, input_arch);
2352     }
2353   else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
2354     {
2355       bfd *obfd;
2356     do_copy:
2357
2358       /* bfd_get_target does not return the correct value until
2359          bfd_check_format succeeds.  */
2360       if (output_target == NULL)
2361         output_target = bfd_get_target (ibfd);
2362
2363       obfd = bfd_openw (output_filename, output_target);
2364       if (obfd == NULL)
2365         {
2366           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2367           status = 1;
2368           return;
2369         }
2370       /* This is a no-op on non-Coff targets.  */
2371       set_long_section_mode (obfd, ibfd, long_section_names);
2372
2373       if (! copy_object (ibfd, obfd, input_arch))
2374         status = 1;
2375
2376       if (!bfd_close (obfd))
2377         {
2378           status = 1;
2379           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2380           return;
2381         }
2382
2383       if (!bfd_close (ibfd))
2384         {
2385           status = 1;
2386           bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2387           return;
2388         }
2389     }
2390   else
2391     {
2392       bfd_error_type obj_error = bfd_get_error ();
2393       bfd_error_type core_error;
2394
2395       if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
2396         {
2397           /* This probably can't happen..  */
2398           if (obj_error == bfd_error_file_ambiguously_recognized)
2399             free (obj_matching);
2400           goto do_copy;
2401         }
2402
2403       core_error = bfd_get_error ();
2404       /* Report the object error in preference to the core error.  */
2405       if (obj_error != core_error)
2406         bfd_set_error (obj_error);
2407
2408       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2409
2410       if (obj_error == bfd_error_file_ambiguously_recognized)
2411         {
2412           list_matching_formats (obj_matching);
2413           free (obj_matching);
2414         }
2415       if (core_error == bfd_error_file_ambiguously_recognized)
2416         {
2417           list_matching_formats (core_matching);
2418           free (core_matching);
2419         }
2420
2421       status = 1;
2422     }
2423 }
2424
2425 /* Add a name to the section renaming list.  */
2426
2427 static void
2428 add_section_rename (const char * old_name, const char * new_name,
2429                     flagword flags)
2430 {
2431   section_rename * srename;
2432
2433   /* Check for conflicts first.  */
2434   for (srename = section_rename_list; srename != NULL; srename = srename->next)
2435     if (strcmp (srename->old_name, old_name) == 0)
2436       {
2437         /* Silently ignore duplicate definitions.  */
2438         if (strcmp (srename->new_name, new_name) == 0
2439             && srename->flags == flags)
2440           return;
2441
2442         fatal (_("Multiple renames of section %s"), old_name);
2443       }
2444
2445   srename = (section_rename *) xmalloc (sizeof (* srename));
2446
2447   srename->old_name = old_name;
2448   srename->new_name = new_name;
2449   srename->flags    = flags;
2450   srename->next     = section_rename_list;
2451
2452   section_rename_list = srename;
2453 }
2454
2455 /* Check the section rename list for a new name of the input section
2456    ISECTION.  Return the new name if one is found.
2457    Also set RETURNED_FLAGS to the flags to be used for this section.  */
2458
2459 static const char *
2460 find_section_rename (bfd * ibfd ATTRIBUTE_UNUSED, sec_ptr isection,
2461                      flagword * returned_flags)
2462 {
2463   const char * old_name = bfd_section_name (ibfd, isection);
2464   section_rename * srename;
2465
2466   /* Default to using the flags of the input section.  */
2467   * returned_flags = bfd_get_section_flags (ibfd, isection);
2468
2469   for (srename = section_rename_list; srename != NULL; srename = srename->next)
2470     if (strcmp (srename->old_name, old_name) == 0)
2471       {
2472         if (srename->flags != (flagword) -1)
2473           * returned_flags = srename->flags;
2474
2475         return srename->new_name;
2476       }
2477
2478   return old_name;
2479 }
2480
2481 /* Once each of the sections is copied, we may still need to do some
2482    finalization work for private section headers.  Do that here.  */
2483
2484 static void
2485 setup_bfd_headers (bfd *ibfd, bfd *obfd)
2486 {
2487   /* Allow the BFD backend to copy any private data it understands
2488      from the input section to the output section.  */
2489   if (! bfd_copy_private_header_data (ibfd, obfd))
2490     {
2491       status = 1;
2492       bfd_nonfatal_message (NULL, ibfd, NULL,
2493                             _("error in private header data"));
2494       return;
2495     }
2496
2497   /* All went well.  */
2498   return;
2499 }
2500
2501 /* Create a section in OBFD with the same
2502    name and attributes as ISECTION in IBFD.  */
2503
2504 static void
2505 setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2506 {
2507   bfd *obfd = (bfd *) obfdarg;
2508   struct section_list *p;
2509   sec_ptr osection;
2510   bfd_size_type size;
2511   bfd_vma vma;
2512   bfd_vma lma;
2513   flagword flags;
2514   const char *err;
2515   const char * name;
2516   char *prefix = NULL;
2517   bfd_boolean make_nobits;
2518
2519   if (is_strip_section (ibfd, isection))
2520     return;
2521
2522   p = find_section_list (bfd_section_name (ibfd, isection), FALSE);
2523   if (p != NULL)
2524     p->used = TRUE;
2525
2526   /* Get the, possibly new, name of the output section.  */
2527   name = find_section_rename (ibfd, isection, & flags);
2528
2529   /* Prefix sections.  */
2530   if ((prefix_alloc_sections_string)
2531       && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
2532     prefix = prefix_alloc_sections_string;
2533   else if (prefix_sections_string)
2534     prefix = prefix_sections_string;
2535
2536   if (prefix)
2537     {
2538       char *n;
2539
2540       n = (char *) xmalloc (strlen (prefix) + strlen (name) + 1);
2541       strcpy (n, prefix);
2542       strcat (n, name);
2543       name = n;
2544     }
2545
2546   make_nobits = FALSE;
2547   if (p != NULL && p->set_flags)
2548     flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
2549   else if (strip_symbols == STRIP_NONDEBUG
2550            && (flags & (SEC_ALLOC | SEC_GROUP)) != 0
2551            && !(ibfd->xvec->flavour == bfd_target_elf_flavour
2552                 && elf_section_type (isection) == SHT_NOTE))
2553     {
2554       flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
2555       if (obfd->xvec->flavour == bfd_target_elf_flavour)
2556         {
2557           make_nobits = TRUE;
2558
2559           /* Twiddle the input section flags so that it seems to
2560              elf.c:copy_private_bfd_data that section flags have not
2561              changed between input and output sections.  This hack
2562              prevents wholesale rewriting of the program headers.  */
2563           isection->flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
2564         }
2565     }
2566
2567   osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
2568
2569   if (osection == NULL)
2570     {
2571       err = _("failed to create output section");
2572       goto loser;
2573     }
2574
2575   if (make_nobits)
2576     elf_section_type (osection) = SHT_NOBITS;
2577
2578   size = bfd_section_size (ibfd, isection);
2579   if (copy_byte >= 0)
2580     size = (size + interleave - 1) / interleave * copy_width;
2581   else if (extract_symbol)
2582     size = 0;
2583   if (! bfd_set_section_size (obfd, osection, size))
2584     {
2585       err = _("failed to set size");
2586       goto loser;
2587     }
2588
2589   vma = bfd_section_vma (ibfd, isection);
2590   if (p != NULL && p->change_vma == CHANGE_MODIFY)
2591     vma += p->vma_val;
2592   else if (p != NULL && p->change_vma == CHANGE_SET)
2593     vma = p->vma_val;
2594   else
2595     vma += change_section_address;
2596
2597   if (! bfd_set_section_vma (obfd, osection, vma))
2598     {
2599       err = _("failed to set vma");
2600       goto loser;
2601     }
2602
2603   lma = isection->lma;
2604   if ((p != NULL) && p->change_lma != CHANGE_IGNORE)
2605     {
2606       if (p->change_lma == CHANGE_MODIFY)
2607         lma += p->lma_val;
2608       else if (p->change_lma == CHANGE_SET)
2609         lma = p->lma_val;
2610       else
2611         abort ();
2612     }
2613   else
2614     lma += change_section_address;
2615
2616   osection->lma = lma;
2617
2618   /* FIXME: This is probably not enough.  If we change the LMA we
2619      may have to recompute the header for the file as well.  */
2620   if (!bfd_set_section_alignment (obfd,
2621                                   osection,
2622                                   bfd_section_alignment (ibfd, isection)))
2623     {
2624       err = _("failed to set alignment");
2625       goto loser;
2626     }
2627
2628   /* Copy merge entity size.  */
2629   osection->entsize = isection->entsize;
2630
2631   /* This used to be mangle_section; we do here to avoid using
2632      bfd_get_section_by_name since some formats allow multiple
2633      sections with the same name.  */
2634   isection->output_section = osection;
2635   isection->output_offset = 0;
2636
2637   /* Do not copy backend data if --extract-symbol is passed; anything
2638      that needs to look at the section contents will fail.  */
2639   if (extract_symbol)
2640     return;
2641
2642   if ((isection->flags & SEC_GROUP) != 0)
2643     {
2644       asymbol *gsym = group_signature (isection);
2645
2646       if (gsym != NULL)
2647         {
2648           gsym->flags |= BSF_KEEP;
2649           if (ibfd->xvec->flavour == bfd_target_elf_flavour)
2650             elf_group_id (isection) = gsym;
2651         }
2652     }
2653
2654   /* Allow the BFD backend to copy any private data it understands
2655      from the input section to the output section.  */
2656   if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
2657     {
2658       err = _("failed to copy private data");
2659       goto loser;
2660     }
2661
2662   /* All went well.  */
2663   return;
2664
2665 loser:
2666   status = 1;
2667   bfd_nonfatal_message (NULL, obfd, osection, err);
2668 }
2669
2670 /* Return TRUE if input section ISECTION should be skipped.  */
2671
2672 static bfd_boolean
2673 skip_section (bfd *ibfd, sec_ptr isection)
2674 {
2675   sec_ptr osection;
2676   bfd_size_type size;
2677   flagword flags;
2678
2679   /* If we have already failed earlier on,
2680      do not keep on generating complaints now.  */
2681   if (status != 0)
2682     return TRUE;
2683
2684   if (extract_symbol)
2685     return TRUE;
2686
2687   if (is_strip_section (ibfd, isection))
2688     return TRUE;
2689
2690   flags = bfd_get_section_flags (ibfd, isection);
2691   if ((flags & SEC_GROUP) != 0)
2692     return TRUE;
2693
2694   osection = isection->output_section;
2695   size = bfd_get_section_size (isection);
2696
2697   if (size == 0 || osection == 0)
2698     return TRUE;
2699
2700   return FALSE;
2701 }
2702
2703 /* Copy relocations in input section ISECTION of IBFD to an output
2704    section with the same name in OBFDARG.  If stripping then don't
2705    copy any relocation info.  */
2706
2707 static void
2708 copy_relocations_in_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2709 {
2710   bfd *obfd = (bfd *) obfdarg;
2711   long relsize;
2712   arelent **relpp;
2713   long relcount;
2714   sec_ptr osection;
2715
2716   if (skip_section (ibfd, isection))
2717     return;
2718
2719   osection = isection->output_section;
2720
2721   /* Core files and DWO files do not need to be relocated.  */
2722   if (bfd_get_format (obfd) == bfd_core || strip_symbols == STRIP_NONDWO)
2723     relsize = 0;
2724   else
2725     {
2726       relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2727
2728       if (relsize < 0)
2729         {
2730           /* Do not complain if the target does not support relocations.  */
2731           if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2732             relsize = 0;
2733           else
2734             {
2735               status = 1;
2736               bfd_nonfatal_message (NULL, ibfd, isection, NULL);
2737               return;
2738             }
2739         }
2740     }
2741
2742   if (relsize == 0)
2743     {
2744       bfd_set_reloc (obfd, osection, NULL, 0);
2745       osection->flags &= ~SEC_RELOC;
2746     }
2747   else
2748     {
2749       relpp = (arelent **) xmalloc (relsize);
2750       relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
2751       if (relcount < 0)
2752         {
2753           status = 1;
2754           bfd_nonfatal_message (NULL, ibfd, isection,
2755                                 _("relocation count is negative"));
2756           return;
2757         }
2758
2759       if (strip_symbols == STRIP_ALL)
2760         {
2761           /* Remove relocations which are not in
2762              keep_strip_specific_list.  */
2763           arelent **temp_relpp;
2764           long temp_relcount = 0;
2765           long i;
2766
2767           temp_relpp = (arelent **) xmalloc (relsize);
2768           for (i = 0; i < relcount; i++)
2769             if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
2770                                      keep_specific_htab))
2771               temp_relpp [temp_relcount++] = relpp [i];
2772           relcount = temp_relcount;
2773           free (relpp);
2774           relpp = temp_relpp;
2775         }
2776
2777       bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
2778       if (relcount == 0)
2779         {
2780           osection->flags &= ~SEC_RELOC;
2781           free (relpp);
2782         }
2783     }
2784 }
2785
2786 /* Copy the data of input section ISECTION of IBFD
2787    to an output section with the same name in OBFD.  */
2788
2789 static void
2790 copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2791 {
2792   bfd *obfd = (bfd *) obfdarg;
2793   struct section_list *p;
2794   sec_ptr osection;
2795   bfd_size_type size;
2796
2797   if (skip_section (ibfd, isection))
2798     return;
2799
2800   osection = isection->output_section;
2801   size = bfd_get_section_size (isection);
2802
2803   p = find_section_list (bfd_get_section_name (ibfd, isection), FALSE);
2804
2805   if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
2806       && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
2807     {
2808       bfd_byte *memhunk = NULL;
2809
2810       if (!bfd_get_full_section_contents (ibfd, isection, &memhunk))
2811         {
2812           status = 1;
2813           bfd_nonfatal_message (NULL, ibfd, isection, NULL);
2814           return;
2815         }
2816
2817       if (reverse_bytes)
2818         {
2819           /* We don't handle leftover bytes (too many possible behaviors,
2820              and we don't know what the user wants).  The section length
2821              must be a multiple of the number of bytes to swap.  */
2822           if ((size % reverse_bytes) == 0)
2823             {
2824               unsigned long i, j;
2825               bfd_byte b;
2826
2827               for (i = 0; i < size; i += reverse_bytes)
2828                 for (j = 0; j < (unsigned long)(reverse_bytes / 2); j++)
2829                   {
2830                     bfd_byte *m = (bfd_byte *) memhunk;
2831
2832                     b = m[i + j];
2833                     m[i + j] = m[(i + reverse_bytes) - (j + 1)];
2834                     m[(i + reverse_bytes) - (j + 1)] = b;
2835                   }
2836             }
2837           else
2838             /* User must pad the section up in order to do this.  */
2839             fatal (_("cannot reverse bytes: length of section %s must be evenly divisible by %d"),
2840                    bfd_section_name (ibfd, isection), reverse_bytes);
2841         }
2842
2843       if (copy_byte >= 0)
2844         {
2845           /* Keep only every `copy_byte'th byte in MEMHUNK.  */
2846           char *from = (char *) memhunk + copy_byte;
2847           char *to = (char *) memhunk;
2848           char *end = (char *) memhunk + size;
2849           int i;
2850
2851           for (; from < end; from += interleave)
2852             for (i = 0; i < copy_width; i++)
2853               {
2854                 if (&from[i] >= end)
2855                   break;
2856                 *to++ = from[i];
2857               }
2858
2859           size = (size + interleave - 1 - copy_byte) / interleave * copy_width;
2860           osection->lma /= interleave;
2861         }
2862
2863       if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2864         {
2865           status = 1;
2866           bfd_nonfatal_message (NULL, obfd, osection, NULL);
2867           return;
2868         }
2869       free (memhunk);
2870     }
2871   else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
2872     {
2873       void *memhunk = xmalloc (size);
2874
2875       /* We don't permit the user to turn off the SEC_HAS_CONTENTS
2876          flag--they can just remove the section entirely and add it
2877          back again.  However, we do permit them to turn on the
2878          SEC_HAS_CONTENTS flag, and take it to mean that the section
2879          contents should be zeroed out.  */
2880
2881       memset (memhunk, 0, size);
2882       if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2883         {
2884           status = 1;
2885           bfd_nonfatal_message (NULL, obfd, osection, NULL);
2886           return;
2887         }
2888       free (memhunk);
2889     }
2890 }
2891
2892 /* Get all the sections.  This is used when --gap-fill or --pad-to is
2893    used.  */
2894
2895 static void
2896 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
2897 {
2898   asection ***secppp = (asection ***) secppparg;
2899
2900   **secppp = osection;
2901   ++(*secppp);
2902 }
2903
2904 /* Sort sections by VMA.  This is called via qsort, and is used when
2905    --gap-fill or --pad-to is used.  We force non loadable or empty
2906    sections to the front, where they are easier to ignore.  */
2907
2908 static int
2909 compare_section_lma (const void *arg1, const void *arg2)
2910 {
2911   const asection *const *sec1 = (const asection * const *) arg1;
2912   const asection *const *sec2 = (const asection * const *) arg2;
2913   flagword flags1, flags2;
2914
2915   /* Sort non loadable sections to the front.  */
2916   flags1 = (*sec1)->flags;
2917   flags2 = (*sec2)->flags;
2918   if ((flags1 & SEC_HAS_CONTENTS) == 0
2919       || (flags1 & SEC_LOAD) == 0)
2920     {
2921       if ((flags2 & SEC_HAS_CONTENTS) != 0
2922           && (flags2 & SEC_LOAD) != 0)
2923         return -1;
2924     }
2925   else
2926     {
2927       if ((flags2 & SEC_HAS_CONTENTS) == 0
2928           || (flags2 & SEC_LOAD) == 0)
2929         return 1;
2930     }
2931
2932   /* Sort sections by LMA.  */
2933   if ((*sec1)->lma > (*sec2)->lma)
2934     return 1;
2935   else if ((*sec1)->lma < (*sec2)->lma)
2936     return -1;
2937
2938   /* Sort sections with the same LMA by size.  */
2939   if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
2940     return 1;
2941   else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
2942     return -1;
2943
2944   return 0;
2945 }
2946
2947 /* Mark all the symbols which will be used in output relocations with
2948    the BSF_KEEP flag so that those symbols will not be stripped.
2949
2950    Ignore relocations which will not appear in the output file.  */
2951
2952 static void
2953 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
2954 {
2955   asymbol **symbols = (asymbol **) symbolsarg;
2956   long relsize;
2957   arelent **relpp;
2958   long relcount, i;
2959
2960   /* Ignore an input section with no corresponding output section.  */
2961   if (isection->output_section == NULL)
2962     return;
2963
2964   relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2965   if (relsize < 0)
2966     {
2967       /* Do not complain if the target does not support relocations.  */
2968       if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2969         return;
2970       bfd_fatal (bfd_get_filename (ibfd));
2971     }
2972
2973   if (relsize == 0)
2974     return;
2975
2976   relpp = (arelent **) xmalloc (relsize);
2977   relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
2978   if (relcount < 0)
2979     bfd_fatal (bfd_get_filename (ibfd));
2980
2981   /* Examine each symbol used in a relocation.  If it's not one of the
2982      special bfd section symbols, then mark it with BSF_KEEP.  */
2983   for (i = 0; i < relcount; i++)
2984     {
2985       if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
2986           && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
2987           && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
2988         (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
2989     }
2990
2991   if (relpp != NULL)
2992     free (relpp);
2993 }
2994
2995 /* Write out debugging information.  */
2996
2997 static bfd_boolean
2998 write_debugging_info (bfd *obfd, void *dhandle,
2999                       long *symcountp ATTRIBUTE_UNUSED,
3000                       asymbol ***symppp ATTRIBUTE_UNUSED)
3001 {
3002   if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
3003     return write_ieee_debugging_info (obfd, dhandle);
3004
3005   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
3006       || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
3007     {
3008       bfd_byte *syms, *strings;
3009       bfd_size_type symsize, stringsize;
3010       asection *stabsec, *stabstrsec;
3011       flagword flags;
3012
3013       if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
3014                                                     &symsize, &strings,
3015                                                     &stringsize))
3016         return FALSE;
3017
3018       flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
3019       stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
3020       stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
3021       if (stabsec == NULL
3022           || stabstrsec == NULL
3023           || ! bfd_set_section_size (obfd, stabsec, symsize)
3024           || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
3025           || ! bfd_set_section_alignment (obfd, stabsec, 2)
3026           || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
3027         {
3028           bfd_nonfatal_message (NULL, obfd, NULL,
3029                                 _("can't create debugging section"));
3030           return FALSE;
3031         }
3032
3033       /* We can get away with setting the section contents now because
3034          the next thing the caller is going to do is copy over the
3035          real sections.  We may someday have to split the contents
3036          setting out of this function.  */
3037       if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
3038           || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
3039                                          stringsize))
3040         {
3041           bfd_nonfatal_message (NULL, obfd, NULL,
3042                                 _("can't set debugging section contents"));
3043           return FALSE;
3044         }
3045
3046       return TRUE;
3047     }
3048
3049   bfd_nonfatal_message (NULL, obfd, NULL,
3050                         _("don't know how to write debugging information for %s"),
3051              bfd_get_target (obfd));
3052   return FALSE;
3053 }
3054
3055 /* If neither -D nor -U was specified explicitly,
3056    then use the configured default.  */
3057 static void
3058 default_deterministic (void)
3059 {
3060   if (deterministic < 0)
3061     deterministic = DEFAULT_AR_DETERMINISTIC;
3062 }
3063
3064 static int
3065 strip_main (int argc, char *argv[])
3066 {
3067   char *input_target = NULL;
3068   char *output_target = NULL;
3069   bfd_boolean show_version = FALSE;
3070   bfd_boolean formats_info = FALSE;
3071   int c;
3072   int i;
3073   struct section_list *p;
3074   char *output_file = NULL;
3075
3076   while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
3077                            strip_options, (int *) 0)) != EOF)
3078     {
3079       switch (c)
3080         {
3081         case 'I':
3082           input_target = optarg;
3083           break;
3084         case 'O':
3085           output_target = optarg;
3086           break;
3087         case 'F':
3088           input_target = output_target = optarg;
3089           break;
3090         case 'R':
3091           p = find_section_list (optarg, TRUE);
3092           p->remove = TRUE;
3093           sections_removed = TRUE;
3094           break;
3095         case 's':
3096           strip_symbols = STRIP_ALL;
3097           break;
3098         case 'S':
3099         case 'g':
3100         case 'd':       /* Historic BSD alias for -g.  Used by early NetBSD.  */
3101           strip_symbols = STRIP_DEBUG;
3102           break;
3103         case OPTION_STRIP_DWO:
3104           strip_symbols = STRIP_DWO;
3105           break;
3106         case OPTION_STRIP_UNNEEDED:
3107           strip_symbols = STRIP_UNNEEDED;
3108           break;
3109         case 'K':
3110           add_specific_symbol (optarg, keep_specific_htab);
3111           break;
3112         case 'N':
3113           add_specific_symbol (optarg, strip_specific_htab);
3114           break;
3115         case 'o':
3116           output_file = optarg;
3117           break;
3118         case 'p':
3119           preserve_dates = TRUE;
3120           break;
3121         case 'D':
3122           deterministic = TRUE;
3123           break;
3124         case 'U':
3125           deterministic = FALSE;
3126           break;
3127         case 'x':
3128           discard_locals = LOCALS_ALL;
3129           break;
3130         case 'X':
3131           discard_locals = LOCALS_START_L;
3132           break;
3133         case 'v':
3134           verbose = TRUE;
3135           break;
3136         case 'V':
3137           show_version = TRUE;
3138           break;
3139         case OPTION_FORMATS_INFO:
3140           formats_info = TRUE;
3141           break;
3142         case OPTION_ONLY_KEEP_DEBUG:
3143           strip_symbols = STRIP_NONDEBUG;
3144           break;
3145         case OPTION_KEEP_FILE_SYMBOLS:
3146           keep_file_symbols = 1;
3147           break;
3148         case 0:
3149           /* We've been given a long option.  */
3150           break;
3151         case 'w':
3152           wildcard = TRUE;
3153           break;
3154         case 'H':
3155         case 'h':
3156           strip_usage (stdout, 0);
3157         default:
3158           strip_usage (stderr, 1);
3159         }
3160     }
3161
3162   if (formats_info)
3163     {
3164       display_info ();
3165       return 0;
3166     }
3167
3168   if (show_version)
3169     print_version ("strip");
3170
3171   default_deterministic ();
3172
3173   /* Default is to strip all symbols.  */
3174   if (strip_symbols == STRIP_UNDEF
3175       && discard_locals == LOCALS_UNDEF
3176       && htab_elements (strip_specific_htab) == 0)
3177     strip_symbols = STRIP_ALL;
3178
3179   if (output_target == NULL)
3180     output_target = input_target;
3181
3182   i = optind;
3183   if (i == argc
3184       || (output_file != NULL && (i + 1) < argc))
3185     strip_usage (stderr, 1);
3186
3187   for (; i < argc; i++)
3188     {
3189       int hold_status = status;
3190       struct stat statbuf;
3191       char *tmpname;
3192
3193       if (get_file_size (argv[i]) < 1)
3194         {
3195           status = 1;
3196           continue;
3197         }
3198
3199       if (preserve_dates)
3200         /* No need to check the return value of stat().
3201            It has already been checked in get_file_size().  */
3202         stat (argv[i], &statbuf);
3203
3204       if (output_file == NULL
3205           || filename_cmp (argv[i], output_file) == 0)
3206         tmpname = make_tempname (argv[i]);
3207       else
3208         tmpname = output_file;
3209
3210       if (tmpname == NULL)
3211         {
3212           bfd_nonfatal_message (argv[i], NULL, NULL,
3213                                 _("could not create temporary file to hold stripped copy"));
3214           status = 1;
3215           continue;
3216         }
3217
3218       status = 0;
3219       copy_file (argv[i], tmpname, input_target, output_target, NULL);
3220       if (status == 0)
3221         {
3222           if (preserve_dates)
3223             set_times (tmpname, &statbuf);
3224           if (output_file != tmpname)
3225             status = (smart_rename (tmpname,
3226                                     output_file ? output_file : argv[i],
3227                                     preserve_dates) != 0);
3228           if (status == 0)
3229             status = hold_status;
3230         }
3231       else
3232         unlink_if_ordinary (tmpname);
3233       if (output_file != tmpname)
3234         free (tmpname);
3235     }
3236
3237   return status;
3238 }
3239
3240 /* Set up PE subsystem.  */
3241
3242 static void
3243 set_pe_subsystem (const char *s)
3244 {
3245   const char *version, *subsystem;
3246   size_t i;
3247   static const struct
3248     {
3249       const char *name;
3250       const char set_def;
3251       const short value;
3252     }
3253   v[] =
3254     {
3255       { "native", 0, IMAGE_SUBSYSTEM_NATIVE },
3256       { "windows", 0, IMAGE_SUBSYSTEM_WINDOWS_GUI },
3257       { "console", 0, IMAGE_SUBSYSTEM_WINDOWS_CUI },
3258       { "posix", 0, IMAGE_SUBSYSTEM_POSIX_CUI },
3259       { "wince", 0, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI },
3260       { "efi-app", 1, IMAGE_SUBSYSTEM_EFI_APPLICATION },
3261       { "efi-bsd", 1, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER },
3262       { "efi-rtd", 1, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER },
3263       { "sal-rtd", 1, IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER },
3264       { "xbox", 0, IMAGE_SUBSYSTEM_XBOX }
3265     };
3266   short value;
3267   char *copy;
3268   int set_def = -1;
3269
3270   /* Check for the presence of a version number.  */
3271   version = strchr (s, ':');
3272   if (version == NULL)
3273     subsystem = s;
3274   else
3275     {
3276       int len = version - s;
3277       copy = xstrdup (s);
3278       subsystem = copy;
3279       copy[len] = '\0';
3280       version = copy + 1 + len;
3281       pe_major_subsystem_version = strtoul (version, &copy, 0);
3282       if (*copy == '.')
3283         pe_minor_subsystem_version = strtoul (copy + 1, &copy, 0);
3284       if (*copy != '\0')
3285         non_fatal (_("%s: bad version in PE subsystem"), s);
3286     }
3287
3288   /* Check for numeric subsystem.  */
3289   value = (short) strtol (subsystem, &copy, 0);
3290   if (*copy == '\0')
3291     {
3292       for (i = 0; i < ARRAY_SIZE (v); i++)
3293         if (v[i].value == value)
3294           {
3295             pe_subsystem = value;
3296             set_def = v[i].set_def;
3297             break;
3298           }
3299     }
3300   else
3301     {
3302       /* Search for subsystem by name.  */
3303       for (i = 0; i < ARRAY_SIZE (v); i++)
3304         if (strcmp (subsystem, v[i].name) == 0)
3305           {
3306             pe_subsystem = v[i].value;
3307             set_def = v[i].set_def;
3308             break;
3309           }
3310     }
3311
3312   switch (set_def)
3313     {
3314     case -1:
3315       fatal (_("unknown PE subsystem: %s"), s);
3316       break;
3317     case 0:
3318       break;
3319     default:
3320       if (pe_file_alignment == (bfd_vma) -1)
3321         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
3322       if (pe_section_alignment == (bfd_vma) -1)
3323         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
3324       break;
3325     }
3326   if (s != subsystem)
3327     free ((char *) subsystem);
3328 }
3329
3330 /* Convert EFI target to PEI target.  */
3331
3332 static void
3333 convert_efi_target (char *efi)
3334 {
3335   efi[0] = 'p';
3336   efi[1] = 'e';
3337   efi[2] = 'i';
3338
3339   if (strcmp (efi + 4, "ia32") == 0)
3340     {
3341       /* Change ia32 to i386.  */
3342       efi[5]= '3';
3343       efi[6]= '8';
3344       efi[7]= '6';
3345     }
3346   else if (strcmp (efi + 4, "x86_64") == 0)
3347     {
3348       /* Change x86_64 to x86-64.  */
3349       efi[7] = '-';
3350     }
3351 }
3352
3353 static int
3354 copy_main (int argc, char *argv[])
3355 {
3356   char *input_filename = NULL;
3357   char *output_filename = NULL;
3358   char *tmpname;
3359   char *input_target = NULL;
3360   char *output_target = NULL;
3361   bfd_boolean show_version = FALSE;
3362   bfd_boolean change_warn = TRUE;
3363   bfd_boolean formats_info = FALSE;
3364   int c;
3365   struct section_list *p;
3366   struct stat statbuf;
3367   const bfd_arch_info_type *input_arch = NULL;
3368
3369   while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
3370                            copy_options, (int *) 0)) != EOF)
3371     {
3372       switch (c)
3373         {
3374         case 'b':
3375           copy_byte = atoi (optarg);
3376           if (copy_byte < 0)
3377             fatal (_("byte number must be non-negative"));
3378           break;
3379
3380         case 'B':
3381           input_arch = bfd_scan_arch (optarg);
3382           if (input_arch == NULL)
3383             fatal (_("architecture %s unknown"), optarg);
3384           break;
3385
3386         case 'i':
3387           if (optarg)
3388             {
3389               interleave = atoi (optarg);
3390               if (interleave < 1)
3391                 fatal (_("interleave must be positive"));
3392             }
3393           else
3394             interleave = 4;
3395           break;
3396
3397         case OPTION_INTERLEAVE_WIDTH:
3398           copy_width = atoi (optarg);
3399           if (copy_width < 1)
3400             fatal(_("interleave width must be positive"));
3401           break;
3402
3403         case 'I':
3404         case 's':               /* "source" - 'I' is preferred */
3405           input_target = optarg;
3406           break;
3407
3408         case 'O':
3409         case 'd':               /* "destination" - 'O' is preferred */
3410           output_target = optarg;
3411           break;
3412
3413         case 'F':
3414           input_target = output_target = optarg;
3415           break;
3416
3417         case 'j':
3418           p = find_section_list (optarg, TRUE);
3419           if (p->remove)
3420             fatal (_("%s both copied and removed"), optarg);
3421           p->copy = TRUE;
3422           sections_copied = TRUE;
3423           break;
3424
3425         case 'R':
3426           p = find_section_list (optarg, TRUE);
3427           if (p->copy)
3428             fatal (_("%s both copied and removed"), optarg);
3429           p->remove = TRUE;
3430           sections_removed = TRUE;
3431           break;
3432
3433         case 'S':
3434           strip_symbols = STRIP_ALL;
3435           break;
3436
3437         case 'g':
3438           strip_symbols = STRIP_DEBUG;
3439           break;
3440
3441         case OPTION_STRIP_DWO:
3442           strip_symbols = STRIP_DWO;
3443           break;
3444
3445         case OPTION_STRIP_UNNEEDED:
3446           strip_symbols = STRIP_UNNEEDED;
3447           break;
3448
3449         case OPTION_ONLY_KEEP_DEBUG:
3450           strip_symbols = STRIP_NONDEBUG;
3451           break;
3452
3453         case OPTION_KEEP_FILE_SYMBOLS:
3454           keep_file_symbols = 1;
3455           break;
3456
3457         case OPTION_ADD_GNU_DEBUGLINK:
3458           long_section_names = ENABLE ;
3459           gnu_debuglink_filename = optarg;
3460           break;
3461
3462         case 'K':
3463           add_specific_symbol (optarg, keep_specific_htab);
3464           break;
3465
3466         case 'N':
3467           add_specific_symbol (optarg, strip_specific_htab);
3468           break;
3469
3470         case OPTION_STRIP_UNNEEDED_SYMBOL:
3471           add_specific_symbol (optarg, strip_unneeded_htab);
3472           break;
3473
3474         case 'L':
3475           add_specific_symbol (optarg, localize_specific_htab);
3476           break;
3477
3478         case OPTION_GLOBALIZE_SYMBOL:
3479           add_specific_symbol (optarg, globalize_specific_htab);
3480           break;
3481
3482         case 'G':
3483           add_specific_symbol (optarg, keepglobal_specific_htab);
3484           break;
3485
3486         case 'W':
3487           add_specific_symbol (optarg, weaken_specific_htab);
3488           break;
3489
3490         case 'p':
3491           preserve_dates = TRUE;
3492           break;
3493
3494         case 'D':
3495           deterministic = TRUE;
3496           break;
3497
3498         case 'U':
3499           deterministic = FALSE;
3500           break;
3501
3502         case 'w':
3503           wildcard = TRUE;
3504           break;
3505
3506         case 'x':
3507           discard_locals = LOCALS_ALL;
3508           break;
3509
3510         case 'X':
3511           discard_locals = LOCALS_START_L;
3512           break;
3513
3514         case 'v':
3515           verbose = TRUE;
3516           break;
3517
3518         case 'V':
3519           show_version = TRUE;
3520           break;
3521
3522         case OPTION_FORMATS_INFO:
3523           formats_info = TRUE;
3524           break;
3525
3526         case OPTION_WEAKEN:
3527           weaken = TRUE;
3528           break;
3529
3530         case OPTION_ADD_SECTION:
3531           {
3532             const char *s;
3533             size_t off, alloc;
3534             struct section_add *pa;
3535             FILE *f;
3536
3537             s = strchr (optarg, '=');
3538
3539             if (s == NULL)
3540               fatal (_("bad format for %s"), "--add-section");
3541
3542             pa = (struct section_add *) xmalloc (sizeof (struct section_add));
3543             pa->name = xstrndup (optarg, s - optarg);
3544             pa->filename = s + 1;
3545
3546             /* We don't use get_file_size so that we can do
3547                  --add-section .note.GNU_stack=/dev/null
3548                get_file_size doesn't work on /dev/null.  */
3549
3550             f = fopen (pa->filename, FOPEN_RB);
3551             if (f == NULL)
3552               fatal (_("cannot open: %s: %s"),
3553                      pa->filename, strerror (errno));
3554
3555             off = 0;
3556             alloc = 4096;
3557             pa->contents = (bfd_byte *) xmalloc (alloc);
3558             while (!feof (f))
3559               {
3560                 off_t got;
3561
3562                 if (off == alloc)
3563                   {
3564                     alloc <<= 1;
3565                     pa->contents = (bfd_byte *) xrealloc (pa->contents, alloc);
3566                   }
3567
3568                 got = fread (pa->contents + off, 1, alloc - off, f);
3569                 if (ferror (f))
3570                   fatal (_("%s: fread failed"), pa->filename);
3571
3572                 off += got;
3573               }
3574
3575             pa->size = off;
3576
3577             fclose (f);
3578
3579             pa->next = add_sections;
3580             add_sections = pa;
3581           }
3582           break;
3583
3584         case OPTION_CHANGE_START:
3585           change_start = parse_vma (optarg, "--change-start");
3586           break;
3587
3588         case OPTION_CHANGE_SECTION_ADDRESS:
3589         case OPTION_CHANGE_SECTION_LMA:
3590         case OPTION_CHANGE_SECTION_VMA:
3591           {
3592             const char *s;
3593             int len;
3594             char *name;
3595             char *option = NULL;
3596             bfd_vma val;
3597             enum change_action what = CHANGE_IGNORE;
3598
3599             switch (c)
3600               {
3601               case OPTION_CHANGE_SECTION_ADDRESS:
3602                 option = "--change-section-address";
3603                 break;
3604               case OPTION_CHANGE_SECTION_LMA:
3605                 option = "--change-section-lma";
3606                 break;
3607               case OPTION_CHANGE_SECTION_VMA:
3608                 option = "--change-section-vma";
3609                 break;
3610               }
3611
3612             s = strchr (optarg, '=');
3613             if (s == NULL)
3614               {
3615                 s = strchr (optarg, '+');
3616                 if (s == NULL)
3617                   {
3618                     s = strchr (optarg, '-');
3619                     if (s == NULL)
3620                       fatal (_("bad format for %s"), option);
3621                   }
3622               }
3623
3624             len = s - optarg;
3625             name = (char *) xmalloc (len + 1);
3626             strncpy (name, optarg, len);
3627             name[len] = '\0';
3628
3629             p = find_section_list (name, TRUE);
3630
3631             val = parse_vma (s + 1, option);
3632
3633             switch (*s)
3634               {
3635               case '=': what = CHANGE_SET; break;
3636               case '-': val  = - val; /* Drop through.  */
3637               case '+': what = CHANGE_MODIFY; break;
3638               }
3639
3640             switch (c)
3641               {
3642               case OPTION_CHANGE_SECTION_ADDRESS:
3643                 p->change_vma = what;
3644                 p->vma_val    = val;
3645                 /* Drop through.  */
3646
3647               case OPTION_CHANGE_SECTION_LMA:
3648                 p->change_lma = what;
3649                 p->lma_val    = val;
3650                 break;
3651
3652               case OPTION_CHANGE_SECTION_VMA:
3653                 p->change_vma = what;
3654                 p->vma_val    = val;
3655                 break;
3656               }
3657           }
3658           break;
3659
3660         case OPTION_CHANGE_ADDRESSES:
3661           change_section_address = parse_vma (optarg, "--change-addresses");
3662           change_start = change_section_address;
3663           break;
3664
3665         case OPTION_CHANGE_WARNINGS:
3666           change_warn = TRUE;
3667           break;
3668
3669         case OPTION_CHANGE_LEADING_CHAR:
3670           change_leading_char = TRUE;
3671           break;
3672
3673         case OPTION_COMPRESS_DEBUG_SECTIONS:
3674           do_debug_sections = compress;
3675           break;
3676
3677         case OPTION_DEBUGGING:
3678           convert_debugging = TRUE;
3679           break;
3680
3681         case OPTION_DECOMPRESS_DEBUG_SECTIONS:
3682           do_debug_sections = decompress;
3683           break;
3684
3685         case OPTION_GAP_FILL:
3686           {
3687             bfd_vma gap_fill_vma;
3688
3689             gap_fill_vma = parse_vma (optarg, "--gap-fill");
3690             gap_fill = (bfd_byte) gap_fill_vma;
3691             if ((bfd_vma) gap_fill != gap_fill_vma)
3692               {
3693                 char buff[20];
3694
3695                 sprintf_vma (buff, gap_fill_vma);
3696
3697                 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
3698                            buff, gap_fill);
3699               }
3700             gap_fill_set = TRUE;
3701           }
3702           break;
3703
3704         case OPTION_NO_CHANGE_WARNINGS:
3705           change_warn = FALSE;
3706           break;
3707
3708         case OPTION_PAD_TO:
3709           pad_to = parse_vma (optarg, "--pad-to");
3710           pad_to_set = TRUE;
3711           break;
3712
3713         case OPTION_REMOVE_LEADING_CHAR:
3714           remove_leading_char = TRUE;
3715           break;
3716
3717         case OPTION_REDEFINE_SYM:
3718           {
3719             /* Push this redefinition onto redefine_symbol_list.  */
3720
3721             int len;
3722             const char *s;
3723             const char *nextarg;
3724             char *source, *target;
3725
3726             s = strchr (optarg, '=');
3727             if (s == NULL)
3728               fatal (_("bad format for %s"), "--redefine-sym");
3729
3730             len = s - optarg;
3731             source = (char *) xmalloc (len + 1);
3732             strncpy (source, optarg, len);
3733             source[len] = '\0';
3734
3735             nextarg = s + 1;
3736             len = strlen (nextarg);
3737             target = (char *) xmalloc (len + 1);
3738             strcpy (target, nextarg);
3739
3740             redefine_list_append ("--redefine-sym", source, target);
3741
3742             free (source);
3743             free (target);
3744           }
3745           break;
3746
3747         case OPTION_REDEFINE_SYMS:
3748           add_redefine_syms_file (optarg);
3749           break;
3750
3751         case OPTION_SET_SECTION_FLAGS:
3752           {
3753             const char *s;
3754             int len;
3755             char *name;
3756
3757             s = strchr (optarg, '=');
3758             if (s == NULL)
3759               fatal (_("bad format for %s"), "--set-section-flags");
3760
3761             len = s - optarg;
3762             name = (char *) xmalloc (len + 1);
3763             strncpy (name, optarg, len);
3764             name[len] = '\0';
3765
3766             p = find_section_list (name, TRUE);
3767
3768             p->set_flags = TRUE;
3769             p->flags = parse_flags (s + 1);
3770           }
3771           break;
3772
3773         case OPTION_RENAME_SECTION:
3774           {
3775             flagword flags;
3776             const char *eq, *fl;
3777             char *old_name;
3778             char *new_name;
3779             unsigned int len;
3780
3781             eq = strchr (optarg, '=');
3782             if (eq == NULL)
3783               fatal (_("bad format for %s"), "--rename-section");
3784
3785             len = eq - optarg;
3786             if (len == 0)
3787               fatal (_("bad format for %s"), "--rename-section");
3788
3789             old_name = (char *) xmalloc (len + 1);
3790             strncpy (old_name, optarg, len);
3791             old_name[len] = 0;
3792
3793             eq++;
3794             fl = strchr (eq, ',');
3795             if (fl)
3796               {
3797                 flags = parse_flags (fl + 1);
3798                 len = fl - eq;
3799               }
3800             else
3801               {
3802                 flags = -1;
3803                 len = strlen (eq);
3804               }
3805
3806             if (len == 0)
3807               fatal (_("bad format for %s"), "--rename-section");
3808
3809             new_name = (char *) xmalloc (len + 1);
3810             strncpy (new_name, eq, len);
3811             new_name[len] = 0;
3812
3813             add_section_rename (old_name, new_name, flags);
3814           }
3815           break;
3816
3817         case OPTION_SET_START:
3818           set_start = parse_vma (optarg, "--set-start");
3819           set_start_set = TRUE;
3820           break;
3821
3822         case OPTION_SREC_LEN:
3823           Chunk = parse_vma (optarg, "--srec-len");
3824           break;
3825
3826         case OPTION_SREC_FORCES3:
3827           S3Forced = TRUE;
3828           break;
3829
3830         case OPTION_STRIP_SYMBOLS:
3831           add_specific_symbols (optarg, strip_specific_htab);
3832           break;
3833
3834         case OPTION_STRIP_UNNEEDED_SYMBOLS:
3835           add_specific_symbols (optarg, strip_unneeded_htab);
3836           break;
3837
3838         case OPTION_KEEP_SYMBOLS:
3839           add_specific_symbols (optarg, keep_specific_htab);
3840           break;
3841
3842         case OPTION_LOCALIZE_HIDDEN:
3843           localize_hidden = TRUE;
3844           break;
3845
3846         case OPTION_LOCALIZE_SYMBOLS:
3847           add_specific_symbols (optarg, localize_specific_htab);
3848           break;
3849
3850         case OPTION_LONG_SECTION_NAMES:
3851           if (!strcmp ("enable", optarg))
3852             long_section_names = ENABLE;
3853           else if (!strcmp ("disable", optarg))
3854             long_section_names = DISABLE;
3855           else if (!strcmp ("keep", optarg))
3856             long_section_names = KEEP;
3857           else
3858             fatal (_("unknown long section names option '%s'"), optarg);
3859           break;
3860
3861         case OPTION_GLOBALIZE_SYMBOLS:
3862           add_specific_symbols (optarg, globalize_specific_htab);
3863           break;
3864
3865         case OPTION_KEEPGLOBAL_SYMBOLS:
3866           add_specific_symbols (optarg, keepglobal_specific_htab);
3867           break;
3868
3869         case OPTION_WEAKEN_SYMBOLS:
3870           add_specific_symbols (optarg, weaken_specific_htab);
3871           break;
3872
3873         case OPTION_ALT_MACH_CODE:
3874           use_alt_mach_code = strtoul (optarg, NULL, 0);
3875           if (use_alt_mach_code == 0)
3876             fatal (_("unable to parse alternative machine code"));
3877           break;
3878
3879         case OPTION_PREFIX_SYMBOLS:
3880           prefix_symbols_string = optarg;
3881           break;
3882
3883         case OPTION_PREFIX_SECTIONS:
3884           prefix_sections_string = optarg;
3885           break;
3886
3887         case OPTION_PREFIX_ALLOC_SECTIONS:
3888           prefix_alloc_sections_string = optarg;
3889           break;
3890
3891         case OPTION_READONLY_TEXT:
3892           bfd_flags_to_set |= WP_TEXT;
3893           bfd_flags_to_clear &= ~WP_TEXT;
3894           break;
3895
3896         case OPTION_WRITABLE_TEXT:
3897           bfd_flags_to_clear |= WP_TEXT;
3898           bfd_flags_to_set &= ~WP_TEXT;
3899           break;
3900
3901         case OPTION_PURE:
3902           bfd_flags_to_set |= D_PAGED;
3903           bfd_flags_to_clear &= ~D_PAGED;
3904           break;
3905
3906         case OPTION_IMPURE:
3907           bfd_flags_to_clear |= D_PAGED;
3908           bfd_flags_to_set &= ~D_PAGED;
3909           break;
3910
3911         case OPTION_EXTRACT_DWO:
3912           strip_symbols = STRIP_NONDWO;
3913           break;
3914
3915         case OPTION_EXTRACT_SYMBOL:
3916           extract_symbol = TRUE;
3917           break;
3918
3919         case OPTION_REVERSE_BYTES:
3920           {
3921             int prev = reverse_bytes;
3922
3923             reverse_bytes = atoi (optarg);
3924             if ((reverse_bytes <= 0) || ((reverse_bytes % 2) != 0))
3925               fatal (_("number of bytes to reverse must be positive and even"));
3926
3927             if (prev && prev != reverse_bytes)
3928               non_fatal (_("Warning: ignoring previous --reverse-bytes value of %d"),
3929                          prev);
3930             break;
3931           }
3932
3933         case OPTION_FILE_ALIGNMENT:
3934           pe_file_alignment = parse_vma (optarg, "--file-alignment");
3935           break;
3936
3937         case OPTION_HEAP:
3938             {
3939               char *end;
3940               pe_heap_reserve = strtoul (optarg, &end, 0);
3941               if (end == optarg
3942                   || (*end != '.' && *end != '\0'))
3943                 non_fatal (_("%s: invalid reserve value for --heap"),
3944                            optarg);
3945               else if (*end != '\0')
3946                 {
3947                   pe_heap_commit = strtoul (end + 1, &end, 0);
3948                   if (*end != '\0')
3949                     non_fatal (_("%s: invalid commit value for --heap"),
3950                                optarg);
3951                 }
3952             }
3953           break;
3954
3955         case OPTION_IMAGE_BASE:
3956           pe_image_base = parse_vma (optarg, "--image-base");
3957           break;
3958
3959         case OPTION_SECTION_ALIGNMENT:
3960           pe_section_alignment = parse_vma (optarg,
3961                                             "--section-alignment");
3962           break;
3963
3964         case OPTION_SUBSYSTEM:
3965           set_pe_subsystem (optarg);
3966           break;
3967
3968         case OPTION_STACK:
3969             {
3970               char *end;
3971               pe_stack_reserve = strtoul (optarg, &end, 0);
3972               if (end == optarg
3973                   || (*end != '.' && *end != '\0'))
3974                 non_fatal (_("%s: invalid reserve value for --stack"),
3975                            optarg);
3976               else if (*end != '\0')
3977                 {
3978                   pe_stack_commit = strtoul (end + 1, &end, 0);
3979                   if (*end != '\0')
3980                     non_fatal (_("%s: invalid commit value for --stack"),
3981                                optarg);
3982                 }
3983             }
3984           break;
3985
3986         case 0:
3987           /* We've been given a long option.  */
3988           break;
3989
3990         case 'H':
3991         case 'h':
3992           copy_usage (stdout, 0);
3993
3994         default:
3995           copy_usage (stderr, 1);
3996         }
3997     }
3998
3999   if (formats_info)
4000     {
4001       display_info ();
4002       return 0;
4003     }
4004
4005   if (show_version)
4006     print_version ("objcopy");
4007
4008   if (interleave && copy_byte == -1)
4009     fatal (_("interleave start byte must be set with --byte"));
4010
4011   if (copy_byte >= interleave)
4012     fatal (_("byte number must be less than interleave"));
4013
4014   if (copy_width > interleave - copy_byte)
4015     fatal (_("interleave width must be less than or equal to interleave - byte`"));
4016
4017   if (optind == argc || optind + 2 < argc)
4018     copy_usage (stderr, 1);
4019
4020   input_filename = argv[optind];
4021   if (optind + 1 < argc)
4022     output_filename = argv[optind + 1];
4023
4024   default_deterministic ();
4025
4026   /* Default is to strip no symbols.  */
4027   if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
4028     strip_symbols = STRIP_NONE;
4029
4030   if (output_target == NULL)
4031     output_target = input_target;
4032
4033   /* Convert input EFI target to PEI target.  */
4034   if (input_target != NULL
4035       && strncmp (input_target, "efi-", 4) == 0)
4036     {
4037       char *efi;
4038
4039       efi = xstrdup (output_target + 4);
4040       if (strncmp (efi, "bsdrv-", 6) == 0
4041           || strncmp (efi, "rtdrv-", 6) == 0)
4042         efi += 2;
4043       else if (strncmp (efi, "app-", 4) != 0)
4044         fatal (_("unknown input EFI target: %s"), input_target);
4045
4046       input_target = efi;
4047       convert_efi_target (efi);
4048     }
4049
4050   /* Convert output EFI target to PEI target.  */
4051   if (output_target != NULL
4052       && strncmp (output_target, "efi-", 4) == 0)
4053     {
4054       char *efi;
4055
4056       efi = xstrdup (output_target + 4);
4057       if (strncmp (efi, "app-", 4) == 0)
4058         {
4059           if (pe_subsystem == -1)
4060             pe_subsystem = IMAGE_SUBSYSTEM_EFI_APPLICATION;
4061         }
4062       else if (strncmp (efi, "bsdrv-", 6) == 0)
4063         {
4064           if (pe_subsystem == -1)
4065             pe_subsystem = IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER;
4066           efi += 2;
4067         }
4068       else if (strncmp (efi, "rtdrv-", 6) == 0)
4069         {
4070           if (pe_subsystem == -1)
4071             pe_subsystem = IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER;
4072           efi += 2;
4073         }
4074       else
4075         fatal (_("unknown output EFI target: %s"), output_target);
4076
4077       if (pe_file_alignment == (bfd_vma) -1)
4078         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
4079       if (pe_section_alignment == (bfd_vma) -1)
4080         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
4081
4082       output_target = efi;
4083       convert_efi_target (efi);
4084     }
4085
4086   if (preserve_dates)
4087     if (stat (input_filename, & statbuf) < 0)
4088       fatal (_("warning: could not locate '%s'.  System error message: %s"),
4089              input_filename, strerror (errno));
4090
4091   /* If there is no destination file, or the source and destination files
4092      are the same, then create a temp and rename the result into the input.  */
4093   if (output_filename == NULL
4094       || filename_cmp (input_filename, output_filename) == 0)
4095     tmpname = make_tempname (input_filename);
4096   else
4097     tmpname = output_filename;
4098
4099   if (tmpname == NULL)
4100     fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"),
4101            input_filename, strerror (errno));
4102
4103   copy_file (input_filename, tmpname, input_target, output_target, input_arch);
4104   if (status == 0)
4105     {
4106       if (preserve_dates)
4107         set_times (tmpname, &statbuf);
4108       if (tmpname != output_filename)
4109         status = (smart_rename (tmpname, input_filename,
4110                                 preserve_dates) != 0);
4111     }
4112   else
4113     unlink_if_ordinary (tmpname);
4114
4115   if (change_warn)
4116     {
4117       for (p = change_sections; p != NULL; p = p->next)
4118         {
4119           if (! p->used)
4120             {
4121               if (p->change_vma != CHANGE_IGNORE)
4122                 {
4123                   char buff [20];
4124
4125                   sprintf_vma (buff, p->vma_val);
4126
4127                   /* xgettext:c-format */
4128                   non_fatal (_("%s %s%c0x%s never used"),
4129                              "--change-section-vma",
4130                              p->name,
4131                              p->change_vma == CHANGE_SET ? '=' : '+',
4132                              buff);
4133                 }
4134
4135               if (p->change_lma != CHANGE_IGNORE)
4136                 {
4137                   char buff [20];
4138
4139                   sprintf_vma (buff, p->lma_val);
4140
4141                   /* xgettext:c-format */
4142                   non_fatal (_("%s %s%c0x%s never used"),
4143                              "--change-section-lma",
4144                              p->name,
4145                              p->change_lma == CHANGE_SET ? '=' : '+',
4146                              buff);
4147                 }
4148             }
4149         }
4150     }
4151
4152   return 0;
4153 }
4154
4155 int
4156 main (int argc, char *argv[])
4157 {
4158 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
4159   setlocale (LC_MESSAGES, "");
4160 #endif
4161 #if defined (HAVE_SETLOCALE)
4162   setlocale (LC_CTYPE, "");
4163 #endif
4164   bindtextdomain (PACKAGE, LOCALEDIR);
4165   textdomain (PACKAGE);
4166
4167   program_name = argv[0];
4168   xmalloc_set_program_name (program_name);
4169
4170   START_PROGRESS (program_name, 0);
4171
4172   expandargv (&argc, &argv);
4173
4174   strip_symbols = STRIP_UNDEF;
4175   discard_locals = LOCALS_UNDEF;
4176
4177   bfd_init ();
4178   set_default_bfd_target ();
4179
4180   if (is_strip < 0)
4181     {
4182       int i = strlen (program_name);
4183 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4184       /* Drop the .exe suffix, if any.  */
4185       if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
4186         {
4187           i -= 4;
4188           program_name[i] = '\0';
4189         }
4190 #endif
4191       is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
4192     }
4193
4194   create_symbol_htabs ();
4195
4196   if (is_strip)
4197     strip_main (argc, argv);
4198   else
4199     copy_main (argc, argv);
4200
4201   END_PROGRESS (program_name);
4202
4203   return status;
4204 }