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 /* See if a section is being removed.  */
 789
 790 static bfd_boolean
 791 is_strip_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
 792 {
 793   if (sections_removed || sections_copied)
 794     {
 795       struct section_list *p;
 796
 797       p = find_section_list (bfd_get_section_name (abfd, sec), FALSE);
 798
 799       if (sections_removed && p != NULL && p->remove)
 800         return TRUE;
 801       if (sections_copied && (p == NULL || ! p->copy))
 802         return TRUE;
 803     }
 804
 805   if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0)
 806     {
 807       if (strip_symbols == STRIP_DEBUG
 808           || strip_symbols == STRIP_UNNEEDED
 809           || strip_symbols == STRIP_ALL
 810           || discard_locals == LOCALS_ALL
 811           || convert_debugging)
 812         return TRUE;
 813
 814       if (strip_symbols == STRIP_NONDEBUG)
 815         return FALSE;
 816     }
 817
 818   return FALSE;
 819 }
 820
 821 /* Return true if SYM is a hidden symbol.  */
 822
 823 static bfd_boolean
 824 is_hidden_symbol (asymbol *sym)
 825 {
 826   elf_symbol_type *elf_sym;
 827
 828   elf_sym = elf_symbol_from (sym->the_bfd, sym);
 829   if (elf_sym != NULL)
 830     switch (ELF_ST_VISIBILITY (elf_sym->internal_elf_sym.st_other))
 831       {
 832       case STV_HIDDEN:
 833       case STV_INTERNAL:
 834         return TRUE;
 835       }
 836   return FALSE;
 837 }
 838
 839 /* Choose which symbol entries to copy; put the result in OSYMS.
 840    We don't copy in place, because that confuses the relocs.
 841    Return the number of symbols to print.  */
 842
 843 static unsigned int
 844 filter_symbols (bfd *abfd, bfd *obfd, asymbol **osyms,
 845                 asymbol **isyms, long symcount)
 846 {
 847   asymbol **from = isyms, **to = osyms;
 848   long src_count = 0, dst_count = 0;
 849   int relocatable = (abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
 850                     == HAS_RELOC;
 851
 852   for (; src_count < symcount; src_count++)
 853     {
 854       asymbol *sym = from[src_count];
 855       flagword flags = sym->flags;
 856       char *name = (char *) bfd_asymbol_name (sym);
 857       int keep;
 858       bfd_boolean undefined;
 859       bfd_boolean rem_leading_char;
 860       bfd_boolean add_leading_char;
 861
 862       undefined = bfd_is_und_section (bfd_get_section (sym));
 863
 864       if (redefine_sym_list)
 865         {
 866           char *old_name, *new_name;
 867
 868           old_name = (char *) bfd_asymbol_name (sym);
 869           new_name = (char *) lookup_sym_redefinition (old_name);
 870           bfd_asymbol_name (sym) = new_name;
 871           name = new_name;
 872         }
 873
 874       /* Check if we will remove the current leading character.  */
 875       rem_leading_char =
 876         (name[0] == bfd_get_symbol_leading_char (abfd))
 877         && (change_leading_char
 878             || (remove_leading_char
 879                 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
 880                     || undefined
 881                     || bfd_is_com_section (bfd_get_section (sym)))));
 882
 883       /* Check if we will add a new leading character.  */
 884       add_leading_char =
 885         change_leading_char
 886         && (bfd_get_symbol_leading_char (obfd) != '\0')
 887         && (bfd_get_symbol_leading_char (abfd) == '\0'
 888             || (name[0] == bfd_get_symbol_leading_char (abfd)));
 889
 890       /* Short circuit for change_leading_char if we can do it in-place.  */
 891       if (rem_leading_char && add_leading_char && !prefix_symbols_string)
 892         {
 893           name[0] = bfd_get_symbol_leading_char (obfd);
 894           bfd_asymbol_name (sym) = name;
 895           rem_leading_char = FALSE;
 896           add_leading_char = FALSE;
 897         }
 898
 899       /* Remove leading char.  */
 900       if (rem_leading_char)
 901         bfd_asymbol_name (sym) = ++name;
 902
 903       /* Add new leading char and/or prefix.  */
 904       if (add_leading_char || prefix_symbols_string)
 905         {
 906           char *n, *ptr;
 907
 908           ptr = n = xmalloc (1 + strlen (prefix_symbols_string)
 909                              + strlen (name) + 1);
 910           if (add_leading_char)
 911             *ptr++ = bfd_get_symbol_leading_char (obfd);
 912
 913           if (prefix_symbols_string)
 914             {
 915               strcpy (ptr, prefix_symbols_string);
 916               ptr += strlen (prefix_symbols_string);
 917            }
 918
 919           strcpy (ptr, name);
 920           bfd_asymbol_name (sym) = n;
 921           name = n;
 922         }
 923
 924       if (strip_symbols == STRIP_ALL)
 925         keep = 0;
 926       else if ((flags & BSF_KEEP) != 0          /* Used in relocation.  */
 927                || ((flags & BSF_SECTION_SYM) != 0
 928                    && ((*bfd_get_section (sym)->symbol_ptr_ptr)->flags
 929                        & BSF_KEEP) != 0))
 930         keep = 1;
 931       else if (relocatable                      /* Relocatable file.  */
 932                && (flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
 933         keep = 1;
 934       else if (bfd_decode_symclass (sym) == 'I')
 935         /* Global symbols in $idata sections need to be retained
 936            even if relocatable is FALSE.  External users of the
 937            library containing the $idata section may reference these
 938            symbols.  */
 939         keep = 1;
 940       else if ((flags & BSF_GLOBAL) != 0        /* Global symbol.  */
 941                || (flags & BSF_WEAK) != 0
 942                || undefined
 943                || bfd_is_com_section (bfd_get_section (sym)))
 944         keep = strip_symbols != STRIP_UNNEEDED;
 945       else if ((flags & BSF_DEBUGGING) != 0)    /* Debugging symbol.  */
 946         keep = (strip_symbols != STRIP_DEBUG
 947                 && strip_symbols != STRIP_UNNEEDED
 948                 && ! convert_debugging);
 949       else if (bfd_coff_get_comdat_section (abfd, bfd_get_section (sym)))
 950         /* COMDAT sections store special information in local
 951            symbols, so we cannot risk stripping any of them.  */
 952         keep = 1;
 953       else                      /* Local symbol.  */
 954         keep = (strip_symbols != STRIP_UNNEEDED
 955                 && (discard_locals != LOCALS_ALL
 956                     && (discard_locals != LOCALS_START_L
 957                         || ! bfd_is_local_label (abfd, sym))));
 958
 959       if (keep && is_specified_symbol (name, strip_specific_list))
 960         keep = 0;
 961       if (keep
 962           && !(flags & BSF_KEEP)
 963           && is_specified_symbol (name, strip_unneeded_list))
 964         keep = 0;
 965       if (!keep
 966           && ((keep_file_symbols && (flags & BSF_FILE))
 967               || is_specified_symbol (name, keep_specific_list)))
 968         keep = 1;
 969       if (keep && is_strip_section (abfd, bfd_get_section (sym)))
 970         keep = 0;
 971
 972       if (keep)
 973         {
 974           if ((flags & BSF_GLOBAL) != 0
 975               && (weaken || is_specified_symbol (name, weaken_specific_list)))
 976             {
 977               sym->flags &= ~ BSF_GLOBAL;
 978               sym->flags |= BSF_WEAK;
 979             }
 980
 981           if (!undefined
 982               && (flags & (BSF_GLOBAL | BSF_WEAK))
 983               && (is_specified_symbol (name, localize_specific_list)
 984                   || (keepglobal_specific_list != NULL
 985                       && ! is_specified_symbol (name, keepglobal_specific_list))
 986                   || (localize_hidden && is_hidden_symbol (sym))))
 987             {
 988               sym->flags &= ~ (BSF_GLOBAL | BSF_WEAK);
 989               sym->flags |= BSF_LOCAL;
 990             }
 991
 992           if (!undefined
 993               && (flags & BSF_LOCAL)
 994               && is_specified_symbol (name, globalize_specific_list))
 995             {
 996               sym->flags &= ~ BSF_LOCAL;
 997               sym->flags |= BSF_GLOBAL;
 998             }
 999
1000           to[dst_count++] = sym;
1001         }
1002     }
1003
1004   to[dst_count] = NULL;
1005
1006   return dst_count;
1007 }
1008
1009 /* Find the redefined name of symbol SOURCE.  */
1010
1011 static const char *
1012 lookup_sym_redefinition (const char *source)
1013 {
1014   struct redefine_node *list;
1015
1016   for (list = redefine_sym_list; list != NULL; list = list->next)
1017     if (strcmp (source, list->source) == 0)
1018       return list->target;
1019
1020   return source;
1021 }
1022
1023 /* Add a node to a symbol redefine list.  */
1024
1025 static void
1026 redefine_list_append (const char *cause, const char *source, const char *target)
1027 {
1028   struct redefine_node **p;
1029   struct redefine_node *list;
1030   struct redefine_node *new_node;
1031
1032   for (p = &redefine_sym_list; (list = *p) != NULL; p = &list->next)
1033     {
1034       if (strcmp (source, list->source) == 0)
1035         fatal (_("%s: Multiple redefinition of symbol \"%s\""),
1036                cause, source);
1037
1038       if (strcmp (target, list->target) == 0)
1039         fatal (_("%s: Symbol \"%s\" is target of more than one redefinition"),
1040                cause, target);
1041     }
1042
1043   new_node = xmalloc (sizeof (struct redefine_node));
1044
1045   new_node->source = strdup (source);
1046   new_node->target = strdup (target);
1047   new_node->next = NULL;
1048
1049   *p = new_node;
1050 }
1051
1052 /* Handle the --redefine-syms option.  Read lines containing "old new"
1053    from the file, and add them to the symbol redefine list.  */
1054
1055 static void
1056 add_redefine_syms_file (const char *filename)
1057 {
1058   FILE *file;
1059   char *buf;
1060   size_t bufsize;
1061   size_t len;
1062   size_t outsym_off;
1063   int c, lineno;
1064
1065   file = fopen (filename, "r");
1066   if (file == NULL)
1067     fatal (_("couldn't open symbol redefinition file %s (error: %s)"),
1068            filename, strerror (errno));
1069
1070   bufsize = 100;
1071   buf = xmalloc (bufsize);
1072
1073   lineno = 1;
1074   c = getc (file);
1075   len = 0;
1076   outsym_off = 0;
1077   while (c != EOF)
1078     {
1079       /* Collect the input symbol name.  */
1080       while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1081         {
1082           if (c == '#')
1083             goto comment;
1084           buf[len++] = c;
1085           if (len >= bufsize)
1086             {
1087               bufsize *= 2;
1088               buf = xrealloc (buf, bufsize);
1089             }
1090           c = getc (file);
1091         }
1092       buf[len++] = '\0';
1093       if (c == EOF)
1094         break;
1095
1096       /* Eat white space between the symbol names.  */
1097       while (IS_WHITESPACE (c))
1098         c = getc (file);
1099       if (c == '#' || IS_LINE_TERMINATOR (c))
1100         goto comment;
1101       if (c == EOF)
1102         break;
1103
1104       /* Collect the output symbol name.  */
1105       outsym_off = len;
1106       while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1107         {
1108           if (c == '#')
1109             goto comment;
1110           buf[len++] = c;
1111           if (len >= bufsize)
1112             {
1113               bufsize *= 2;
1114               buf = xrealloc (buf, bufsize);
1115             }
1116           c = getc (file);
1117         }
1118       buf[len++] = '\0';
1119       if (c == EOF)
1120         break;
1121
1122       /* Eat white space at end of line.  */
1123       while (! IS_LINE_TERMINATOR(c) && c != EOF && IS_WHITESPACE (c))
1124         c = getc (file);
1125       if (c == '#')
1126         goto comment;
1127       /* Handle \r\n.  */
1128       if ((c == '\r' && (c = getc (file)) == '\n')
1129           || c == '\n' || c == EOF)
1130         {
1131  end_of_line:
1132           /* Append the redefinition to the list.  */
1133           if (buf[0] != '\0')
1134             redefine_list_append (filename, &buf[0], &buf[outsym_off]);
1135
1136           lineno++;
1137           len = 0;
1138           outsym_off = 0;
1139           if (c == EOF)
1140             break;
1141           c = getc (file);
1142           continue;
1143         }
1144       else
1145         fatal (_("%s:%d: garbage found at end of line"), filename, lineno);
1146  comment:
1147       if (len != 0 && (outsym_off == 0 || outsym_off == len))
1148         fatal (_("%s:%d: missing new symbol name"), filename, lineno);
1149       buf[len++] = '\0';
1150
1151       /* Eat the rest of the line and finish it.  */
1152       while (c != '\n' && c != EOF)
1153         c = getc (file);
1154       goto end_of_line;
1155     }
1156
1157   if (len != 0)
1158     fatal (_("%s:%d: premature end of file"), filename, lineno);
1159
1160   free (buf);
1161 }
1162
1163 /* Copy unkown object file IBFD onto OBFD.
1164    Returns TRUE upon success, FALSE otherwise.  */
1165
1166 static bfd_boolean
1167 copy_unknown_object (bfd *ibfd, bfd *obfd)
1168 {
1169   char *cbuf;
1170   int tocopy;
1171   long ncopied;
1172   long size;
1173   struct stat buf;
1174
1175   if (bfd_stat_arch_elt (ibfd, &buf) != 0)
1176     {
1177       bfd_nonfatal (bfd_get_archive_filename (ibfd));
1178       return FALSE;
1179     }
1180
1181   size = buf.st_size;
1182   if (size < 0)
1183     {
1184       non_fatal (_("stat returns negative size for `%s'"),
1185                  bfd_get_archive_filename (ibfd));
1186       return FALSE;
1187     }
1188
1189   if (bfd_seek (ibfd, (file_ptr) 0, SEEK_SET) != 0)
1190     {
1191       bfd_nonfatal (bfd_get_archive_filename (ibfd));
1192       return FALSE;
1193     }
1194
1195   if (verbose)
1196     printf (_("copy from `%s' [unknown] to `%s' [unknown]\n"),
1197             bfd_get_archive_filename (ibfd), bfd_get_filename (obfd));
1198
1199   cbuf = xmalloc (BUFSIZE);
1200   ncopied = 0;
1201   while (ncopied < size)
1202     {
1203       tocopy = size - ncopied;
1204       if (tocopy > BUFSIZE)
1205         tocopy = BUFSIZE;
1206
1207       if (bfd_bread (cbuf, (bfd_size_type) tocopy, ibfd)
1208           != (bfd_size_type) tocopy)
1209         {
1210           bfd_nonfatal (bfd_get_archive_filename (ibfd));
1211           free (cbuf);
1212           return FALSE;
1213         }
1214
1215       if (bfd_bwrite (cbuf, (bfd_size_type) tocopy, obfd)
1216           != (bfd_size_type) tocopy)
1217         {
1218           bfd_nonfatal (bfd_get_filename (obfd));
1219           free (cbuf);
1220           return FALSE;
1221         }
1222
1223       ncopied += tocopy;
1224     }
1225
1226   chmod (bfd_get_filename (obfd), buf.st_mode);
1227   free (cbuf);
1228   return TRUE;
1229 }
1230
1231 /* Copy object file IBFD onto OBFD.
1232    Returns TRUE upon success, FALSE otherwise.  */
1233
1234 static bfd_boolean
1235 copy_object (bfd *ibfd, bfd *obfd)
1236 {
1237   bfd_vma start;
1238   long symcount;
1239   asection **osections = NULL;
1240   asection *gnu_debuglink_section = NULL;
1241   bfd_size_type *gaps = NULL;
1242   bfd_size_type max_gap = 0;
1243   long symsize;
1244   void *dhandle;
1245   enum bfd_architecture iarch;
1246   unsigned int imach;
1247
1248   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1249       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1250       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1251     fatal (_("Unable to change endianness of input file(s)"));
1252
1253   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1254     {
1255       bfd_nonfatal (bfd_get_filename (obfd));
1256       return FALSE;
1257     }
1258
1259   if (verbose)
1260     printf (_("copy from `%s' [%s] to `%s' [%s]\n"),
1261             bfd_get_archive_filename (ibfd), bfd_get_target (ibfd),
1262             bfd_get_filename (obfd), bfd_get_target (obfd));
1263
1264   if (set_start_set)
1265     start = set_start;
1266   else
1267     start = bfd_get_start_address (ibfd);
1268   start += change_start;
1269
1270   /* Neither the start address nor the flags
1271      need to be set for a core file.  */
1272   if (bfd_get_format (obfd) != bfd_core)
1273     {
1274       flagword flags;
1275
1276       flags = bfd_get_file_flags (ibfd);
1277       flags |= bfd_flags_to_set;
1278       flags &= ~bfd_flags_to_clear;
1279       flags &= bfd_applicable_file_flags (obfd);
1280
1281       if (!bfd_set_start_address (obfd, start)
1282           || !bfd_set_file_flags (obfd, flags))
1283         {
1284           bfd_nonfatal (bfd_get_archive_filename (ibfd));
1285           return FALSE;
1286         }
1287     }
1288
1289   /* Copy architecture of input file to output file.  */
1290   iarch = bfd_get_arch (ibfd);
1291   imach = bfd_get_mach (ibfd);
1292   if (!bfd_set_arch_mach (obfd, iarch, imach)
1293       && (ibfd->target_defaulted
1294           || bfd_get_arch (ibfd) != bfd_get_arch (obfd)))
1295     {
1296       if (bfd_get_arch (ibfd) == bfd_arch_unknown)
1297         non_fatal (_("Unable to recognise the format of the input file `%s'"),
1298                    bfd_get_archive_filename (ibfd));
1299       else
1300         non_fatal (_("Warning: Output file cannot represent architecture `%s'"),
1301                    bfd_printable_arch_mach (bfd_get_arch (ibfd),
1302                                             bfd_get_mach (ibfd)));
1303       return FALSE;
1304     }
1305
1306   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1307     {
1308       bfd_nonfatal (bfd_get_archive_filename (ibfd));
1309       return FALSE;
1310     }
1311
1312   if (isympp)
1313     free (isympp);
1314
1315   if (osympp != isympp)
1316     free (osympp);
1317
1318   isympp = NULL;
1319   osympp = NULL;
1320
1321   /* BFD mandates that all output sections be created and sizes set before
1322      any output is done.  Thus, we traverse all sections multiple times.  */
1323   bfd_map_over_sections (ibfd, setup_section, obfd);
1324
1325   setup_bfd_headers (ibfd, obfd);
1326
1327   if (add_sections != NULL)
1328     {
1329       struct section_add *padd;
1330       struct section_list *pset;
1331
1332       for (padd = add_sections; padd != NULL; padd = padd->next)
1333         {
1334           flagword flags;
1335
1336           pset = find_section_list (padd->name, FALSE);
1337           if (pset != NULL)
1338             pset->used = TRUE;
1339
1340           flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
1341           if (pset != NULL && pset->set_flags)
1342             flags = pset->flags | SEC_HAS_CONTENTS;
1343
1344           /* bfd_make_section_with_flags() does not return very helpful
1345              error codes, so check for the most likely user error first.  */
1346           if (bfd_get_section_by_name (obfd, padd->name))
1347             {
1348               non_fatal (_("can't add section '%s' - it already exists!"), padd->name);
1349               return FALSE;
1350             }
1351           else
1352             {
1353               padd->section = bfd_make_section_with_flags (obfd, padd->name, flags);
1354               if (padd->section == NULL)
1355                 {
1356                   non_fatal (_("can't create section `%s': %s"),
1357                              padd->name, bfd_errmsg (bfd_get_error ()));
1358                   return FALSE;
1359                 }
1360             }
1361
1362           if (! bfd_set_section_size (obfd, padd->section, padd->size))
1363             {
1364               bfd_nonfatal (bfd_get_filename (obfd));
1365               return FALSE;
1366             }
1367
1368           if (pset != NULL)
1369             {
1370               if (pset->change_vma != CHANGE_IGNORE)
1371                 if (! bfd_set_section_vma (obfd, padd->section,
1372                                            pset->vma_val))
1373                   {
1374                     bfd_nonfatal (bfd_get_filename (obfd));
1375                     return FALSE;
1376                   }
1377
1378               if (pset->change_lma != CHANGE_IGNORE)
1379                 {
1380                   padd->section->lma = pset->lma_val;
1381
1382                   if (! bfd_set_section_alignment
1383                       (obfd, padd->section,
1384                        bfd_section_alignment (obfd, padd->section)))
1385                     {
1386                       bfd_nonfatal (bfd_get_filename (obfd));
1387                       return FALSE;
1388                     }
1389                 }
1390             }
1391         }
1392     }
1393
1394   if (gnu_debuglink_filename != NULL)
1395     {
1396       gnu_debuglink_section = bfd_create_gnu_debuglink_section
1397         (obfd, gnu_debuglink_filename);
1398
1399       if (gnu_debuglink_section == NULL)
1400         {
1401           bfd_nonfatal (gnu_debuglink_filename);
1402           return FALSE;
1403         }
1404
1405       /* Special processing for PE format files.  We
1406          have no way to distinguish PE from COFF here.  */
1407       if (bfd_get_flavour (obfd) == bfd_target_coff_flavour)
1408         {
1409           bfd_vma debuglink_vma;
1410           asection * highest_section;
1411           asection * sec;
1412
1413           /* The PE spec requires that all sections be adjacent and sorted
1414              in ascending order of VMA.  It also specifies that debug
1415              sections should be last.  This is despite the fact that debug
1416              sections are not loaded into memory and so in theory have no
1417              use for a VMA.
1418
1419              This means that the debuglink section must be given a non-zero
1420              VMA which makes it contiguous with other debug sections.  So
1421              walk the current section list, find the section with the
1422              highest VMA and start the debuglink section after that one.  */
1423           for (sec = obfd->sections, highest_section = NULL;
1424                sec != NULL;
1425                sec = sec->next)
1426             if (sec->vma > 0
1427                 && (highest_section == NULL
1428                     || sec->vma > highest_section->vma))
1429               highest_section = sec;
1430
1431           if (highest_section)
1432             debuglink_vma = BFD_ALIGN (highest_section->vma
1433                                        + highest_section->size,
1434                                        /* FIXME: We ought to be using
1435                                           COFF_PAGE_SIZE here or maybe
1436                                           bfd_get_section_alignment() (if it
1437                                           was set) but since this is for PE
1438                                           and we know the required alignment
1439                                           it is easier just to hard code it.  */
1440                                        0x1000);
1441           else
1442             /* Umm, not sure what to do in this case.  */
1443             debuglink_vma = 0x1000;
1444
1445           bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma);
1446         }
1447     }
1448
1449   if (bfd_count_sections (obfd) == 0)
1450     {
1451       non_fatal (_("there are no sections to be copied!"));
1452       return FALSE;
1453     }
1454
1455   if (gap_fill_set || pad_to_set)
1456     {
1457       asection **set;
1458       unsigned int c, i;
1459
1460       /* We must fill in gaps between the sections and/or we must pad
1461          the last section to a specified address.  We do this by
1462          grabbing a list of the sections, sorting them by VMA, and
1463          increasing the section sizes as required to fill the gaps.
1464          We write out the gap contents below.  */
1465
1466       c = bfd_count_sections (obfd);
1467       osections = xmalloc (c * sizeof (asection *));
1468       set = osections;
1469       bfd_map_over_sections (obfd, get_sections, &set);
1470
1471       qsort (osections, c, sizeof (asection *), compare_section_lma);
1472
1473       gaps = xmalloc (c * sizeof (bfd_size_type));
1474       memset (gaps, 0, c * sizeof (bfd_size_type));
1475
1476       if (gap_fill_set)
1477         {
1478           for (i = 0; i < c - 1; i++)
1479             {
1480               flagword flags;
1481               bfd_size_type size;
1482               bfd_vma gap_start, gap_stop;
1483
1484               flags = bfd_get_section_flags (obfd, osections[i]);
1485               if ((flags & SEC_HAS_CONTENTS) == 0
1486                   || (flags & SEC_LOAD) == 0)
1487                 continue;
1488
1489               size = bfd_section_size (obfd, osections[i]);
1490               gap_start = bfd_section_lma (obfd, osections[i]) + size;
1491               gap_stop = bfd_section_lma (obfd, osections[i + 1]);
1492               if (gap_start < gap_stop)
1493                 {
1494                   if (! bfd_set_section_size (obfd, osections[i],
1495                                               size + (gap_stop - gap_start)))
1496                     {
1497                       non_fatal (_("Can't fill gap after %s: %s"),
1498                                  bfd_get_section_name (obfd, osections[i]),
1499                                  bfd_errmsg (bfd_get_error ()));
1500                       status = 1;
1501                       break;
1502                     }
1503                   gaps[i] = gap_stop - gap_start;
1504                   if (max_gap < gap_stop - gap_start)
1505                     max_gap = gap_stop - gap_start;
1506                 }
1507             }
1508         }
1509
1510       if (pad_to_set)
1511         {
1512           bfd_vma lma;
1513           bfd_size_type size;
1514
1515           lma = bfd_section_lma (obfd, osections[c - 1]);
1516           size = bfd_section_size (obfd, osections[c - 1]);
1517           if (lma + size < pad_to)
1518             {
1519               if (! bfd_set_section_size (obfd, osections[c - 1],
1520                                           pad_to - lma))
1521                 {
1522                   non_fatal (_("Can't add padding to %s: %s"),
1523                              bfd_get_section_name (obfd, osections[c - 1]),
1524                              bfd_errmsg (bfd_get_error ()));
1525                   status = 1;
1526                 }
1527               else
1528                 {
1529                   gaps[c - 1] = pad_to - (lma + size);
1530                   if (max_gap < pad_to - (lma + size))
1531                     max_gap = pad_to - (lma + size);
1532                 }
1533             }
1534         }
1535     }
1536
1537   /* Symbol filtering must happen after the output sections
1538      have been created, but before their contents are set.  */
1539   dhandle = NULL;
1540   symsize = bfd_get_symtab_upper_bound (ibfd);
1541   if (symsize < 0)
1542     {
1543       bfd_nonfatal (bfd_get_archive_filename (ibfd));
1544       return FALSE;
1545     }
1546
1547   osympp = isympp = xmalloc (symsize);
1548   symcount = bfd_canonicalize_symtab (ibfd, isympp);
1549   if (symcount < 0)
1550     {
1551       bfd_nonfatal (bfd_get_filename (ibfd));
1552       return FALSE;
1553     }
1554
1555   if (convert_debugging)
1556     dhandle = read_debugging_info (ibfd, isympp, symcount);
1557
1558   if (strip_symbols == STRIP_DEBUG
1559       || strip_symbols == STRIP_ALL
1560       || strip_symbols == STRIP_UNNEEDED
1561       || strip_symbols == STRIP_NONDEBUG
1562       || discard_locals != LOCALS_UNDEF
1563       || localize_hidden
1564       || strip_specific_list != NULL
1565       || keep_specific_list != NULL
1566       || localize_specific_list != NULL
1567       || globalize_specific_list != NULL
1568       || keepglobal_specific_list != NULL
1569       || weaken_specific_list != NULL
1570       || prefix_symbols_string
1571       || sections_removed
1572       || sections_copied
1573       || convert_debugging
1574       || change_leading_char
1575       || remove_leading_char
1576       || redefine_sym_list
1577       || weaken)
1578     {
1579       /* Mark symbols used in output relocations so that they
1580          are kept, even if they are local labels or static symbols.
1581
1582          Note we iterate over the input sections examining their
1583          relocations since the relocations for the output sections
1584          haven't been set yet.  mark_symbols_used_in_relocations will
1585          ignore input sections which have no corresponding output
1586          section.  */
1587       if (strip_symbols != STRIP_ALL)
1588         bfd_map_over_sections (ibfd,
1589                                mark_symbols_used_in_relocations,
1590                                isympp);
1591       osympp = xmalloc ((symcount + 1) * sizeof (asymbol *));
1592       symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
1593     }
1594
1595   if (convert_debugging && dhandle != NULL)
1596     {
1597       if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
1598         {
1599           status = 1;
1600           return FALSE;
1601         }
1602     }
1603
1604   bfd_set_symtab (obfd, osympp, symcount);
1605
1606   /* This has to happen after the symbol table has been set.  */
1607   bfd_map_over_sections (ibfd, copy_section, obfd);
1608
1609   if (add_sections != NULL)
1610     {
1611       struct section_add *padd;
1612
1613       for (padd = add_sections; padd != NULL; padd = padd->next)
1614         {
1615           if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
1616                                           0, padd->size))
1617             {
1618               bfd_nonfatal (bfd_get_filename (obfd));
1619               return FALSE;
1620             }
1621         }
1622     }
1623
1624   if (gnu_debuglink_filename != NULL)
1625     {
1626       if (! bfd_fill_in_gnu_debuglink_section
1627           (obfd, gnu_debuglink_section, gnu_debuglink_filename))
1628         {
1629           bfd_nonfatal (gnu_debuglink_filename);
1630           return FALSE;
1631         }
1632     }
1633
1634   if (gap_fill_set || pad_to_set)
1635     {
1636       bfd_byte *buf;
1637       int c, i;
1638
1639       /* Fill in the gaps.  */
1640       if (max_gap > 8192)
1641         max_gap = 8192;
1642       buf = xmalloc (max_gap);
1643       memset (buf, gap_fill, max_gap);
1644
1645       c = bfd_count_sections (obfd);
1646       for (i = 0; i < c; i++)
1647         {
1648           if (gaps[i] != 0)
1649             {
1650               bfd_size_type left;
1651               file_ptr off;
1652
1653               left = gaps[i];
1654               off = bfd_section_size (obfd, osections[i]) - left;
1655
1656               while (left > 0)
1657                 {
1658                   bfd_size_type now;
1659
1660                   if (left > 8192)
1661                     now = 8192;
1662                   else
1663                     now = left;
1664
1665                   if (! bfd_set_section_contents (obfd, osections[i], buf,
1666                                                   off, now))
1667                     {
1668                       bfd_nonfatal (bfd_get_filename (obfd));
1669                       return FALSE;
1670                     }
1671
1672                   left -= now;
1673                   off += now;
1674                 }
1675             }
1676         }
1677     }
1678
1679   /* Allow the BFD backend to copy any private data it understands
1680      from the input BFD to the output BFD.  This is done last to
1681      permit the routine to look at the filtered symbol table, which is
1682      important for the ECOFF code at least.  */
1683   if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
1684       && strip_symbols == STRIP_NONDEBUG)
1685     /* Do not copy the private data when creating an ELF format
1686        debug info file.  We do not want the program headers.  */
1687     ;
1688   else if (! bfd_copy_private_bfd_data (ibfd, obfd))
1689     {
1690       non_fatal (_("%s: error copying private BFD data: %s"),
1691                  bfd_get_filename (obfd),
1692                  bfd_errmsg (bfd_get_error ()));
1693       return FALSE;
1694     }
1695
1696   /* Switch to the alternate machine code.  We have to do this at the
1697      very end, because we only initialize the header when we create
1698      the first section.  */
1699   if (use_alt_mach_code != 0)
1700     {
1701       if (! bfd_alt_mach_code (obfd, use_alt_mach_code))
1702         {
1703           non_fatal (_("this target does not support %lu alternative machine codes"),
1704                      use_alt_mach_code);
1705           if (bfd_get_flavour (obfd) == bfd_target_elf_flavour)
1706             {
1707               non_fatal (_("treating that number as an absolute e_machine value instead"));
1708               elf_elfheader (obfd)->e_machine = use_alt_mach_code;
1709             }
1710           else
1711             non_fatal (_("ignoring the alternative value"));
1712         }
1713     }
1714
1715   return TRUE;
1716 }
1717
1718 #undef MKDIR
1719 #if defined (_WIN32) && !defined (__CYGWIN32__)
1720 #define MKDIR(DIR, MODE) mkdir (DIR)
1721 #else
1722 #define MKDIR(DIR, MODE) mkdir (DIR, MODE)
1723 #endif
1724
1725 /* Read each archive element in turn from IBFD, copy the
1726    contents to temp file, and keep the temp file handle.  */
1727
1728 static void
1729 copy_archive (bfd *ibfd, bfd *obfd, const char *output_target)
1730 {
1731   struct name_list
1732     {
1733       struct name_list *next;
1734       const char *name;
1735       bfd *obfd;
1736     } *list, *l;
1737   bfd **ptr = &obfd->archive_head;
1738   bfd *this_element;
1739   char *dir = make_tempname (bfd_get_filename (obfd));
1740
1741   /* Make a temp directory to hold the contents.  */
1742   if (MKDIR (dir, 0700) != 0)
1743     fatal (_("cannot mkdir %s for archive copying (error: %s)"),
1744            dir, strerror (errno));
1745
1746   obfd->has_armap = ibfd->has_armap;
1747
1748   list = NULL;
1749
1750   this_element = bfd_openr_next_archived_file (ibfd, NULL);
1751
1752   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1753     RETURN_NONFATAL (bfd_get_filename (obfd));
1754
1755   while (!status && this_element != NULL)
1756     {
1757       char *output_name;
1758       bfd *output_bfd;
1759       bfd *last_element;
1760       struct stat buf;
1761       int stat_status = 0;
1762       bfd_boolean delete = TRUE;
1763
1764       /* Create an output file for this member.  */
1765       output_name = concat (dir, "/",
1766                             bfd_get_filename (this_element), (char *) 0);
1767
1768       /* If the file already exists, make another temp dir.  */
1769       if (stat (output_name, &buf) >= 0)
1770         {
1771           output_name = make_tempname (output_name);
1772           if (MKDIR (output_name, 0700) != 0)
1773             fatal (_("cannot mkdir %s for archive copying (error: %s)"),
1774                    output_name, strerror (errno));
1775
1776           l = xmalloc (sizeof (struct name_list));
1777           l->name = output_name;
1778           l->next = list;
1779           l->obfd = NULL;
1780           list = l;
1781           output_name = concat (output_name, "/",
1782                                 bfd_get_filename (this_element), (char *) 0);
1783         }
1784
1785       output_bfd = bfd_openw (output_name, output_target);
1786       if (preserve_dates)
1787         {
1788           stat_status = bfd_stat_arch_elt (this_element, &buf);
1789
1790           if (stat_status != 0)
1791             non_fatal (_("internal stat error on %s"),
1792                        bfd_get_filename (this_element));
1793         }
1794
1795       l = xmalloc (sizeof (struct name_list));
1796       l->name = output_name;
1797       l->next = list;
1798       l->obfd = NULL;
1799       list = l;
1800
1801       if (output_bfd == NULL)
1802         RETURN_NONFATAL (output_name);
1803
1804       if (bfd_check_format (this_element, bfd_object))
1805         {
1806           delete = ! copy_object (this_element, output_bfd);
1807
1808           if (! delete
1809               || bfd_get_arch (this_element) != bfd_arch_unknown)
1810             {
1811               if (!bfd_close (output_bfd))
1812                 {
1813                   bfd_nonfatal (bfd_get_filename (output_bfd));
1814                   /* Error in new object file. Don't change archive.  */
1815                   status = 1;
1816                 }
1817             }
1818           else
1819             goto copy_unknown_element;
1820         }
1821       else
1822         {
1823           non_fatal (_("Unable to recognise the format of the input file `%s'"),
1824                      bfd_get_archive_filename (this_element));
1825
1826 copy_unknown_element:
1827           delete = !copy_unknown_object (this_element, output_bfd);
1828           if (!bfd_close_all_done (output_bfd))
1829             {
1830               bfd_nonfatal (bfd_get_filename (output_bfd));
1831               /* Error in new object file. Don't change archive.  */
1832               status = 1;
1833             }
1834         }
1835
1836       if (delete)
1837         {
1838           unlink (output_name);
1839           status = 1;
1840         }
1841       else
1842         {
1843           if (preserve_dates && stat_status == 0)
1844             set_times (output_name, &buf);
1845
1846           /* Open the newly output file and attach to our list.  */
1847           output_bfd = bfd_openr (output_name, output_target);
1848
1849           l->obfd = output_bfd;
1850
1851           *ptr = output_bfd;
1852           ptr = &output_bfd->next;
1853
1854           last_element = this_element;
1855
1856           this_element = bfd_openr_next_archived_file (ibfd, last_element);
1857
1858           bfd_close (last_element);
1859         }
1860     }
1861   *ptr = NULL;
1862
1863   if (!bfd_close (obfd))
1864     RETURN_NONFATAL (bfd_get_filename (obfd));
1865
1866   if (!bfd_close (ibfd))
1867     RETURN_NONFATAL (bfd_get_filename (ibfd));
1868
1869   /* Delete all the files that we opened.  */
1870   for (l = list; l != NULL; l = l->next)
1871     {
1872       if (l->obfd == NULL)
1873         rmdir (l->name);
1874       else
1875         {
1876           bfd_close (l->obfd);
1877           unlink (l->name);
1878         }
1879     }
1880   rmdir (dir);
1881 }
1882
1883 /* The top-level control.  */
1884
1885 static void
1886 copy_file (const char *input_filename, const char *output_filename,
1887            const char *input_target,   const char *output_target)
1888 {
1889   bfd *ibfd;
1890   char **obj_matching;
1891   char **core_matching;
1892
1893   if (get_file_size (input_filename) < 1)
1894     {
1895       status = 1;
1896       return;
1897     }
1898
1899   /* To allow us to do "strip *" without dying on the first
1900      non-object file, failures are nonfatal.  */
1901   ibfd = bfd_openr (input_filename, input_target);
1902   if (ibfd == NULL)
1903     RETURN_NONFATAL (input_filename);
1904
1905   if (bfd_check_format (ibfd, bfd_archive))
1906     {
1907       bfd *obfd;
1908
1909       /* bfd_get_target does not return the correct value until
1910          bfd_check_format succeeds.  */
1911       if (output_target == NULL)
1912         output_target = bfd_get_target (ibfd);
1913
1914       obfd = bfd_openw (output_filename, output_target);
1915       if (obfd == NULL)
1916         RETURN_NONFATAL (output_filename);
1917
1918       copy_archive (ibfd, obfd, output_target);
1919     }
1920   else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
1921     {
1922       bfd *obfd;
1923     do_copy:
1924
1925       /* bfd_get_target does not return the correct value until
1926          bfd_check_format succeeds.  */
1927       if (output_target == NULL)
1928         output_target = bfd_get_target (ibfd);
1929
1930       obfd = bfd_openw (output_filename, output_target);
1931       if (obfd == NULL)
1932         RETURN_NONFATAL (output_filename);
1933
1934       if (! copy_object (ibfd, obfd))
1935         status = 1;
1936
1937       if (!bfd_close (obfd))
1938         RETURN_NONFATAL (output_filename);
1939
1940       if (!bfd_close (ibfd))
1941         RETURN_NONFATAL (input_filename);
1942
1943     }
1944   else
1945     {
1946       bfd_error_type obj_error = bfd_get_error ();
1947       bfd_error_type core_error;
1948
1949       if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
1950         {
1951           /* This probably can't happen..  */
1952           if (obj_error == bfd_error_file_ambiguously_recognized)
1953             free (obj_matching);
1954           goto do_copy;
1955         }
1956
1957       core_error = bfd_get_error ();
1958       /* Report the object error in preference to the core error.  */
1959       if (obj_error != core_error)
1960         bfd_set_error (obj_error);
1961
1962       bfd_nonfatal (input_filename);
1963
1964       if (obj_error == bfd_error_file_ambiguously_recognized)
1965         {
1966           list_matching_formats (obj_matching);
1967           free (obj_matching);
1968         }
1969       if (core_error == bfd_error_file_ambiguously_recognized)
1970         {
1971           list_matching_formats (core_matching);
1972           free (core_matching);
1973         }
1974
1975       status = 1;
1976     }
1977 }
1978
1979 /* Add a name to the section renaming list.  */
1980
1981 static void
1982 add_section_rename (const char * old_name, const char * new_name,
1983                     flagword flags)
1984 {
1985   section_rename * rename;
1986
1987   /* Check for conflicts first.  */
1988   for (rename = section_rename_list; rename != NULL; rename = rename->next)
1989     if (strcmp (rename->old_name, old_name) == 0)
1990       {
1991         /* Silently ignore duplicate definitions.  */
1992         if (strcmp (rename->new_name, new_name) == 0
1993             && rename->flags == flags)
1994           return;
1995
1996         fatal (_("Multiple renames of section %s"), old_name);
1997       }
1998
1999   rename = xmalloc (sizeof (* rename));
2000
2001   rename->old_name = old_name;
2002   rename->new_name = new_name;
2003   rename->flags    = flags;
2004   rename->next     = section_rename_list;
2005
2006   section_rename_list = rename;
2007 }
2008
2009 /* Check the section rename list for a new name of the input section
2010    ISECTION.  Return the new name if one is found.
2011    Also set RETURNED_FLAGS to the flags to be used for this section.  */
2012
2013 static const char *
2014 find_section_rename (bfd * ibfd ATTRIBUTE_UNUSED, sec_ptr isection,
2015                      flagword * returned_flags)
2016 {
2017   const char * old_name = bfd_section_name (ibfd, isection);
2018   section_rename * rename;
2019
2020   /* Default to using the flags of the input section.  */
2021   * returned_flags = bfd_get_section_flags (ibfd, isection);
2022
2023   for (rename = section_rename_list; rename != NULL; rename = rename->next)
2024     if (strcmp (rename->old_name, old_name) == 0)
2025       {
2026         if (rename->flags != (flagword) -1)
2027           * returned_flags = rename->flags;
2028
2029         return rename->new_name;
2030       }
2031
2032   return old_name;
2033 }
2034
2035 /* Once each of the sections is copied, we may still need to do some
2036    finalization work for private section headers.  Do that here.  */
2037
2038 static void
2039 setup_bfd_headers (bfd *ibfd, bfd *obfd)
2040 {
2041   const char *err;
2042
2043   /* Allow the BFD backend to copy any private data it understands
2044      from the input section to the output section.  */
2045   if (! bfd_copy_private_header_data (ibfd, obfd))
2046     {
2047       err = _("private header data");
2048       goto loser;
2049     }
2050
2051   /* All went well.  */
2052   return;
2053
2054 loser:
2055   non_fatal (_("%s: error in %s: %s"),
2056              bfd_get_filename (ibfd),
2057              err, bfd_errmsg (bfd_get_error ()));
2058   status = 1;
2059 }
2060
2061 /* Create a section in OBFD with the same
2062    name and attributes as ISECTION in IBFD.  */
2063
2064 static void
2065 setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2066 {
2067   bfd *obfd = obfdarg;
2068   struct section_list *p;
2069   sec_ptr osection;
2070   bfd_size_type size;
2071   bfd_vma vma;
2072   bfd_vma lma;
2073   flagword flags;
2074   const char *err;
2075   const char * name;
2076   char *prefix = NULL;
2077
2078   if (is_strip_section (ibfd, isection))
2079     return;
2080
2081   p = find_section_list (bfd_section_name (ibfd, isection), FALSE);
2082   if (p != NULL)
2083     p->used = TRUE;
2084
2085   /* Get the, possibly new, name of the output section.  */
2086   name = find_section_rename (ibfd, isection, & flags);
2087
2088   /* Prefix sections.  */
2089   if ((prefix_alloc_sections_string)
2090       && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
2091     prefix = prefix_alloc_sections_string;
2092   else if (prefix_sections_string)
2093     prefix = prefix_sections_string;
2094
2095   if (prefix)
2096     {
2097       char *n;
2098
2099       n = xmalloc (strlen (prefix) + strlen (name) + 1);
2100       strcpy (n, prefix);
2101       strcat (n, name);
2102       name = n;
2103     }
2104
2105   if (p != NULL && p->set_flags)
2106     flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
2107   else if (strip_symbols == STRIP_NONDEBUG && (flags & SEC_ALLOC) != 0)
2108     flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD);
2109
2110   osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
2111
2112   if (osection == NULL)
2113     {
2114       err = _("making");
2115       goto loser;
2116     }
2117
2118   if (strip_symbols == STRIP_NONDEBUG
2119       && obfd->xvec->flavour == bfd_target_elf_flavour
2120       && (flags & SEC_ALLOC) != 0
2121       && (p == NULL || !p->set_flags))
2122     elf_section_type (osection) = SHT_NOBITS;
2123
2124   size = bfd_section_size (ibfd, isection);
2125   if (copy_byte >= 0)
2126     size = (size + interleave - 1) / interleave;
2127   if (! bfd_set_section_size (obfd, osection, size))
2128     {
2129       err = _("size");
2130       goto loser;
2131     }
2132
2133   vma = bfd_section_vma (ibfd, isection);
2134   if (p != NULL && p->change_vma == CHANGE_MODIFY)
2135     vma += p->vma_val;
2136   else if (p != NULL && p->change_vma == CHANGE_SET)
2137     vma = p->vma_val;
2138   else
2139     vma += change_section_address;
2140
2141   if (! bfd_set_section_vma (obfd, osection, vma))
2142     {
2143       err = _("vma");
2144       goto loser;
2145     }
2146
2147   lma = isection->lma;
2148   if ((p != NULL) && p->change_lma != CHANGE_IGNORE)
2149     {
2150       if (p->change_lma == CHANGE_MODIFY)
2151         lma += p->lma_val;
2152       else if (p->change_lma == CHANGE_SET)
2153         lma = p->lma_val;
2154       else
2155         abort ();
2156     }
2157   else
2158     lma += change_section_address;
2159
2160   osection->lma = lma;
2161
2162   /* FIXME: This is probably not enough.  If we change the LMA we
2163      may have to recompute the header for the file as well.  */
2164   if (!bfd_set_section_alignment (obfd,
2165                                   osection,
2166                                   bfd_section_alignment (ibfd, isection)))
2167     {
2168       err = _("alignment");
2169       goto loser;
2170     }
2171
2172   /* Copy merge entity size.  */
2173   osection->entsize = isection->entsize;
2174
2175   /* This used to be mangle_section; we do here to avoid using
2176      bfd_get_section_by_name since some formats allow multiple
2177      sections with the same name.  */
2178   isection->output_section = osection;
2179   isection->output_offset = 0;
2180
2181   /* Allow the BFD backend to copy any private data it understands
2182      from the input section to the output section.  */
2183   if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
2184       && strip_symbols == STRIP_NONDEBUG)
2185     /* Do not copy the private data when creating an ELF format
2186        debug info file.  We do not want the program headers.  */
2187     ;
2188   else if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
2189     {
2190       err = _("private data");
2191       goto loser;
2192     }
2193
2194   /* All went well.  */
2195   return;
2196
2197 loser:
2198   non_fatal (_("%s: section `%s': error in %s: %s"),
2199              bfd_get_filename (ibfd),
2200              bfd_section_name (ibfd, isection),
2201              err, bfd_errmsg (bfd_get_error ()));
2202   status = 1;
2203 }
2204
2205 /* Copy the data of input section ISECTION of IBFD
2206    to an output section with the same name in OBFD.
2207    If stripping then don't copy any relocation info.  */
2208
2209 static void
2210 copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2211 {
2212   bfd *obfd = obfdarg;
2213   struct section_list *p;
2214   arelent **relpp;
2215   long relcount;
2216   sec_ptr osection;
2217   bfd_size_type size;
2218   long relsize;
2219   flagword flags;
2220
2221   /* If we have already failed earlier on,
2222      do not keep on generating complaints now.  */
2223   if (status != 0)
2224     return;
2225
2226   if (is_strip_section (ibfd, isection))
2227     return;
2228
2229   flags = bfd_get_section_flags (ibfd, isection);
2230   if ((flags & SEC_GROUP) != 0)
2231     return;
2232
2233   osection = isection->output_section;
2234   size = bfd_get_section_size (isection);
2235
2236   if (size == 0 || osection == 0)
2237     return;
2238
2239   p = find_section_list (bfd_get_section_name (ibfd, isection), FALSE);
2240
2241   /* Core files do not need to be relocated.  */
2242   if (bfd_get_format (obfd) == bfd_core)
2243     relsize = 0;
2244   else
2245     {
2246       relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2247
2248       if (relsize < 0)
2249         {
2250           /* Do not complain if the target does not support relocations.  */
2251           if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2252             relsize = 0;
2253           else
2254             RETURN_NONFATAL (bfd_get_filename (ibfd));
2255         }
2256     }
2257
2258   if (relsize == 0)
2259     bfd_set_reloc (obfd, osection, NULL, 0);
2260   else
2261     {
2262       relpp = xmalloc (relsize);
2263       relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
2264       if (relcount < 0)
2265         RETURN_NONFATAL (bfd_get_filename (ibfd));
2266
2267       if (strip_symbols == STRIP_ALL)
2268         {
2269           /* Remove relocations which are not in
2270              keep_strip_specific_list.  */
2271           arelent **temp_relpp;
2272           long temp_relcount = 0;
2273           long i;
2274
2275           temp_relpp = xmalloc (relsize);
2276           for (i = 0; i < relcount; i++)
2277             if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
2278                                      keep_specific_list))
2279               temp_relpp [temp_relcount++] = relpp [i];
2280           relcount = temp_relcount;
2281           free (relpp);
2282           relpp = temp_relpp;
2283         }
2284
2285       bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
2286       if (relcount == 0)
2287         free (relpp);
2288     }
2289
2290   if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
2291       && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
2292     {
2293       void *memhunk = xmalloc (size);
2294
2295       if (!bfd_get_section_contents (ibfd, isection, memhunk, 0, size))
2296         RETURN_NONFATAL (bfd_get_filename (ibfd));
2297
2298       if (copy_byte >= 0)
2299         {
2300           /* Keep only every `copy_byte'th byte in MEMHUNK.  */
2301           char *from = (char *) memhunk + copy_byte;
2302           char *to = memhunk;
2303           char *end = (char *) memhunk + size;
2304
2305           for (; from < end; from += interleave)
2306             *to++ = *from;
2307
2308           size = (size + interleave - 1 - copy_byte) / interleave;
2309           osection->lma /= interleave;
2310         }
2311
2312       if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2313         RETURN_NONFATAL (bfd_get_filename (obfd));
2314
2315       free (memhunk);
2316     }
2317   else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
2318     {
2319       void *memhunk = xmalloc (size);
2320
2321       /* We don't permit the user to turn off the SEC_HAS_CONTENTS
2322          flag--they can just remove the section entirely and add it
2323          back again.  However, we do permit them to turn on the
2324          SEC_HAS_CONTENTS flag, and take it to mean that the section
2325          contents should be zeroed out.  */
2326
2327       memset (memhunk, 0, size);
2328       if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2329         RETURN_NONFATAL (bfd_get_filename (obfd));
2330       free (memhunk);
2331     }
2332 }
2333
2334 /* Get all the sections.  This is used when --gap-fill or --pad-to is
2335    used.  */
2336
2337 static void
2338 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
2339 {
2340   asection ***secppp = secppparg;
2341
2342   **secppp = osection;
2343   ++(*secppp);
2344 }
2345
2346 /* Sort sections by VMA.  This is called via qsort, and is used when
2347    --gap-fill or --pad-to is used.  We force non loadable or empty
2348    sections to the front, where they are easier to ignore.  */
2349
2350 static int
2351 compare_section_lma (const void *arg1, const void *arg2)
2352 {
2353   const asection *const *sec1 = arg1;
2354   const asection *const *sec2 = arg2;
2355   flagword flags1, flags2;
2356
2357   /* Sort non loadable sections to the front.  */
2358   flags1 = (*sec1)->flags;
2359   flags2 = (*sec2)->flags;
2360   if ((flags1 & SEC_HAS_CONTENTS) == 0
2361       || (flags1 & SEC_LOAD) == 0)
2362     {
2363       if ((flags2 & SEC_HAS_CONTENTS) != 0
2364           && (flags2 & SEC_LOAD) != 0)
2365         return -1;
2366     }
2367   else
2368     {
2369       if ((flags2 & SEC_HAS_CONTENTS) == 0
2370           || (flags2 & SEC_LOAD) == 0)
2371         return 1;
2372     }
2373
2374   /* Sort sections by LMA.  */
2375   if ((*sec1)->lma > (*sec2)->lma)
2376     return 1;
2377   else if ((*sec1)->lma < (*sec2)->lma)
2378     return -1;
2379
2380   /* Sort sections with the same LMA by size.  */
2381   if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
2382     return 1;
2383   else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
2384     return -1;
2385
2386   return 0;
2387 }
2388
2389 /* Mark all the symbols which will be used in output relocations with
2390    the BSF_KEEP flag so that those symbols will not be stripped.
2391
2392    Ignore relocations which will not appear in the output file.  */
2393
2394 static void
2395 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
2396 {
2397   asymbol **symbols = symbolsarg;
2398   long relsize;
2399   arelent **relpp;
2400   long relcount, i;
2401
2402   /* Ignore an input section with no corresponding output section.  */
2403   if (isection->output_section == NULL)
2404     return;
2405
2406   relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2407   if (relsize < 0)
2408     {
2409       /* Do not complain if the target does not support relocations.  */
2410       if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2411         return;
2412       bfd_fatal (bfd_get_filename (ibfd));
2413     }
2414
2415   if (relsize == 0)
2416     return;
2417
2418   relpp = xmalloc (relsize);
2419   relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
2420   if (relcount < 0)
2421     bfd_fatal (bfd_get_filename (ibfd));
2422
2423   /* Examine each symbol used in a relocation.  If it's not one of the
2424      special bfd section symbols, then mark it with BSF_KEEP.  */
2425   for (i = 0; i < relcount; i++)
2426     {
2427       if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
2428           && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
2429           && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
2430         (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
2431     }
2432
2433   if (relpp != NULL)
2434     free (relpp);
2435 }
2436
2437 /* Write out debugging information.  */
2438
2439 static bfd_boolean
2440 write_debugging_info (bfd *obfd, void *dhandle,
2441                       long *symcountp ATTRIBUTE_UNUSED,
2442                       asymbol ***symppp ATTRIBUTE_UNUSED)
2443 {
2444   if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
2445     return write_ieee_debugging_info (obfd, dhandle);
2446
2447   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
2448       || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2449     {
2450       bfd_byte *syms, *strings;
2451       bfd_size_type symsize, stringsize;
2452       asection *stabsec, *stabstrsec;
2453       flagword flags;
2454
2455       if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
2456                                                     &symsize, &strings,
2457                                                     &stringsize))
2458         return FALSE;
2459
2460       flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
2461       stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
2462       stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
2463       if (stabsec == NULL
2464           || stabstrsec == NULL
2465           || ! bfd_set_section_size (obfd, stabsec, symsize)
2466           || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
2467           || ! bfd_set_section_alignment (obfd, stabsec, 2)
2468           || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
2469         {
2470           non_fatal (_("%s: can't create debugging section: %s"),
2471                      bfd_get_filename (obfd),
2472                      bfd_errmsg (bfd_get_error ()));
2473           return FALSE;
2474         }
2475
2476       /* We can get away with setting the section contents now because
2477          the next thing the caller is going to do is copy over the
2478          real sections.  We may someday have to split the contents
2479          setting out of this function.  */
2480       if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
2481           || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
2482                                          stringsize))
2483         {
2484           non_fatal (_("%s: can't set debugging section contents: %s"),
2485                      bfd_get_filename (obfd),
2486                      bfd_errmsg (bfd_get_error ()));
2487           return FALSE;
2488         }
2489
2490       return TRUE;
2491     }
2492
2493   non_fatal (_("%s: don't know how to write debugging information for %s"),
2494              bfd_get_filename (obfd), bfd_get_target (obfd));
2495   return FALSE;
2496 }
2497
2498 static int
2499 strip_main (int argc, char *argv[])
2500 {
2501   char *input_target = NULL;
2502   char *output_target = NULL;
2503   bfd_boolean show_version = FALSE;
2504   bfd_boolean formats_info = FALSE;
2505   int c;
2506   int i;
2507   struct section_list *p;
2508   char *output_file = NULL;
2509
2510   while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
2511                            strip_options, (int *) 0)) != EOF)
2512     {
2513       switch (c)
2514         {
2515         case 'I':
2516           input_target = optarg;
2517           break;
2518         case 'O':
2519           output_target = optarg;
2520           break;
2521         case 'F':
2522           input_target = output_target = optarg;
2523           break;
2524         case 'R':
2525           p = find_section_list (optarg, TRUE);
2526           p->remove = TRUE;
2527           sections_removed = TRUE;
2528           break;
2529         case 's':
2530           strip_symbols = STRIP_ALL;
2531           break;
2532         case 'S':
2533         case 'g':
2534         case 'd':       /* Historic BSD alias for -g.  Used by early NetBSD.  */
2535           strip_symbols = STRIP_DEBUG;
2536           break;
2537         case OPTION_STRIP_UNNEEDED:
2538           strip_symbols = STRIP_UNNEEDED;
2539           break;
2540         case 'K':
2541           add_specific_symbol (optarg, &keep_specific_list);
2542           break;
2543         case 'N':
2544           add_specific_symbol (optarg, &strip_specific_list);
2545           break;
2546         case 'o':
2547           output_file = optarg;
2548           break;
2549         case 'p':
2550           preserve_dates = TRUE;
2551           break;
2552         case 'x':
2553           discard_locals = LOCALS_ALL;
2554           break;
2555         case 'X':
2556           discard_locals = LOCALS_START_L;
2557           break;
2558         case 'v':
2559           verbose = TRUE;
2560           break;
2561         case 'V':
2562           show_version = TRUE;
2563           break;
2564         case OPTION_FORMATS_INFO:
2565           formats_info = TRUE;
2566           break;
2567         case OPTION_ONLY_KEEP_DEBUG:
2568           strip_symbols = STRIP_NONDEBUG;
2569           break;
2570         case OPTION_KEEP_FILE_SYMBOLS:
2571           keep_file_symbols = 1;
2572           break;
2573         case 0:
2574           /* We've been given a long option.  */
2575           break;
2576         case 'w':
2577           wildcard = TRUE;
2578           break;
2579         case 'H':
2580         case 'h':
2581           strip_usage (stdout, 0);
2582         default:
2583           strip_usage (stderr, 1);
2584         }
2585     }
2586
2587   if (formats_info)
2588     {
2589       display_info ();
2590       return 0;
2591     }
2592
2593   if (show_version)
2594     print_version ("strip");
2595
2596   /* Default is to strip all symbols.  */
2597   if (strip_symbols == STRIP_UNDEF
2598       && discard_locals == LOCALS_UNDEF
2599       && strip_specific_list == NULL)
2600     strip_symbols = STRIP_ALL;
2601
2602   if (output_target == NULL)
2603     output_target = input_target;
2604
2605   i = optind;
2606   if (i == argc
2607       || (output_file != NULL && (i + 1) < argc))
2608     strip_usage (stderr, 1);
2609
2610   for (; i < argc; i++)
2611     {
2612       int hold_status = status;
2613       struct stat statbuf;
2614       char *tmpname;
2615
2616       if (get_file_size (argv[i]) < 1)
2617         {
2618           status = 1;
2619           continue;
2620         }
2621
2622       if (preserve_dates)
2623         /* No need to check the return value of stat().
2624            It has already been checked in get_file_size().  */
2625         stat (argv[i], &statbuf);
2626
2627       if (output_file != NULL)
2628         tmpname = output_file;
2629       else
2630         tmpname = make_tempname (argv[i]);
2631
2632       status = 0;
2633       copy_file (argv[i], tmpname, input_target, output_target);
2634       if (status == 0)
2635         {
2636           if (preserve_dates)
2637             set_times (tmpname, &statbuf);
2638           if (output_file == NULL)
2639             smart_rename (tmpname, argv[i], preserve_dates);
2640           status = hold_status;
2641         }
2642       else
2643         unlink_if_ordinary (tmpname);
2644       if (output_file == NULL)
2645         free (tmpname);
2646     }
2647
2648   return status;
2649 }
2650
2651 static int
2652 copy_main (int argc, char *argv[])
2653 {
2654   char * binary_architecture = NULL;
2655   char *input_filename = NULL;
2656   char *output_filename = NULL;
2657   char *input_target = NULL;
2658   char *output_target = NULL;
2659   bfd_boolean show_version = FALSE;
2660   bfd_boolean change_warn = TRUE;
2661   bfd_boolean formats_info = FALSE;
2662   int c;
2663   struct section_list *p;
2664   struct stat statbuf;
2665
2666   while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
2667                            copy_options, (int *) 0)) != EOF)
2668     {
2669       switch (c)
2670         {
2671         case 'b':
2672           copy_byte = atoi (optarg);
2673           if (copy_byte < 0)
2674             fatal (_("byte number must be non-negative"));
2675           break;
2676
2677         case 'B':
2678           binary_architecture = optarg;
2679           break;
2680
2681         case 'i':
2682           interleave = atoi (optarg);
2683           if (interleave < 1)
2684             fatal (_("interleave must be positive"));
2685           break;
2686
2687         case 'I':
2688         case 's':               /* "source" - 'I' is preferred */
2689           input_target = optarg;
2690           break;
2691
2692         case 'O':
2693         case 'd':               /* "destination" - 'O' is preferred */
2694           output_target = optarg;
2695           break;
2696
2697         case 'F':
2698           input_target = output_target = optarg;
2699           break;
2700
2701         case 'j':
2702           p = find_section_list (optarg, TRUE);
2703           if (p->remove)
2704             fatal (_("%s both copied and removed"), optarg);
2705           p->copy = TRUE;
2706           sections_copied = TRUE;
2707           break;
2708
2709         case 'R':
2710           p = find_section_list (optarg, TRUE);
2711           if (p->copy)
2712             fatal (_("%s both copied and removed"), optarg);
2713           p->remove = TRUE;
2714           sections_removed = TRUE;
2715           break;
2716
2717         case 'S':
2718           strip_symbols = STRIP_ALL;
2719           break;
2720
2721         case 'g':
2722           strip_symbols = STRIP_DEBUG;
2723           break;
2724
2725         case OPTION_STRIP_UNNEEDED:
2726           strip_symbols = STRIP_UNNEEDED;
2727           break;
2728
2729         case OPTION_ONLY_KEEP_DEBUG:
2730           strip_symbols = STRIP_NONDEBUG;
2731           break;
2732
2733         case OPTION_KEEP_FILE_SYMBOLS:
2734           keep_file_symbols = 1;
2735           break;
2736
2737         case OPTION_ADD_GNU_DEBUGLINK:
2738           gnu_debuglink_filename = optarg;
2739           break;
2740
2741         case 'K':
2742           add_specific_symbol (optarg, &keep_specific_list);
2743           break;
2744
2745         case 'N':
2746           add_specific_symbol (optarg, &strip_specific_list);
2747           break;
2748
2749         case OPTION_STRIP_UNNEEDED_SYMBOL:
2750           add_specific_symbol (optarg, &strip_unneeded_list);
2751           break;
2752
2753         case 'L':
2754           add_specific_symbol (optarg, &localize_specific_list);
2755           break;
2756
2757         case OPTION_GLOBALIZE_SYMBOL:
2758           add_specific_symbol (optarg, &globalize_specific_list);
2759           break;
2760
2761         case 'G':
2762           add_specific_symbol (optarg, &keepglobal_specific_list);
2763           break;
2764
2765         case 'W':
2766           add_specific_symbol (optarg, &weaken_specific_list);
2767           break;
2768
2769         case 'p':
2770           preserve_dates = TRUE;
2771           break;
2772
2773         case 'w':
2774           wildcard = TRUE;
2775           break;
2776
2777         case 'x':
2778           discard_locals = LOCALS_ALL;
2779           break;
2780
2781         case 'X':
2782           discard_locals = LOCALS_START_L;
2783           break;
2784
2785         case 'v':
2786           verbose = TRUE;
2787           break;
2788
2789         case 'V':
2790           show_version = TRUE;
2791           break;
2792
2793         case OPTION_FORMATS_INFO:
2794           formats_info = TRUE;
2795           break;
2796
2797         case OPTION_WEAKEN:
2798           weaken = TRUE;
2799           break;
2800
2801         case OPTION_ADD_SECTION:
2802           {
2803             const char *s;
2804             off_t size;
2805             struct section_add *pa;
2806             int len;
2807             char *name;
2808             FILE *f;
2809
2810             s = strchr (optarg, '=');
2811
2812             if (s == NULL)
2813               fatal (_("bad format for %s"), "--add-section");
2814
2815             size = get_file_size (s + 1);
2816             if (size < 1)
2817               {
2818                 status = 1;
2819                 break;
2820               }
2821
2822             pa = xmalloc (sizeof (struct section_add));
2823
2824             len = s - optarg;
2825             name = xmalloc (len + 1);
2826             strncpy (name, optarg, len);
2827             name[len] = '\0';
2828             pa->name = name;
2829
2830             pa->filename = s + 1;
2831             pa->size = size;
2832             pa->contents = xmalloc (size);
2833
2834             f = fopen (pa->filename, FOPEN_RB);
2835
2836             if (f == NULL)
2837               fatal (_("cannot open: %s: %s"),
2838                      pa->filename, strerror (errno));
2839
2840             if (fread (pa->contents, 1, pa->size, f) == 0
2841                 || ferror (f))
2842               fatal (_("%s: fread failed"), pa->filename);
2843
2844             fclose (f);
2845
2846             pa->next = add_sections;
2847             add_sections = pa;
2848           }
2849           break;
2850
2851         case OPTION_CHANGE_START:
2852           change_start = parse_vma (optarg, "--change-start");
2853           break;
2854
2855         case OPTION_CHANGE_SECTION_ADDRESS:
2856         case OPTION_CHANGE_SECTION_LMA:
2857         case OPTION_CHANGE_SECTION_VMA:
2858           {
2859             const char *s;
2860             int len;
2861             char *name;
2862             char *option = NULL;
2863             bfd_vma val;
2864             enum change_action what = CHANGE_IGNORE;
2865
2866             switch (c)
2867               {
2868               case OPTION_CHANGE_SECTION_ADDRESS:
2869                 option = "--change-section-address";
2870                 break;
2871               case OPTION_CHANGE_SECTION_LMA:
2872                 option = "--change-section-lma";
2873                 break;
2874               case OPTION_CHANGE_SECTION_VMA:
2875                 option = "--change-section-vma";
2876                 break;
2877               }
2878
2879             s = strchr (optarg, '=');
2880             if (s == NULL)
2881               {
2882                 s = strchr (optarg, '+');
2883                 if (s == NULL)
2884                   {
2885                     s = strchr (optarg, '-');
2886                     if (s == NULL)
2887                       fatal (_("bad format for %s"), option);
2888                   }
2889               }
2890
2891             len = s - optarg;
2892             name = xmalloc (len + 1);
2893             strncpy (name, optarg, len);
2894             name[len] = '\0';
2895
2896             p = find_section_list (name, TRUE);
2897
2898             val = parse_vma (s + 1, option);
2899
2900             switch (*s)
2901               {
2902               case '=': what = CHANGE_SET; break;
2903               case '-': val  = - val; /* Drop through.  */
2904               case '+': what = CHANGE_MODIFY; break;
2905               }
2906
2907             switch (c)
2908               {
2909               case OPTION_CHANGE_SECTION_ADDRESS:
2910                 p->change_vma = what;
2911                 p->vma_val    = val;
2912                 /* Drop through.  */
2913
2914               case OPTION_CHANGE_SECTION_LMA:
2915                 p->change_lma = what;
2916                 p->lma_val    = val;
2917                 break;
2918
2919               case OPTION_CHANGE_SECTION_VMA:
2920                 p->change_vma = what;
2921                 p->vma_val    = val;
2922                 break;
2923               }
2924           }
2925           break;
2926
2927         case OPTION_CHANGE_ADDRESSES:
2928           change_section_address = parse_vma (optarg, "--change-addresses");
2929           change_start = change_section_address;
2930           break;
2931
2932         case OPTION_CHANGE_WARNINGS:
2933           change_warn = TRUE;
2934           break;
2935
2936         case OPTION_CHANGE_LEADING_CHAR:
2937           change_leading_char = TRUE;
2938           break;
2939
2940         case OPTION_DEBUGGING:
2941           convert_debugging = TRUE;
2942           break;
2943
2944         case OPTION_GAP_FILL:
2945           {
2946             bfd_vma gap_fill_vma;
2947
2948             gap_fill_vma = parse_vma (optarg, "--gap-fill");
2949             gap_fill = (bfd_byte) gap_fill_vma;
2950             if ((bfd_vma) gap_fill != gap_fill_vma)
2951               {
2952                 char buff[20];
2953
2954                 sprintf_vma (buff, gap_fill_vma);
2955
2956                 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
2957                            buff, gap_fill);
2958               }
2959             gap_fill_set = TRUE;
2960           }
2961           break;
2962
2963         case OPTION_NO_CHANGE_WARNINGS:
2964           change_warn = FALSE;
2965           break;
2966
2967         case OPTION_PAD_TO:
2968           pad_to = parse_vma (optarg, "--pad-to");
2969           pad_to_set = TRUE;
2970           break;
2971
2972         case OPTION_REMOVE_LEADING_CHAR:
2973           remove_leading_char = TRUE;
2974           break;
2975
2976         case OPTION_REDEFINE_SYM:
2977           {
2978             /* Push this redefinition onto redefine_symbol_list.  */
2979
2980             int len;
2981             const char *s;
2982             const char *nextarg;
2983             char *source, *target;
2984
2985             s = strchr (optarg, '=');
2986             if (s == NULL)
2987               fatal (_("bad format for %s"), "--redefine-sym");
2988
2989             len = s - optarg;
2990             source = xmalloc (len + 1);
2991             strncpy (source, optarg, len);
2992             source[len] = '\0';
2993
2994             nextarg = s + 1;
2995             len = strlen (nextarg);
2996             target = xmalloc (len + 1);
2997             strcpy (target, nextarg);
2998
2999             redefine_list_append ("--redefine-sym", source, target);
3000
3001             free (source);
3002             free (target);
3003           }
3004           break;
3005
3006         case OPTION_REDEFINE_SYMS:
3007           add_redefine_syms_file (optarg);
3008           break;
3009
3010         case OPTION_SET_SECTION_FLAGS:
3011           {
3012             const char *s;
3013             int len;
3014             char *name;
3015
3016             s = strchr (optarg, '=');
3017             if (s == NULL)
3018               fatal (_("bad format for %s"), "--set-section-flags");
3019
3020             len = s - optarg;
3021             name = xmalloc (len + 1);
3022             strncpy (name, optarg, len);
3023             name[len] = '\0';
3024
3025             p = find_section_list (name, TRUE);
3026
3027             p->set_flags = TRUE;
3028             p->flags = parse_flags (s + 1);
3029           }
3030           break;
3031
3032         case OPTION_RENAME_SECTION:
3033           {
3034             flagword flags;
3035             const char *eq, *fl;
3036             char *old_name;
3037             char *new_name;
3038             unsigned int len;
3039
3040             eq = strchr (optarg, '=');
3041             if (eq == NULL)
3042               fatal (_("bad format for %s"), "--rename-section");
3043
3044             len = eq - optarg;
3045             if (len == 0)
3046               fatal (_("bad format for %s"), "--rename-section");
3047
3048             old_name = xmalloc (len + 1);
3049             strncpy (old_name, optarg, len);
3050             old_name[len] = 0;
3051
3052             eq++;
3053             fl = strchr (eq, ',');
3054             if (fl)
3055               {
3056                 flags = parse_flags (fl + 1);
3057                 len = fl - eq;
3058               }
3059             else
3060               {
3061                 flags = -1;
3062                 len = strlen (eq);
3063               }
3064
3065             if (len == 0)
3066               fatal (_("bad format for %s"), "--rename-section");
3067
3068             new_name = xmalloc (len + 1);
3069             strncpy (new_name, eq, len);
3070             new_name[len] = 0;
3071
3072             add_section_rename (old_name, new_name, flags);
3073           }
3074           break;
3075
3076         case OPTION_SET_START:
3077           set_start = parse_vma (optarg, "--set-start");
3078           set_start_set = TRUE;
3079           break;
3080
3081         case OPTION_SREC_LEN:
3082           Chunk = parse_vma (optarg, "--srec-len");
3083           break;
3084
3085         case OPTION_SREC_FORCES3:
3086           S3Forced = TRUE;
3087           break;
3088
3089         case OPTION_STRIP_SYMBOLS:
3090           add_specific_symbols (optarg, &strip_specific_list);
3091           break;
3092
3093         case OPTION_STRIP_UNNEEDED_SYMBOLS:
3094           add_specific_symbols (optarg, &strip_unneeded_list);
3095           break;
3096
3097         case OPTION_KEEP_SYMBOLS:
3098           add_specific_symbols (optarg, &keep_specific_list);
3099           break;
3100
3101         case OPTION_LOCALIZE_HIDDEN:
3102           localize_hidden = TRUE;
3103           break;
3104
3105         case OPTION_LOCALIZE_SYMBOLS:
3106           add_specific_symbols (optarg, &localize_specific_list);
3107           break;
3108
3109         case OPTION_GLOBALIZE_SYMBOLS:
3110           add_specific_symbols (optarg, &globalize_specific_list);
3111           break;
3112
3113         case OPTION_KEEPGLOBAL_SYMBOLS:
3114           add_specific_symbols (optarg, &keepglobal_specific_list);
3115           break;
3116
3117         case OPTION_WEAKEN_SYMBOLS:
3118           add_specific_symbols (optarg, &weaken_specific_list);
3119           break;
3120
3121         case OPTION_ALT_MACH_CODE:
3122           use_alt_mach_code = strtoul (optarg, NULL, 0);
3123           if (use_alt_mach_code == 0)
3124             fatal (_("unable to parse alternative machine code"));
3125           break;
3126
3127         case OPTION_PREFIX_SYMBOLS:
3128           prefix_symbols_string = optarg;
3129           break;
3130
3131         case OPTION_PREFIX_SECTIONS:
3132           prefix_sections_string = optarg;
3133           break;
3134
3135         case OPTION_PREFIX_ALLOC_SECTIONS:
3136           prefix_alloc_sections_string = optarg;
3137           break;
3138
3139         case OPTION_READONLY_TEXT:
3140           bfd_flags_to_set |= WP_TEXT;
3141           bfd_flags_to_clear &= ~WP_TEXT;
3142           break;
3143
3144         case OPTION_WRITABLE_TEXT:
3145           bfd_flags_to_clear |= WP_TEXT;
3146           bfd_flags_to_set &= ~WP_TEXT;
3147           break;
3148
3149         case OPTION_PURE:
3150           bfd_flags_to_set |= D_PAGED;
3151           bfd_flags_to_clear &= ~D_PAGED;
3152           break;
3153
3154         case OPTION_IMPURE:
3155           bfd_flags_to_clear |= D_PAGED;
3156           bfd_flags_to_set &= ~D_PAGED;
3157           break;
3158
3159         case 0:
3160           /* We've been given a long option.  */
3161           break;
3162
3163         case 'H':
3164         case 'h':
3165           copy_usage (stdout, 0);
3166
3167         default:
3168           copy_usage (stderr, 1);
3169         }
3170     }
3171
3172   if (formats_info)
3173     {
3174       display_info ();
3175       return 0;
3176     }
3177
3178   if (show_version)
3179     print_version ("objcopy");
3180
3181   if (copy_byte >= interleave)
3182     fatal (_("byte number must be less than interleave"));
3183
3184   if (optind == argc || optind + 2 < argc)
3185     copy_usage (stderr, 1);
3186
3187   input_filename = argv[optind];
3188   if (optind + 1 < argc)
3189     output_filename = argv[optind + 1];
3190
3191   /* Default is to strip no symbols.  */
3192   if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
3193     strip_symbols = STRIP_NONE;
3194
3195   if (output_target == NULL)
3196     output_target = input_target;
3197
3198   if (binary_architecture != NULL)
3199     {
3200       if (input_target && strcmp (input_target, "binary") == 0)
3201         {
3202           const bfd_arch_info_type * temp_arch_info;
3203
3204           temp_arch_info = bfd_scan_arch (binary_architecture);
3205
3206           if (temp_arch_info != NULL)
3207             {
3208               bfd_external_binary_architecture = temp_arch_info->arch;
3209               bfd_external_machine             = temp_arch_info->mach;
3210             }
3211           else
3212             fatal (_("architecture %s unknown"), binary_architecture);
3213         }
3214       else
3215         {
3216           non_fatal (_("Warning: input target 'binary' required for binary architecture parameter."));
3217           non_fatal (_(" Argument %s ignored"), binary_architecture);
3218         }
3219     }
3220
3221   if (preserve_dates)
3222     if (stat (input_filename, & statbuf) < 0)
3223       fatal (_("warning: could not locate '%s'.  System error message: %s"),
3224              input_filename, strerror (errno));
3225
3226   /* If there is no destination file, or the source and destination files
3227      are the same, then create a temp and rename the result into the input.  */
3228   if (output_filename == NULL || strcmp (input_filename, output_filename) == 0)
3229     {
3230       char *tmpname = make_tempname (input_filename);
3231
3232       copy_file (input_filename, tmpname, input_target, output_target);
3233       if (status == 0)
3234         {
3235           if (preserve_dates)
3236             set_times (tmpname, &statbuf);
3237           smart_rename (tmpname, input_filename, preserve_dates);
3238         }
3239       else
3240         unlink (tmpname);
3241     }
3242   else
3243     {
3244       copy_file (input_filename, output_filename, input_target, output_target);
3245
3246       if (status == 0 && preserve_dates)
3247         set_times (output_filename, &statbuf);
3248       else if (status != 0)
3249         unlink_if_ordinary (output_filename);
3250     }
3251
3252   if (change_warn)
3253     {
3254       for (p = change_sections; p != NULL; p = p->next)
3255         {
3256           if (! p->used)
3257             {
3258               if (p->change_vma != CHANGE_IGNORE)
3259                 {
3260                   char buff [20];
3261
3262                   sprintf_vma (buff, p->vma_val);
3263
3264                   /* xgettext:c-format */
3265                   non_fatal (_("%s %s%c0x%s never used"),
3266                              "--change-section-vma",
3267                              p->name,
3268                              p->change_vma == CHANGE_SET ? '=' : '+',
3269                              buff);
3270                 }
3271
3272               if (p->change_lma != CHANGE_IGNORE)
3273                 {
3274                   char buff [20];
3275
3276                   sprintf_vma (buff, p->lma_val);
3277
3278                   /* xgettext:c-format */
3279                   non_fatal (_("%s %s%c0x%s never used"),
3280                              "--change-section-lma",
3281                              p->name,
3282                              p->change_lma == CHANGE_SET ? '=' : '+',
3283                              buff);
3284                 }
3285             }
3286         }
3287     }
3288
3289   return 0;
3290 }
3291
3292 int
3293 main (int argc, char *argv[])
3294 {
3295 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3296   setlocale (LC_MESSAGES, "");
3297 #endif
3298 #if defined (HAVE_SETLOCALE)
3299   setlocale (LC_CTYPE, "");
3300 #endif
3301   bindtextdomain (PACKAGE, LOCALEDIR);
3302   textdomain (PACKAGE);
3303
3304   program_name = argv[0];
3305   xmalloc_set_program_name (program_name);
3306
3307   START_PROGRESS (program_name, 0);
3308
3309   expandargv (&argc, &argv);
3310
3311   strip_symbols = STRIP_UNDEF;
3312   discard_locals = LOCALS_UNDEF;
3313
3314   bfd_init ();
3315   set_default_bfd_target ();
3316
3317   if (is_strip < 0)
3318     {
3319       int i = strlen (program_name);
3320 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3321       /* Drop the .exe suffix, if any.  */
3322       if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
3323         {
3324           i -= 4;
3325           program_name[i] = '\0';
3326         }
3327 #endif
3328       is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
3329     }
3330
3331   if (is_strip)
3332     strip_main (argc, argv);
3333   else
3334     copy_main (argc, argv);
3335
3336   END_PROGRESS (program_name);
3337
3338   return status;
3339 }