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