binutils/objcopy.c

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