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