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