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