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