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             {
1879               if (fwrite (contents, 1, size, f) != size)
1880                 fatal (_("error writing section contents to %s (error: %s)"),
1881                        pdump->filename,
1882                        strerror (errno));
1883             }
1884           else
1885             bfd_nonfatal_message (NULL, ibfd, sec,
1886                                   _("could not retrieve section contents"));
1887
1888           fclose (f);
1889           free (contents);
1890         }
1891     }
1892
1893   if (gnu_debuglink_filename != NULL)
1894     {
1895       /* PR 15125: Give a helpful warning message if
1896          the debuglink section already exists, and
1897          allow the rest of the copy to complete.  */
1898       if (bfd_get_section_by_name (obfd, ".gnu_debuglink"))
1899         {
1900           non_fatal (_("%s: debuglink section already exists"),
1901                      bfd_get_filename (obfd));
1902           gnu_debuglink_filename = NULL;
1903         }
1904       else
1905         {
1906           gnu_debuglink_section = bfd_create_gnu_debuglink_section
1907             (obfd, gnu_debuglink_filename);
1908
1909           if (gnu_debuglink_section == NULL)
1910             {
1911               bfd_nonfatal_message (NULL, obfd, NULL,
1912                                     _("cannot create debug link section `%s'"),
1913                                     gnu_debuglink_filename);
1914               return FALSE;
1915             }
1916
1917           /* Special processing for PE format files.  We
1918              have no way to distinguish PE from COFF here.  */
1919           if (bfd_get_flavour (obfd) == bfd_target_coff_flavour)
1920             {
1921               bfd_vma debuglink_vma;
1922               asection * highest_section;
1923               asection * sec;
1924
1925               /* The PE spec requires that all sections be adjacent and sorted
1926                  in ascending order of VMA.  It also specifies that debug
1927                  sections should be last.  This is despite the fact that debug
1928                  sections are not loaded into memory and so in theory have no
1929                  use for a VMA.
1930
1931                  This means that the debuglink section must be given a non-zero
1932                  VMA which makes it contiguous with other debug sections.  So
1933                  walk the current section list, find the section with the
1934                  highest VMA and start the debuglink section after that one.  */
1935               for (sec = obfd->sections, highest_section = NULL;
1936                    sec != NULL;
1937                    sec = sec->next)
1938                 if (sec->vma > 0
1939                     && (highest_section == NULL
1940                         || sec->vma > highest_section->vma))
1941                   highest_section = sec;
1942
1943               if (highest_section)
1944                 debuglink_vma = BFD_ALIGN (highest_section->vma
1945                                            + highest_section->size,
1946                                            /* FIXME: We ought to be using
1947                                               COFF_PAGE_SIZE here or maybe
1948                                               bfd_get_section_alignment() (if it
1949                                               was set) but since this is for PE
1950                                               and we know the required alignment
1951                                               it is easier just to hard code it.  */
1952                                            0x1000);
1953               else
1954                 /* Umm, not sure what to do in this case.  */
1955                 debuglink_vma = 0x1000;
1956
1957               bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma);
1958             }
1959         }
1960     }
1961
1962   if (bfd_count_sections (obfd) != 0
1963       && (gap_fill_set || pad_to_set))
1964     {
1965       asection **set;
1966       unsigned int c, i;
1967
1968       /* We must fill in gaps between the sections and/or we must pad
1969          the last section to a specified address.  We do this by
1970          grabbing a list of the sections, sorting them by VMA, and
1971          increasing the section sizes as required to fill the gaps.
1972          We write out the gap contents below.  */
1973
1974       c = bfd_count_sections (obfd);
1975       osections = (asection **) xmalloc (c * sizeof (asection *));
1976       set = osections;
1977       bfd_map_over_sections (obfd, get_sections, &set);
1978
1979       qsort (osections, c, sizeof (asection *), compare_section_lma);
1980
1981       gaps = (bfd_size_type *) xmalloc (c * sizeof (bfd_size_type));
1982       memset (gaps, 0, c * sizeof (bfd_size_type));
1983
1984       if (gap_fill_set)
1985         {
1986           for (i = 0; i < c - 1; i++)
1987             {
1988               flagword flags;
1989               bfd_size_type size;
1990               bfd_vma gap_start, gap_stop;
1991
1992               flags = bfd_get_section_flags (obfd, osections[i]);
1993               if ((flags & SEC_HAS_CONTENTS) == 0
1994                   || (flags & SEC_LOAD) == 0)
1995                 continue;
1996
1997               size = bfd_section_size (obfd, osections[i]);
1998               gap_start = bfd_section_lma (obfd, osections[i]) + size;
1999               gap_stop = bfd_section_lma (obfd, osections[i + 1]);
2000               if (gap_start < gap_stop)
2001                 {
2002                   if (! bfd_set_section_size (obfd, osections[i],
2003                                               size + (gap_stop - gap_start)))
2004                     {
2005                       bfd_nonfatal_message (NULL, obfd, osections[i],
2006                                             _("Can't fill gap after section"));
2007                       status = 1;
2008                       break;
2009                     }
2010                   gaps[i] = gap_stop - gap_start;
2011                   if (max_gap < gap_stop - gap_start)
2012                     max_gap = gap_stop - gap_start;
2013                 }
2014             }
2015         }
2016
2017       if (pad_to_set)
2018         {
2019           bfd_vma lma;
2020           bfd_size_type size;
2021
2022           lma = bfd_section_lma (obfd, osections[c - 1]);
2023           size = bfd_section_size (obfd, osections[c - 1]);
2024           if (lma + size < pad_to)
2025             {
2026               if (! bfd_set_section_size (obfd, osections[c - 1],
2027                                           pad_to - lma))
2028                 {
2029                   bfd_nonfatal_message (NULL, obfd, osections[c - 1],
2030                                         _("can't add padding"));
2031                   status = 1;
2032                 }
2033               else
2034                 {
2035                   gaps[c - 1] = pad_to - (lma + size);
2036                   if (max_gap < pad_to - (lma + size))
2037                     max_gap = pad_to - (lma + size);
2038                 }
2039             }
2040         }
2041     }
2042
2043   /* Symbol filtering must happen after the output sections
2044      have been created, but before their contents are set.  */
2045   dhandle = NULL;
2046   if (convert_debugging)
2047     dhandle = read_debugging_info (ibfd, isympp, symcount, FALSE);
2048
2049   if (strip_symbols == STRIP_DEBUG
2050       || strip_symbols == STRIP_ALL
2051       || strip_symbols == STRIP_UNNEEDED
2052       || strip_symbols == STRIP_NONDEBUG
2053       || strip_symbols == STRIP_DWO
2054       || strip_symbols == STRIP_NONDWO
2055       || discard_locals != LOCALS_UNDEF
2056       || localize_hidden
2057       || htab_elements (strip_specific_htab) != 0
2058       || htab_elements (keep_specific_htab) != 0
2059       || htab_elements (localize_specific_htab) != 0
2060       || htab_elements (globalize_specific_htab) != 0
2061       || htab_elements (keepglobal_specific_htab) != 0
2062       || htab_elements (weaken_specific_htab) != 0
2063       || prefix_symbols_string
2064       || sections_removed
2065       || sections_copied
2066       || convert_debugging
2067       || change_leading_char
2068       || remove_leading_char
2069       || redefine_sym_list
2070       || weaken)
2071     {
2072       /* Mark symbols used in output relocations so that they
2073          are kept, even if they are local labels or static symbols.
2074
2075          Note we iterate over the input sections examining their
2076          relocations since the relocations for the output sections
2077          haven't been set yet.  mark_symbols_used_in_relocations will
2078          ignore input sections which have no corresponding output
2079          section.  */
2080       if (strip_symbols != STRIP_ALL)
2081         bfd_map_over_sections (ibfd,
2082                                mark_symbols_used_in_relocations,
2083                                isympp);
2084       osympp = (asymbol **) xmalloc ((symcount + 1) * sizeof (asymbol *));
2085       symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
2086     }
2087
2088   if (convert_debugging && dhandle != NULL)
2089     {
2090       if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
2091         {
2092           status = 1;
2093           return FALSE;
2094         }
2095     }
2096
2097   bfd_set_symtab (obfd, osympp, symcount);
2098
2099   /* This has to happen before section positions are set.  */
2100   bfd_map_over_sections (ibfd, copy_relocations_in_section, obfd);
2101
2102   /* This has to happen after the symbol table has been set.  */
2103   bfd_map_over_sections (ibfd, copy_section, obfd);
2104
2105   if (add_sections != NULL)
2106     {
2107       struct section_add *padd;
2108
2109       for (padd = add_sections; padd != NULL; padd = padd->next)
2110         {
2111           if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
2112                                           0, padd->size))
2113             {
2114               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
2115               return FALSE;
2116             }
2117         }
2118     }
2119
2120   if (gnu_debuglink_filename != NULL)
2121     {
2122       if (! bfd_fill_in_gnu_debuglink_section
2123           (obfd, gnu_debuglink_section, gnu_debuglink_filename))
2124         {
2125           bfd_nonfatal_message (NULL, obfd, NULL,
2126                                 _("cannot fill debug link section `%s'"),
2127                                 gnu_debuglink_filename);
2128           return FALSE;
2129         }
2130     }
2131
2132   if (gap_fill_set || pad_to_set)
2133     {
2134       bfd_byte *buf;
2135       int c, i;
2136
2137       /* Fill in the gaps.  */
2138       if (max_gap > 8192)
2139         max_gap = 8192;
2140       buf = (bfd_byte *) xmalloc (max_gap);
2141       memset (buf, gap_fill, max_gap);
2142
2143       c = bfd_count_sections (obfd);
2144       for (i = 0; i < c; i++)
2145         {
2146           if (gaps[i] != 0)
2147             {
2148               bfd_size_type left;
2149               file_ptr off;
2150
2151               left = gaps[i];
2152               off = bfd_section_size (obfd, osections[i]) - left;
2153
2154               while (left > 0)
2155                 {
2156                   bfd_size_type now;
2157
2158                   if (left > 8192)
2159                     now = 8192;
2160                   else
2161                     now = left;
2162
2163                   if (! bfd_set_section_contents (obfd, osections[i], buf,
2164                                                   off, now))
2165                     {
2166                       bfd_nonfatal_message (NULL, obfd, osections[i], NULL);
2167                       return FALSE;
2168                     }
2169
2170                   left -= now;
2171                   off += now;
2172                 }
2173             }
2174         }
2175     }
2176
2177   /* Do not copy backend data if --extract-symbol is passed; anything
2178      that needs to look at the section contents will fail.  */
2179   if (extract_symbol)
2180     return TRUE;
2181
2182   /* Allow the BFD backend to copy any private data it understands
2183      from the input BFD to the output BFD.  This is done last to
2184      permit the routine to look at the filtered symbol table, which is
2185      important for the ECOFF code at least.  */
2186   if (! bfd_copy_private_bfd_data (ibfd, obfd))
2187     {
2188       bfd_nonfatal_message (NULL, obfd, NULL,
2189                             _("error copying private BFD data"));
2190       return FALSE;
2191     }
2192
2193   /* Switch to the alternate machine code.  We have to do this at the
2194      very end, because we only initialize the header when we create
2195      the first section.  */
2196   if (use_alt_mach_code != 0)
2197     {
2198       if (! bfd_alt_mach_code (obfd, use_alt_mach_code))
2199         {
2200           non_fatal (_("this target does not support %lu alternative machine codes"),
2201                      use_alt_mach_code);
2202           if (bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2203             {
2204               non_fatal (_("treating that number as an absolute e_machine value instead"));
2205               elf_elfheader (obfd)->e_machine = use_alt_mach_code;
2206             }
2207           else
2208             non_fatal (_("ignoring the alternative value"));
2209         }
2210     }
2211
2212   return TRUE;
2213 }
2214
2215 /* Read each archive element in turn from IBFD, copy the
2216    contents to temp file, and keep the temp file handle.
2217    If 'force_output_target' is TRUE then make sure that
2218    all elements in the new archive are of the type
2219    'output_target'.  */
2220
2221 static void
2222 copy_archive (bfd *ibfd, bfd *obfd, const char *output_target,
2223               bfd_boolean force_output_target,
2224               const bfd_arch_info_type *input_arch)
2225 {
2226   struct name_list
2227     {
2228       struct name_list *next;
2229       const char *name;
2230       bfd *obfd;
2231     } *list, *l;
2232   bfd **ptr = &obfd->archive_head;
2233   bfd *this_element;
2234   char *dir;
2235   const char *filename;
2236
2237   /* Make a temp directory to hold the contents.  */
2238   dir = make_tempdir (bfd_get_filename (obfd));
2239   if (dir == NULL)
2240       fatal (_("cannot create tempdir for archive copying (error: %s)"),
2241            strerror (errno));
2242
2243   if (strip_symbols == STRIP_ALL)
2244     obfd->has_armap = FALSE;
2245   else
2246     obfd->has_armap = ibfd->has_armap;
2247   obfd->is_thin_archive = ibfd->is_thin_archive;
2248
2249   if (deterministic)
2250     obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
2251
2252   list = NULL;
2253
2254   this_element = bfd_openr_next_archived_file (ibfd, NULL);
2255
2256   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
2257     {
2258       status = 1;
2259       bfd_nonfatal_message (NULL, obfd, NULL, NULL);
2260       return;
2261     }
2262
2263   while (!status && this_element != NULL)
2264     {
2265       char *output_name;
2266       bfd *output_bfd;
2267       bfd *last_element;
2268       struct stat buf;
2269       int stat_status = 0;
2270       bfd_boolean del = TRUE;
2271       bfd_boolean ok_object;
2272
2273       /* Create an output file for this member.  */
2274       output_name = concat (dir, "/",
2275                             bfd_get_filename (this_element), (char *) 0);
2276
2277       /* If the file already exists, make another temp dir.  */
2278       if (stat (output_name, &buf) >= 0)
2279         {
2280           output_name = make_tempdir (output_name);
2281           if (output_name == NULL)
2282             fatal (_("cannot create tempdir for archive copying (error: %s)"),
2283                    strerror (errno));
2284
2285           l = (struct name_list *) xmalloc (sizeof (struct name_list));
2286           l->name = output_name;
2287           l->next = list;
2288           l->obfd = NULL;
2289           list = l;
2290           output_name = concat (output_name, "/",
2291                                 bfd_get_filename (this_element), (char *) 0);
2292         }
2293
2294       if (preserve_dates)
2295         {
2296           stat_status = bfd_stat_arch_elt (this_element, &buf);
2297
2298           if (stat_status != 0)
2299             non_fatal (_("internal stat error on %s"),
2300                        bfd_get_filename (this_element));
2301         }
2302
2303       l = (struct name_list *) xmalloc (sizeof (struct name_list));
2304       l->name = output_name;
2305       l->next = list;
2306       l->obfd = NULL;
2307       list = l;
2308
2309       ok_object = bfd_check_format (this_element, bfd_object);
2310       if (!ok_object)
2311         bfd_nonfatal_message (NULL, this_element, NULL,
2312                               _("Unable to recognise the format of file"));
2313
2314       /* PR binutils/3110: Cope with archives
2315          containing multiple target types.  */
2316       if (force_output_target || !ok_object)
2317         output_bfd = bfd_openw (output_name, output_target);
2318       else
2319         output_bfd = bfd_openw (output_name, bfd_get_target (this_element));
2320
2321       if (output_bfd == NULL)
2322         {
2323           bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2324           status = 1;
2325           return;
2326         }
2327
2328       if (ok_object)
2329         {
2330           del = !copy_object (this_element, output_bfd, input_arch);
2331
2332           if (del && bfd_get_arch (this_element) == bfd_arch_unknown)
2333             /* Try again as an unknown object file.  */
2334             ok_object = FALSE;
2335           else if (!bfd_close (output_bfd))
2336             {
2337               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2338               /* Error in new object file. Don't change archive.  */
2339               status = 1;
2340             }
2341         }
2342
2343       if (!ok_object)
2344         {
2345           del = !copy_unknown_object (this_element, output_bfd);
2346           if (!bfd_close_all_done (output_bfd))
2347             {
2348               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2349               /* Error in new object file. Don't change archive.  */
2350               status = 1;
2351             }
2352         }
2353
2354       if (del)
2355         {
2356           unlink (output_name);
2357           status = 1;
2358         }
2359       else
2360         {
2361           if (preserve_dates && stat_status == 0)
2362             set_times (output_name, &buf);
2363
2364           /* Open the newly output file and attach to our list.  */
2365           output_bfd = bfd_openr (output_name, output_target);
2366
2367           l->obfd = output_bfd;
2368
2369           *ptr = output_bfd;
2370           ptr = &output_bfd->archive_next;
2371
2372           last_element = this_element;
2373
2374           this_element = bfd_openr_next_archived_file (ibfd, last_element);
2375
2376           bfd_close (last_element);
2377         }
2378     }
2379   *ptr = NULL;
2380
2381   filename = bfd_get_filename (obfd);
2382   if (!bfd_close (obfd))
2383     {
2384       status = 1;
2385       bfd_nonfatal_message (filename, NULL, NULL, NULL);
2386       return;
2387     }
2388
2389   filename = bfd_get_filename (ibfd);
2390   if (!bfd_close (ibfd))
2391     {
2392       status = 1;
2393       bfd_nonfatal_message (filename, NULL, NULL, NULL);
2394       return;
2395     }
2396
2397   /* Delete all the files that we opened.  */
2398   for (l = list; l != NULL; l = l->next)
2399     {
2400       if (l->obfd == NULL)
2401         rmdir (l->name);
2402       else
2403         {
2404           bfd_close (l->obfd);
2405           unlink (l->name);
2406         }
2407     }
2408   rmdir (dir);
2409 }
2410
2411 static void
2412 set_long_section_mode (bfd *output_bfd, bfd *input_bfd, enum long_section_name_handling style)
2413 {
2414   /* This is only relevant to Coff targets.  */
2415   if (bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
2416     {
2417       if (style == KEEP
2418           && bfd_get_flavour (input_bfd) == bfd_target_coff_flavour)
2419         style = bfd_coff_long_section_names (input_bfd) ? ENABLE : DISABLE;
2420       bfd_coff_set_long_section_names (output_bfd, style != DISABLE);
2421     }
2422 }
2423
2424 /* The top-level control.  */
2425
2426 static void
2427 copy_file (const char *input_filename, const char *output_filename,
2428            const char *input_target,   const char *output_target,
2429            const bfd_arch_info_type *input_arch)
2430 {
2431   bfd *ibfd;
2432   char **obj_matching;
2433   char **core_matching;
2434   off_t size = get_file_size (input_filename);
2435
2436   if (size < 1)
2437     {
2438       if (size == 0)
2439         non_fatal (_("error: the input file '%s' is empty"),
2440                    input_filename);
2441       status = 1;
2442       return;
2443     }
2444
2445   /* To allow us to do "strip *" without dying on the first
2446      non-object file, failures are nonfatal.  */
2447   ibfd = bfd_openr (input_filename, input_target);
2448   if (ibfd == NULL)
2449     {
2450       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2451       status = 1;
2452       return;
2453     }
2454
2455   switch (do_debug_sections)
2456     {
2457     case compress:
2458       ibfd->flags |= BFD_COMPRESS;
2459       break;
2460     case decompress:
2461       ibfd->flags |= BFD_DECOMPRESS;
2462       break;
2463     default:
2464       break;
2465     }
2466
2467   if (bfd_check_format (ibfd, bfd_archive))
2468     {
2469       bfd_boolean force_output_target;
2470       bfd *obfd;
2471
2472       /* bfd_get_target does not return the correct value until
2473          bfd_check_format succeeds.  */
2474       if (output_target == NULL)
2475         {
2476           output_target = bfd_get_target (ibfd);
2477           force_output_target = FALSE;
2478         }
2479       else
2480         force_output_target = TRUE;
2481
2482       obfd = bfd_openw (output_filename, output_target);
2483       if (obfd == NULL)
2484         {
2485           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2486           status = 1;
2487           return;
2488         }
2489       /* This is a no-op on non-Coff targets.  */
2490       set_long_section_mode (obfd, ibfd, long_section_names);
2491
2492       copy_archive (ibfd, obfd, output_target, force_output_target, input_arch);
2493     }
2494   else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
2495     {
2496       bfd *obfd;
2497     do_copy:
2498
2499       /* bfd_get_target does not return the correct value until
2500          bfd_check_format succeeds.  */
2501       if (output_target == NULL)
2502         output_target = bfd_get_target (ibfd);
2503
2504       obfd = bfd_openw (output_filename, output_target);
2505       if (obfd == NULL)
2506         {
2507           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2508           status = 1;
2509           return;
2510         }
2511       /* This is a no-op on non-Coff targets.  */
2512       set_long_section_mode (obfd, ibfd, long_section_names);
2513
2514       if (! copy_object (ibfd, obfd, input_arch))
2515         status = 1;
2516
2517       if (!bfd_close (obfd))
2518         {
2519           status = 1;
2520           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2521           return;
2522         }
2523
2524       if (!bfd_close (ibfd))
2525         {
2526           status = 1;
2527           bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2528           return;
2529         }
2530     }
2531   else
2532     {
2533       bfd_error_type obj_error = bfd_get_error ();
2534       bfd_error_type core_error;
2535
2536       if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
2537         {
2538           /* This probably can't happen..  */
2539           if (obj_error == bfd_error_file_ambiguously_recognized)
2540             free (obj_matching);
2541           goto do_copy;
2542         }
2543
2544       core_error = bfd_get_error ();
2545       /* Report the object error in preference to the core error.  */
2546       if (obj_error != core_error)
2547         bfd_set_error (obj_error);
2548
2549       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2550
2551       if (obj_error == bfd_error_file_ambiguously_recognized)
2552         {
2553           list_matching_formats (obj_matching);
2554           free (obj_matching);
2555         }
2556       if (core_error == bfd_error_file_ambiguously_recognized)
2557         {
2558           list_matching_formats (core_matching);
2559           free (core_matching);
2560         }
2561
2562       status = 1;
2563     }
2564 }
2565
2566 /* Add a name to the section renaming list.  */
2567
2568 static void
2569 add_section_rename (const char * old_name, const char * new_name,
2570                     flagword flags)
2571 {
2572   section_rename * srename;
2573
2574   /* Check for conflicts first.  */
2575   for (srename = section_rename_list; srename != NULL; srename = srename->next)
2576     if (strcmp (srename->old_name, old_name) == 0)
2577       {
2578         /* Silently ignore duplicate definitions.  */
2579         if (strcmp (srename->new_name, new_name) == 0
2580             && srename->flags == flags)
2581           return;
2582
2583         fatal (_("Multiple renames of section %s"), old_name);
2584       }
2585
2586   srename = (section_rename *) xmalloc (sizeof (* srename));
2587
2588   srename->old_name = old_name;
2589   srename->new_name = new_name;
2590   srename->flags    = flags;
2591   srename->next     = section_rename_list;
2592
2593   section_rename_list = srename;
2594 }
2595
2596 /* Check the section rename list for a new name of the input section
2597    ISECTION.  Return the new name if one is found.
2598    Also set RETURNED_FLAGS to the flags to be used for this section.  */
2599
2600 static const char *
2601 find_section_rename (bfd * ibfd ATTRIBUTE_UNUSED, sec_ptr isection,
2602                      flagword * returned_flags)
2603 {
2604   const char * old_name = bfd_section_name (ibfd, isection);
2605   section_rename * srename;
2606
2607   /* Default to using the flags of the input section.  */
2608   * returned_flags = bfd_get_section_flags (ibfd, isection);
2609
2610   for (srename = section_rename_list; srename != NULL; srename = srename->next)
2611     if (strcmp (srename->old_name, old_name) == 0)
2612       {
2613         if (srename->flags != (flagword) -1)
2614           * returned_flags = srename->flags;
2615
2616         return srename->new_name;
2617       }
2618
2619   return old_name;
2620 }
2621
2622 /* Once each of the sections is copied, we may still need to do some
2623    finalization work for private section headers.  Do that here.  */
2624
2625 static void
2626 setup_bfd_headers (bfd *ibfd, bfd *obfd)
2627 {
2628   /* Allow the BFD backend to copy any private data it understands
2629      from the input section to the output section.  */
2630   if (! bfd_copy_private_header_data (ibfd, obfd))
2631     {
2632       status = 1;
2633       bfd_nonfatal_message (NULL, ibfd, NULL,
2634                             _("error in private header data"));
2635       return;
2636     }
2637
2638   /* All went well.  */
2639   return;
2640 }
2641
2642 /* Create a section in OBFD with the same
2643    name and attributes as ISECTION in IBFD.  */
2644
2645 static void
2646 setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2647 {
2648   bfd *obfd = (bfd *) obfdarg;
2649   struct section_list *p;
2650   sec_ptr osection;
2651   bfd_size_type size;
2652   bfd_vma vma;
2653   bfd_vma lma;
2654   flagword flags;
2655   const char *err;
2656   const char * name;
2657   char *prefix = NULL;
2658   bfd_boolean make_nobits;
2659
2660   if (is_strip_section (ibfd, isection))
2661     return;
2662
2663   /* Get the, possibly new, name of the output section.  */
2664   name = find_section_rename (ibfd, isection, & flags);
2665
2666   /* Prefix sections.  */
2667   if ((prefix_alloc_sections_string)
2668       && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
2669     prefix = prefix_alloc_sections_string;
2670   else if (prefix_sections_string)
2671     prefix = prefix_sections_string;
2672
2673   if (prefix)
2674     {
2675       char *n;
2676
2677       n = (char *) xmalloc (strlen (prefix) + strlen (name) + 1);
2678       strcpy (n, prefix);
2679       strcat (n, name);
2680       name = n;
2681     }
2682
2683   make_nobits = FALSE;
2684
2685   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
2686                          SECTION_CONTEXT_SET_FLAGS);
2687   if (p != NULL)
2688     flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
2689   else if (strip_symbols == STRIP_NONDEBUG
2690            && (flags & (SEC_ALLOC | SEC_GROUP)) != 0
2691            && !(ibfd->xvec->flavour == bfd_target_elf_flavour
2692                 && elf_section_type (isection) == SHT_NOTE))
2693     {
2694       flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
2695       if (obfd->xvec->flavour == bfd_target_elf_flavour)
2696         {
2697           make_nobits = TRUE;
2698
2699           /* Twiddle the input section flags so that it seems to
2700              elf.c:copy_private_bfd_data that section flags have not
2701              changed between input and output sections.  This hack
2702              prevents wholesale rewriting of the program headers.  */
2703           isection->flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
2704         }
2705     }
2706
2707   osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
2708
2709   if (osection == NULL)
2710     {
2711       err = _("failed to create output section");
2712       goto loser;
2713     }
2714
2715   if (make_nobits)
2716     elf_section_type (osection) = SHT_NOBITS;
2717
2718   size = bfd_section_size (ibfd, isection);
2719   if (copy_byte >= 0)
2720     size = (size + interleave - 1) / interleave * copy_width;
2721   else if (extract_symbol)
2722     size = 0;
2723   if (! bfd_set_section_size (obfd, osection, size))
2724     {
2725       err = _("failed to set size");
2726       goto loser;
2727     }
2728
2729   vma = bfd_section_vma (ibfd, isection);
2730   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
2731                          SECTION_CONTEXT_ALTER_VMA | SECTION_CONTEXT_SET_VMA);
2732   if (p != NULL)
2733     {
2734       if (p->context & SECTION_CONTEXT_SET_VMA)
2735         vma = p->vma_val;
2736       else
2737         vma += p->vma_val;
2738     }
2739   else
2740     vma += change_section_address;
2741
2742   if (! bfd_set_section_vma (obfd, osection, vma))
2743     {
2744       err = _("failed to set vma");
2745       goto loser;
2746     }
2747
2748   lma = isection->lma;
2749   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
2750                          SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_SET_LMA);
2751   if (p != NULL)
2752     {
2753       if (p->context & SECTION_CONTEXT_ALTER_LMA)
2754         lma += p->lma_val;
2755       else
2756         lma = p->lma_val;
2757     }
2758   else
2759     lma += change_section_address;
2760
2761   osection->lma = lma;
2762
2763   /* FIXME: This is probably not enough.  If we change the LMA we
2764      may have to recompute the header for the file as well.  */
2765   if (!bfd_set_section_alignment (obfd,
2766                                   osection,
2767                                   bfd_section_alignment (ibfd, isection)))
2768     {
2769       err = _("failed to set alignment");
2770       goto loser;
2771     }
2772
2773   /* Copy merge entity size.  */
2774   osection->entsize = isection->entsize;
2775
2776   /* This used to be mangle_section; we do here to avoid using
2777      bfd_get_section_by_name since some formats allow multiple
2778      sections with the same name.  */
2779   isection->output_section = osection;
2780   isection->output_offset = 0;
2781
2782   /* Do not copy backend data if --extract-symbol is passed; anything
2783      that needs to look at the section contents will fail.  */
2784   if (extract_symbol)
2785     return;
2786
2787   if ((isection->flags & SEC_GROUP) != 0)
2788     {
2789       asymbol *gsym = group_signature (isection);
2790
2791       if (gsym != NULL)
2792         {
2793           gsym->flags |= BSF_KEEP;
2794           if (ibfd->xvec->flavour == bfd_target_elf_flavour)
2795             elf_group_id (isection) = gsym;
2796         }
2797     }
2798
2799   /* Allow the BFD backend to copy any private data it understands
2800      from the input section to the output section.  */
2801   if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
2802     {
2803       err = _("failed to copy private data");
2804       goto loser;
2805     }
2806
2807   /* All went well.  */
2808   return;
2809
2810 loser:
2811   status = 1;
2812   bfd_nonfatal_message (NULL, obfd, osection, err);
2813 }
2814
2815 /* Return TRUE if input section ISECTION should be skipped.  */
2816
2817 static bfd_boolean
2818 skip_section (bfd *ibfd, sec_ptr isection)
2819 {
2820   sec_ptr osection;
2821   bfd_size_type size;
2822   flagword flags;
2823
2824   /* If we have already failed earlier on,
2825      do not keep on generating complaints now.  */
2826   if (status != 0)
2827     return TRUE;
2828
2829   if (extract_symbol)
2830     return TRUE;
2831
2832   if (is_strip_section (ibfd, isection))
2833     return TRUE;
2834
2835   flags = bfd_get_section_flags (ibfd, isection);
2836   if ((flags & SEC_GROUP) != 0)
2837     return TRUE;
2838
2839   osection = isection->output_section;
2840   size = bfd_get_section_size (isection);
2841
2842   if (size == 0 || osection == 0)
2843     return TRUE;
2844
2845   return FALSE;
2846 }
2847
2848 /* Copy relocations in input section ISECTION of IBFD to an output
2849    section with the same name in OBFDARG.  If stripping then don't
2850    copy any relocation info.  */
2851
2852 static void
2853 copy_relocations_in_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2854 {
2855   bfd *obfd = (bfd *) obfdarg;
2856   long relsize;
2857   arelent **relpp;
2858   long relcount;
2859   sec_ptr osection;
2860
2861   if (skip_section (ibfd, isection))
2862     return;
2863
2864   osection = isection->output_section;
2865
2866   /* Core files and DWO files do not need to be relocated.  */
2867   if (bfd_get_format (obfd) == bfd_core || strip_symbols == STRIP_NONDWO)
2868     relsize = 0;
2869   else
2870     {
2871       relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2872
2873       if (relsize < 0)
2874         {
2875           /* Do not complain if the target does not support relocations.  */
2876           if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2877             relsize = 0;
2878           else
2879             {
2880               status = 1;
2881               bfd_nonfatal_message (NULL, ibfd, isection, NULL);
2882               return;
2883             }
2884         }
2885     }
2886
2887   if (relsize == 0)
2888     {
2889       bfd_set_reloc (obfd, osection, NULL, 0);
2890       osection->flags &= ~SEC_RELOC;
2891     }
2892   else
2893     {
2894       relpp = (arelent **) xmalloc (relsize);
2895       relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
2896       if (relcount < 0)
2897         {
2898           status = 1;
2899           bfd_nonfatal_message (NULL, ibfd, isection,
2900                                 _("relocation count is negative"));
2901           return;
2902         }
2903
2904       if (strip_symbols == STRIP_ALL)
2905         {
2906           /* Remove relocations which are not in
2907              keep_strip_specific_list.  */
2908           arelent **temp_relpp;
2909           long temp_relcount = 0;
2910           long i;
2911
2912           temp_relpp = (arelent **) xmalloc (relsize);
2913           for (i = 0; i < relcount; i++)
2914             if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
2915                                      keep_specific_htab))
2916               temp_relpp [temp_relcount++] = relpp [i];
2917           relcount = temp_relcount;
2918           free (relpp);
2919           relpp = temp_relpp;
2920         }
2921
2922       bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
2923       if (relcount == 0)
2924         {
2925           osection->flags &= ~SEC_RELOC;
2926           free (relpp);
2927         }
2928     }
2929 }
2930
2931 /* Copy the data of input section ISECTION of IBFD
2932    to an output section with the same name in OBFD.  */
2933
2934 static void
2935 copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2936 {
2937   bfd *obfd = (bfd *) obfdarg;
2938   struct section_list *p;
2939   sec_ptr osection;
2940   bfd_size_type size;
2941
2942   if (skip_section (ibfd, isection))
2943     return;
2944
2945   osection = isection->output_section;
2946   size = bfd_get_section_size (isection);
2947
2948   if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
2949       && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
2950     {
2951       bfd_byte *memhunk = NULL;
2952
2953       if (!bfd_get_full_section_contents (ibfd, isection, &memhunk))
2954         {
2955           status = 1;
2956           bfd_nonfatal_message (NULL, ibfd, isection, NULL);
2957           return;
2958         }
2959
2960       if (reverse_bytes)
2961         {
2962           /* We don't handle leftover bytes (too many possible behaviors,
2963              and we don't know what the user wants).  The section length
2964              must be a multiple of the number of bytes to swap.  */
2965           if ((size % reverse_bytes) == 0)
2966             {
2967               unsigned long i, j;
2968               bfd_byte b;
2969
2970               for (i = 0; i < size; i += reverse_bytes)
2971                 for (j = 0; j < (unsigned long)(reverse_bytes / 2); j++)
2972                   {
2973                     bfd_byte *m = (bfd_byte *) memhunk;
2974
2975                     b = m[i + j];
2976                     m[i + j] = m[(i + reverse_bytes) - (j + 1)];
2977                     m[(i + reverse_bytes) - (j + 1)] = b;
2978                   }
2979             }
2980           else
2981             /* User must pad the section up in order to do this.  */
2982             fatal (_("cannot reverse bytes: length of section %s must be evenly divisible by %d"),
2983                    bfd_section_name (ibfd, isection), reverse_bytes);
2984         }
2985
2986       if (copy_byte >= 0)
2987         {
2988           /* Keep only every `copy_byte'th byte in MEMHUNK.  */
2989           char *from = (char *) memhunk + copy_byte;
2990           char *to = (char *) memhunk;
2991           char *end = (char *) memhunk + size;
2992           int i;
2993
2994           for (; from < end; from += interleave)
2995             for (i = 0; i < copy_width; i++)
2996               {
2997                 if (&from[i] >= end)
2998                   break;
2999                 *to++ = from[i];
3000               }
3001
3002           size = (size + interleave - 1 - copy_byte) / interleave * copy_width;
3003           osection->lma /= interleave;
3004         }
3005
3006       if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
3007         {
3008           status = 1;
3009           bfd_nonfatal_message (NULL, obfd, osection, NULL);
3010           return;
3011         }
3012       free (memhunk);
3013     }
3014   else if ((p = find_section_list (bfd_get_section_name (ibfd, isection),
3015                                    FALSE, SECTION_CONTEXT_SET_FLAGS)) != NULL
3016            && (p->flags & SEC_HAS_CONTENTS) != 0)
3017     {
3018       void *memhunk = xmalloc (size);
3019
3020       /* We don't permit the user to turn off the SEC_HAS_CONTENTS
3021          flag--they can just remove the section entirely and add it
3022          back again.  However, we do permit them to turn on the
3023          SEC_HAS_CONTENTS flag, and take it to mean that the section
3024          contents should be zeroed out.  */
3025
3026       memset (memhunk, 0, size);
3027       if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
3028         {
3029           status = 1;
3030           bfd_nonfatal_message (NULL, obfd, osection, NULL);
3031           return;
3032         }
3033       free (memhunk);
3034     }
3035 }
3036
3037 /* Get all the sections.  This is used when --gap-fill or --pad-to is
3038    used.  */
3039
3040 static void
3041 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
3042 {
3043   asection ***secppp = (asection ***) secppparg;
3044
3045   **secppp = osection;
3046   ++(*secppp);
3047 }
3048
3049 /* Sort sections by VMA.  This is called via qsort, and is used when
3050    --gap-fill or --pad-to is used.  We force non loadable or empty
3051    sections to the front, where they are easier to ignore.  */
3052
3053 static int
3054 compare_section_lma (const void *arg1, const void *arg2)
3055 {
3056   const asection *const *sec1 = (const asection * const *) arg1;
3057   const asection *const *sec2 = (const asection * const *) arg2;
3058   flagword flags1, flags2;
3059
3060   /* Sort non loadable sections to the front.  */
3061   flags1 = (*sec1)->flags;
3062   flags2 = (*sec2)->flags;
3063   if ((flags1 & SEC_HAS_CONTENTS) == 0
3064       || (flags1 & SEC_LOAD) == 0)
3065     {
3066       if ((flags2 & SEC_HAS_CONTENTS) != 0
3067           && (flags2 & SEC_LOAD) != 0)
3068         return -1;
3069     }
3070   else
3071     {
3072       if ((flags2 & SEC_HAS_CONTENTS) == 0
3073           || (flags2 & SEC_LOAD) == 0)
3074         return 1;
3075     }
3076
3077   /* Sort sections by LMA.  */
3078   if ((*sec1)->lma > (*sec2)->lma)
3079     return 1;
3080   else if ((*sec1)->lma < (*sec2)->lma)
3081     return -1;
3082
3083   /* Sort sections with the same LMA by size.  */
3084   if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
3085     return 1;
3086   else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
3087     return -1;
3088
3089   return 0;
3090 }
3091
3092 /* Mark all the symbols which will be used in output relocations with
3093    the BSF_KEEP flag so that those symbols will not be stripped.
3094
3095    Ignore relocations which will not appear in the output file.  */
3096
3097 static void
3098 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
3099 {
3100   asymbol **symbols = (asymbol **) symbolsarg;
3101   long relsize;
3102   arelent **relpp;
3103   long relcount, i;
3104
3105   /* Ignore an input section with no corresponding output section.  */
3106   if (isection->output_section == NULL)
3107     return;
3108
3109   relsize = bfd_get_reloc_upper_bound (ibfd, isection);
3110   if (relsize < 0)
3111     {
3112       /* Do not complain if the target does not support relocations.  */
3113       if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
3114         return;
3115       bfd_fatal (bfd_get_filename (ibfd));
3116     }
3117
3118   if (relsize == 0)
3119     return;
3120
3121   relpp = (arelent **) xmalloc (relsize);
3122   relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
3123   if (relcount < 0)
3124     bfd_fatal (bfd_get_filename (ibfd));
3125
3126   /* Examine each symbol used in a relocation.  If it's not one of the
3127      special bfd section symbols, then mark it with BSF_KEEP.  */
3128   for (i = 0; i < relcount; i++)
3129     {
3130       if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
3131           && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
3132           && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
3133         (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
3134     }
3135
3136   if (relpp != NULL)
3137     free (relpp);
3138 }
3139
3140 /* Write out debugging information.  */
3141
3142 static bfd_boolean
3143 write_debugging_info (bfd *obfd, void *dhandle,
3144                       long *symcountp ATTRIBUTE_UNUSED,
3145                       asymbol ***symppp ATTRIBUTE_UNUSED)
3146 {
3147   if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
3148     return write_ieee_debugging_info (obfd, dhandle);
3149
3150   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
3151       || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
3152     {
3153       bfd_byte *syms, *strings;
3154       bfd_size_type symsize, stringsize;
3155       asection *stabsec, *stabstrsec;
3156       flagword flags;
3157
3158       if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
3159                                                     &symsize, &strings,
3160                                                     &stringsize))
3161         return FALSE;
3162
3163       flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
3164       stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
3165       stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
3166       if (stabsec == NULL
3167           || stabstrsec == NULL
3168           || ! bfd_set_section_size (obfd, stabsec, symsize)
3169           || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
3170           || ! bfd_set_section_alignment (obfd, stabsec, 2)
3171           || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
3172         {
3173           bfd_nonfatal_message (NULL, obfd, NULL,
3174                                 _("can't create debugging section"));
3175           return FALSE;
3176         }
3177
3178       /* We can get away with setting the section contents now because
3179          the next thing the caller is going to do is copy over the
3180          real sections.  We may someday have to split the contents
3181          setting out of this function.  */
3182       if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
3183           || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
3184                                          stringsize))
3185         {
3186           bfd_nonfatal_message (NULL, obfd, NULL,
3187                                 _("can't set debugging section contents"));
3188           return FALSE;
3189         }
3190
3191       return TRUE;
3192     }
3193
3194   bfd_nonfatal_message (NULL, obfd, NULL,
3195                         _("don't know how to write debugging information for %s"),
3196              bfd_get_target (obfd));
3197   return FALSE;
3198 }
3199
3200 /* If neither -D nor -U was specified explicitly,
3201    then use the configured default.  */
3202 static void
3203 default_deterministic (void)
3204 {
3205   if (deterministic < 0)
3206     deterministic = DEFAULT_AR_DETERMINISTIC;
3207 }
3208
3209 static int
3210 strip_main (int argc, char *argv[])
3211 {
3212   char *input_target = NULL;
3213   char *output_target = NULL;
3214   bfd_boolean show_version = FALSE;
3215   bfd_boolean formats_info = FALSE;
3216   int c;
3217   int i;
3218   char *output_file = NULL;
3219
3220   while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
3221                            strip_options, (int *) 0)) != EOF)
3222     {
3223       switch (c)
3224         {
3225         case 'I':
3226           input_target = optarg;
3227           break;
3228         case 'O':
3229           output_target = optarg;
3230           break;
3231         case 'F':
3232           input_target = output_target = optarg;
3233           break;
3234         case 'R':
3235           find_section_list (optarg, TRUE, SECTION_CONTEXT_REMOVE);
3236           sections_removed = TRUE;
3237           break;
3238         case 's':
3239           strip_symbols = STRIP_ALL;
3240           break;
3241         case 'S':
3242         case 'g':
3243         case 'd':       /* Historic BSD alias for -g.  Used by early NetBSD.  */
3244           strip_symbols = STRIP_DEBUG;
3245           break;
3246         case OPTION_STRIP_DWO:
3247           strip_symbols = STRIP_DWO;
3248           break;
3249         case OPTION_STRIP_UNNEEDED:
3250           strip_symbols = STRIP_UNNEEDED;
3251           break;
3252         case 'K':
3253           add_specific_symbol (optarg, keep_specific_htab);
3254           break;
3255         case 'N':
3256           add_specific_symbol (optarg, strip_specific_htab);
3257           break;
3258         case 'o':
3259           output_file = optarg;
3260           break;
3261         case 'p':
3262           preserve_dates = TRUE;
3263           break;
3264         case 'D':
3265           deterministic = TRUE;
3266           break;
3267         case 'U':
3268           deterministic = FALSE;
3269           break;
3270         case 'x':
3271           discard_locals = LOCALS_ALL;
3272           break;
3273         case 'X':
3274           discard_locals = LOCALS_START_L;
3275           break;
3276         case 'v':
3277           verbose = TRUE;
3278           break;
3279         case 'V':
3280           show_version = TRUE;
3281           break;
3282         case OPTION_FORMATS_INFO:
3283           formats_info = TRUE;
3284           break;
3285         case OPTION_ONLY_KEEP_DEBUG:
3286           strip_symbols = STRIP_NONDEBUG;
3287           break;
3288         case OPTION_KEEP_FILE_SYMBOLS:
3289           keep_file_symbols = 1;
3290           break;
3291         case 0:
3292           /* We've been given a long option.  */
3293           break;
3294         case 'w':
3295           wildcard = TRUE;
3296           break;
3297         case 'H':
3298         case 'h':
3299           strip_usage (stdout, 0);
3300         default:
3301           strip_usage (stderr, 1);
3302         }
3303     }
3304
3305   if (formats_info)
3306     {
3307       display_info ();
3308       return 0;
3309     }
3310
3311   if (show_version)
3312     print_version ("strip");
3313
3314   default_deterministic ();
3315
3316   /* Default is to strip all symbols.  */
3317   if (strip_symbols == STRIP_UNDEF
3318       && discard_locals == LOCALS_UNDEF
3319       && htab_elements (strip_specific_htab) == 0)
3320     strip_symbols = STRIP_ALL;
3321
3322   if (output_target == NULL)
3323     output_target = input_target;
3324
3325   i = optind;
3326   if (i == argc
3327       || (output_file != NULL && (i + 1) < argc))
3328     strip_usage (stderr, 1);
3329
3330   for (; i < argc; i++)
3331     {
3332       int hold_status = status;
3333       struct stat statbuf;
3334       char *tmpname;
3335
3336       if (get_file_size (argv[i]) < 1)
3337         {
3338           status = 1;
3339           continue;
3340         }
3341
3342       if (preserve_dates)
3343         /* No need to check the return value of stat().
3344            It has already been checked in get_file_size().  */
3345         stat (argv[i], &statbuf);
3346
3347       if (output_file == NULL
3348           || filename_cmp (argv[i], output_file) == 0)
3349         tmpname = make_tempname (argv[i]);
3350       else
3351         tmpname = output_file;
3352
3353       if (tmpname == NULL)
3354         {
3355           bfd_nonfatal_message (argv[i], NULL, NULL,
3356                                 _("could not create temporary file to hold stripped copy"));
3357           status = 1;
3358           continue;
3359         }
3360
3361       status = 0;
3362       copy_file (argv[i], tmpname, input_target, output_target, NULL);
3363       if (status == 0)
3364         {
3365           if (preserve_dates)
3366             set_times (tmpname, &statbuf);
3367           if (output_file != tmpname)
3368             status = (smart_rename (tmpname,
3369                                     output_file ? output_file : argv[i],
3370                                     preserve_dates) != 0);
3371           if (status == 0)
3372             status = hold_status;
3373         }
3374       else
3375         unlink_if_ordinary (tmpname);
3376       if (output_file != tmpname)
3377         free (tmpname);
3378     }
3379
3380   return status;
3381 }
3382
3383 /* Set up PE subsystem.  */
3384
3385 static void
3386 set_pe_subsystem (const char *s)
3387 {
3388   const char *version, *subsystem;
3389   size_t i;
3390   static const struct
3391     {
3392       const char *name;
3393       const char set_def;
3394       const short value;
3395     }
3396   v[] =
3397     {
3398       { "native", 0, IMAGE_SUBSYSTEM_NATIVE },
3399       { "windows", 0, IMAGE_SUBSYSTEM_WINDOWS_GUI },
3400       { "console", 0, IMAGE_SUBSYSTEM_WINDOWS_CUI },
3401       { "posix", 0, IMAGE_SUBSYSTEM_POSIX_CUI },
3402       { "wince", 0, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI },
3403       { "efi-app", 1, IMAGE_SUBSYSTEM_EFI_APPLICATION },
3404       { "efi-bsd", 1, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER },
3405       { "efi-rtd", 1, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER },
3406       { "sal-rtd", 1, IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER },
3407       { "xbox", 0, IMAGE_SUBSYSTEM_XBOX }
3408     };
3409   short value;
3410   char *copy;
3411   int set_def = -1;
3412
3413   /* Check for the presence of a version number.  */
3414   version = strchr (s, ':');
3415   if (version == NULL)
3416     subsystem = s;
3417   else
3418     {
3419       int len = version - s;
3420       copy = xstrdup (s);
3421       subsystem = copy;
3422       copy[len] = '\0';
3423       version = copy + 1 + len;
3424       pe_major_subsystem_version = strtoul (version, &copy, 0);
3425       if (*copy == '.')
3426         pe_minor_subsystem_version = strtoul (copy + 1, &copy, 0);
3427       if (*copy != '\0')
3428         non_fatal (_("%s: bad version in PE subsystem"), s);
3429     }
3430
3431   /* Check for numeric subsystem.  */
3432   value = (short) strtol (subsystem, &copy, 0);
3433   if (*copy == '\0')
3434     {
3435       for (i = 0; i < ARRAY_SIZE (v); i++)
3436         if (v[i].value == value)
3437           {
3438             pe_subsystem = value;
3439             set_def = v[i].set_def;
3440             break;
3441           }
3442     }
3443   else
3444     {
3445       /* Search for subsystem by name.  */
3446       for (i = 0; i < ARRAY_SIZE (v); i++)
3447         if (strcmp (subsystem, v[i].name) == 0)
3448           {
3449             pe_subsystem = v[i].value;
3450             set_def = v[i].set_def;
3451             break;
3452           }
3453     }
3454
3455   switch (set_def)
3456     {
3457     case -1:
3458       fatal (_("unknown PE subsystem: %s"), s);
3459       break;
3460     case 0:
3461       break;
3462     default:
3463       if (pe_file_alignment == (bfd_vma) -1)
3464         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
3465       if (pe_section_alignment == (bfd_vma) -1)
3466         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
3467       break;
3468     }
3469   if (s != subsystem)
3470     free ((char *) subsystem);
3471 }
3472
3473 /* Convert EFI target to PEI target.  */
3474
3475 static void
3476 convert_efi_target (char *efi)
3477 {
3478   efi[0] = 'p';
3479   efi[1] = 'e';
3480   efi[2] = 'i';
3481
3482   if (strcmp (efi + 4, "ia32") == 0)
3483     {
3484       /* Change ia32 to i386.  */
3485       efi[5]= '3';
3486       efi[6]= '8';
3487       efi[7]= '6';
3488     }
3489   else if (strcmp (efi + 4, "x86_64") == 0)
3490     {
3491       /* Change x86_64 to x86-64.  */
3492       efi[7] = '-';
3493     }
3494 }
3495
3496 static int
3497 copy_main (int argc, char *argv[])
3498 {
3499   char *input_filename = NULL;
3500   char *output_filename = NULL;
3501   char *tmpname;
3502   char *input_target = NULL;
3503   char *output_target = NULL;
3504   bfd_boolean show_version = FALSE;
3505   bfd_boolean change_warn = TRUE;
3506   bfd_boolean formats_info = FALSE;
3507   int c;
3508   struct stat statbuf;
3509   const bfd_arch_info_type *input_arch = NULL;
3510
3511   while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
3512                            copy_options, (int *) 0)) != EOF)
3513     {
3514       switch (c)
3515         {
3516         case 'b':
3517           copy_byte = atoi (optarg);
3518           if (copy_byte < 0)
3519             fatal (_("byte number must be non-negative"));
3520           break;
3521
3522         case 'B':
3523           input_arch = bfd_scan_arch (optarg);
3524           if (input_arch == NULL)
3525             fatal (_("architecture %s unknown"), optarg);
3526           break;
3527
3528         case 'i':
3529           if (optarg)
3530             {
3531               interleave = atoi (optarg);
3532               if (interleave < 1)
3533                 fatal (_("interleave must be positive"));
3534             }
3535           else
3536             interleave = 4;
3537           break;
3538
3539         case OPTION_INTERLEAVE_WIDTH:
3540           copy_width = atoi (optarg);
3541           if (copy_width < 1)
3542             fatal(_("interleave width must be positive"));
3543           break;
3544
3545         case 'I':
3546         case 's':               /* "source" - 'I' is preferred */
3547           input_target = optarg;
3548           break;
3549
3550         case 'O':
3551         case 'd':               /* "destination" - 'O' is preferred */
3552           output_target = optarg;
3553           break;
3554
3555         case 'F':
3556           input_target = output_target = optarg;
3557           break;
3558
3559         case 'j':
3560           find_section_list (optarg, TRUE, SECTION_CONTEXT_COPY);
3561           sections_copied = TRUE;
3562           break;
3563
3564         case 'R':
3565           find_section_list (optarg, TRUE, SECTION_CONTEXT_REMOVE);
3566           sections_removed = TRUE;
3567           break;
3568
3569         case 'S':
3570           strip_symbols = STRIP_ALL;
3571           break;
3572
3573         case 'g':
3574           strip_symbols = STRIP_DEBUG;
3575           break;
3576
3577         case OPTION_STRIP_DWO:
3578           strip_symbols = STRIP_DWO;
3579           break;
3580
3581         case OPTION_STRIP_UNNEEDED:
3582           strip_symbols = STRIP_UNNEEDED;
3583           break;
3584
3585         case OPTION_ONLY_KEEP_DEBUG:
3586           strip_symbols = STRIP_NONDEBUG;
3587           break;
3588
3589         case OPTION_KEEP_FILE_SYMBOLS:
3590           keep_file_symbols = 1;
3591           break;
3592
3593         case OPTION_ADD_GNU_DEBUGLINK:
3594           long_section_names = ENABLE ;
3595           gnu_debuglink_filename = optarg;
3596           break;
3597
3598         case 'K':
3599           add_specific_symbol (optarg, keep_specific_htab);
3600           break;
3601
3602         case 'N':
3603           add_specific_symbol (optarg, strip_specific_htab);
3604           break;
3605
3606         case OPTION_STRIP_UNNEEDED_SYMBOL:
3607           add_specific_symbol (optarg, strip_unneeded_htab);
3608           break;
3609
3610         case 'L':
3611           add_specific_symbol (optarg, localize_specific_htab);
3612           break;
3613
3614         case OPTION_GLOBALIZE_SYMBOL:
3615           add_specific_symbol (optarg, globalize_specific_htab);
3616           break;
3617
3618         case 'G':
3619           add_specific_symbol (optarg, keepglobal_specific_htab);
3620           break;
3621
3622         case 'W':
3623           add_specific_symbol (optarg, weaken_specific_htab);
3624           break;
3625
3626         case 'p':
3627           preserve_dates = TRUE;
3628           break;
3629
3630         case 'D':
3631           deterministic = TRUE;
3632           break;
3633
3634         case 'U':
3635           deterministic = FALSE;
3636           break;
3637
3638         case 'w':
3639           wildcard = TRUE;
3640           break;
3641
3642         case 'x':
3643           discard_locals = LOCALS_ALL;
3644           break;
3645
3646         case 'X':
3647           discard_locals = LOCALS_START_L;
3648           break;
3649
3650         case 'v':
3651           verbose = TRUE;
3652           break;
3653
3654         case 'V':
3655           show_version = TRUE;
3656           break;
3657
3658         case OPTION_FORMATS_INFO:
3659           formats_info = TRUE;
3660           break;
3661
3662         case OPTION_WEAKEN:
3663           weaken = TRUE;
3664           break;
3665
3666         case OPTION_ADD_SECTION:
3667           {
3668             const char *s;
3669             size_t off, alloc;
3670             struct section_add *pa;
3671             FILE *f;
3672
3673             s = strchr (optarg, '=');
3674
3675             if (s == NULL)
3676               fatal (_("bad format for %s"), "--add-section");
3677
3678             pa = (struct section_add *) xmalloc (sizeof (struct section_add));
3679             pa->name = xstrndup (optarg, s - optarg);
3680             pa->filename = s + 1;
3681
3682             /* We don't use get_file_size so that we can do
3683                  --add-section .note.GNU_stack=/dev/null
3684                get_file_size doesn't work on /dev/null.  */
3685
3686             f = fopen (pa->filename, FOPEN_RB);
3687             if (f == NULL)
3688               fatal (_("cannot open: %s: %s"),
3689                      pa->filename, strerror (errno));
3690
3691             off = 0;
3692             alloc = 4096;
3693             pa->contents = (bfd_byte *) xmalloc (alloc);
3694             while (!feof (f))
3695               {
3696                 off_t got;
3697
3698                 if (off == alloc)
3699                   {
3700                     alloc <<= 1;
3701                     pa->contents = (bfd_byte *) xrealloc (pa->contents, alloc);
3702                   }
3703
3704                 got = fread (pa->contents + off, 1, alloc - off, f);
3705                 if (ferror (f))
3706                   fatal (_("%s: fread failed"), pa->filename);
3707
3708                 off += got;
3709               }
3710
3711             pa->size = off;
3712
3713             fclose (f);
3714
3715             pa->next = add_sections;
3716             add_sections = pa;
3717           }
3718           break;
3719
3720         case OPTION_DUMP_SECTION:
3721           {
3722             const char *s;
3723             struct section_add *pa;
3724
3725             s = strchr (optarg, '=');
3726
3727             if (s == NULL)
3728               fatal (_("bad format for %s"), "--dump-section");
3729
3730             pa = (struct section_add *) xmalloc (sizeof * pa);
3731             pa->name = xstrndup (optarg, s - optarg);
3732             pa->filename = s + 1;
3733             pa->next = dump_sections;
3734             pa->contents = NULL;
3735             dump_sections = pa;
3736           }
3737           break;
3738
3739         case OPTION_CHANGE_START:
3740           change_start = parse_vma (optarg, "--change-start");
3741           break;
3742
3743         case OPTION_CHANGE_SECTION_ADDRESS:
3744         case OPTION_CHANGE_SECTION_LMA:
3745         case OPTION_CHANGE_SECTION_VMA:
3746           {
3747             struct section_list * p;
3748             unsigned int context = 0;
3749             const char *s;
3750             int len;
3751             char *name;
3752             char *option = NULL;
3753             bfd_vma val;
3754
3755             switch (c)
3756               {
3757               case OPTION_CHANGE_SECTION_ADDRESS:
3758                 option = "--change-section-address";
3759                 context = SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_ALTER_VMA;
3760                 break;
3761               case OPTION_CHANGE_SECTION_LMA:
3762                 option = "--change-section-lma";
3763                 context = SECTION_CONTEXT_ALTER_LMA;
3764                 break;
3765               case OPTION_CHANGE_SECTION_VMA:
3766                 option = "--change-section-vma";
3767                 context = SECTION_CONTEXT_ALTER_VMA;
3768                 break;
3769               }
3770
3771             s = strchr (optarg, '=');
3772             if (s == NULL)
3773               {
3774                 s = strchr (optarg, '+');
3775                 if (s == NULL)
3776                   {
3777                     s = strchr (optarg, '-');
3778                     if (s == NULL)
3779                       fatal (_("bad format for %s"), option);
3780                   }
3781               }
3782             else
3783               {
3784                 /* Correct the context.  */
3785                 switch (c)
3786                   {
3787                   case OPTION_CHANGE_SECTION_ADDRESS:
3788                     context = SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_SET_VMA;
3789                     break;
3790                   case OPTION_CHANGE_SECTION_LMA:
3791                     context = SECTION_CONTEXT_SET_LMA;
3792                     break;
3793                   case OPTION_CHANGE_SECTION_VMA:
3794                     context = SECTION_CONTEXT_SET_VMA;
3795                     break;
3796                   }
3797               }
3798
3799             len = s - optarg;
3800             name = (char *) xmalloc (len + 1);
3801             strncpy (name, optarg, len);
3802             name[len] = '\0';
3803
3804             p = find_section_list (name, TRUE, context);
3805
3806             val = parse_vma (s + 1, option);
3807             if (*s == '-')
3808               val = - val;
3809
3810             switch (c)
3811               {
3812               case OPTION_CHANGE_SECTION_ADDRESS:
3813                 p->vma_val = val;
3814                 /* Drop through.  */
3815
3816               case OPTION_CHANGE_SECTION_LMA:
3817                 p->lma_val = val;
3818                 break;
3819
3820               case OPTION_CHANGE_SECTION_VMA:
3821                 p->vma_val = val;
3822                 break;
3823               }
3824           }
3825           break;
3826
3827         case OPTION_CHANGE_ADDRESSES:
3828           change_section_address = parse_vma (optarg, "--change-addresses");
3829           change_start = change_section_address;
3830           break;
3831
3832         case OPTION_CHANGE_WARNINGS:
3833           change_warn = TRUE;
3834           break;
3835
3836         case OPTION_CHANGE_LEADING_CHAR:
3837           change_leading_char = TRUE;
3838           break;
3839
3840         case OPTION_COMPRESS_DEBUG_SECTIONS:
3841           do_debug_sections = compress;
3842           break;
3843
3844         case OPTION_DEBUGGING:
3845           convert_debugging = TRUE;
3846           break;
3847
3848         case OPTION_DECOMPRESS_DEBUG_SECTIONS:
3849           do_debug_sections = decompress;
3850           break;
3851
3852         case OPTION_GAP_FILL:
3853           {
3854             bfd_vma gap_fill_vma;
3855
3856             gap_fill_vma = parse_vma (optarg, "--gap-fill");
3857             gap_fill = (bfd_byte) gap_fill_vma;
3858             if ((bfd_vma) gap_fill != gap_fill_vma)
3859               {
3860                 char buff[20];
3861
3862                 sprintf_vma (buff, gap_fill_vma);
3863
3864                 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
3865                            buff, gap_fill);
3866               }
3867             gap_fill_set = TRUE;
3868           }
3869           break;
3870
3871         case OPTION_NO_CHANGE_WARNINGS:
3872           change_warn = FALSE;
3873           break;
3874
3875         case OPTION_PAD_TO:
3876           pad_to = parse_vma (optarg, "--pad-to");
3877           pad_to_set = TRUE;
3878           break;
3879
3880         case OPTION_REMOVE_LEADING_CHAR:
3881           remove_leading_char = TRUE;
3882           break;
3883
3884         case OPTION_REDEFINE_SYM:
3885           {
3886             /* Push this redefinition onto redefine_symbol_list.  */
3887
3888             int len;
3889             const char *s;
3890             const char *nextarg;
3891             char *source, *target;
3892
3893             s = strchr (optarg, '=');
3894             if (s == NULL)
3895               fatal (_("bad format for %s"), "--redefine-sym");
3896
3897             len = s - optarg;
3898             source = (char *) xmalloc (len + 1);
3899             strncpy (source, optarg, len);
3900             source[len] = '\0';
3901
3902             nextarg = s + 1;
3903             len = strlen (nextarg);
3904             target = (char *) xmalloc (len + 1);
3905             strcpy (target, nextarg);
3906
3907             redefine_list_append ("--redefine-sym", source, target);
3908
3909             free (source);
3910             free (target);
3911           }
3912           break;
3913
3914         case OPTION_REDEFINE_SYMS:
3915           add_redefine_syms_file (optarg);
3916           break;
3917
3918         case OPTION_SET_SECTION_FLAGS:
3919           {
3920             struct section_list *p;
3921             const char *s;
3922             int len;
3923             char *name;
3924
3925             s = strchr (optarg, '=');
3926             if (s == NULL)
3927               fatal (_("bad format for %s"), "--set-section-flags");
3928
3929             len = s - optarg;
3930             name = (char *) xmalloc (len + 1);
3931             strncpy (name, optarg, len);
3932             name[len] = '\0';
3933
3934             p = find_section_list (name, TRUE, SECTION_CONTEXT_SET_FLAGS);
3935
3936             p->flags = parse_flags (s + 1);
3937           }
3938           break;
3939
3940         case OPTION_RENAME_SECTION:
3941           {
3942             flagword flags;
3943             const char *eq, *fl;
3944             char *old_name;
3945             char *new_name;
3946             unsigned int len;
3947
3948             eq = strchr (optarg, '=');
3949             if (eq == NULL)
3950               fatal (_("bad format for %s"), "--rename-section");
3951
3952             len = eq - optarg;
3953             if (len == 0)
3954               fatal (_("bad format for %s"), "--rename-section");
3955
3956             old_name = (char *) xmalloc (len + 1);
3957             strncpy (old_name, optarg, len);
3958             old_name[len] = 0;
3959
3960             eq++;
3961             fl = strchr (eq, ',');
3962             if (fl)
3963               {
3964                 flags = parse_flags (fl + 1);
3965                 len = fl - eq;
3966               }
3967             else
3968               {
3969                 flags = -1;
3970                 len = strlen (eq);
3971               }
3972
3973             if (len == 0)
3974               fatal (_("bad format for %s"), "--rename-section");
3975
3976             new_name = (char *) xmalloc (len + 1);
3977             strncpy (new_name, eq, len);
3978             new_name[len] = 0;
3979
3980             add_section_rename (old_name, new_name, flags);
3981           }
3982           break;
3983
3984         case OPTION_SET_START:
3985           set_start = parse_vma (optarg, "--set-start");
3986           set_start_set = TRUE;
3987           break;
3988
3989         case OPTION_SREC_LEN:
3990           Chunk = parse_vma (optarg, "--srec-len");
3991           break;
3992
3993         case OPTION_SREC_FORCES3:
3994           S3Forced = TRUE;
3995           break;
3996
3997         case OPTION_STRIP_SYMBOLS:
3998           add_specific_symbols (optarg, strip_specific_htab);
3999           break;
4000
4001         case OPTION_STRIP_UNNEEDED_SYMBOLS:
4002           add_specific_symbols (optarg, strip_unneeded_htab);
4003           break;
4004
4005         case OPTION_KEEP_SYMBOLS:
4006           add_specific_symbols (optarg, keep_specific_htab);
4007           break;
4008
4009         case OPTION_LOCALIZE_HIDDEN:
4010           localize_hidden = TRUE;
4011           break;
4012
4013         case OPTION_LOCALIZE_SYMBOLS:
4014           add_specific_symbols (optarg, localize_specific_htab);
4015           break;
4016
4017         case OPTION_LONG_SECTION_NAMES:
4018           if (!strcmp ("enable", optarg))
4019             long_section_names = ENABLE;
4020           else if (!strcmp ("disable", optarg))
4021             long_section_names = DISABLE;
4022           else if (!strcmp ("keep", optarg))
4023             long_section_names = KEEP;
4024           else
4025             fatal (_("unknown long section names option '%s'"), optarg);
4026           break;
4027
4028         case OPTION_GLOBALIZE_SYMBOLS:
4029           add_specific_symbols (optarg, globalize_specific_htab);
4030           break;
4031
4032         case OPTION_KEEPGLOBAL_SYMBOLS:
4033           add_specific_symbols (optarg, keepglobal_specific_htab);
4034           break;
4035
4036         case OPTION_WEAKEN_SYMBOLS:
4037           add_specific_symbols (optarg, weaken_specific_htab);
4038           break;
4039
4040         case OPTION_ALT_MACH_CODE:
4041           use_alt_mach_code = strtoul (optarg, NULL, 0);
4042           if (use_alt_mach_code == 0)
4043             fatal (_("unable to parse alternative machine code"));
4044           break;
4045
4046         case OPTION_PREFIX_SYMBOLS:
4047           prefix_symbols_string = optarg;
4048           break;
4049
4050         case OPTION_PREFIX_SECTIONS:
4051           prefix_sections_string = optarg;
4052           break;
4053
4054         case OPTION_PREFIX_ALLOC_SECTIONS:
4055           prefix_alloc_sections_string = optarg;
4056           break;
4057
4058         case OPTION_READONLY_TEXT:
4059           bfd_flags_to_set |= WP_TEXT;
4060           bfd_flags_to_clear &= ~WP_TEXT;
4061           break;
4062
4063         case OPTION_WRITABLE_TEXT:
4064           bfd_flags_to_clear |= WP_TEXT;
4065           bfd_flags_to_set &= ~WP_TEXT;
4066           break;
4067
4068         case OPTION_PURE:
4069           bfd_flags_to_set |= D_PAGED;
4070           bfd_flags_to_clear &= ~D_PAGED;
4071           break;
4072
4073         case OPTION_IMPURE:
4074           bfd_flags_to_clear |= D_PAGED;
4075           bfd_flags_to_set &= ~D_PAGED;
4076           break;
4077
4078         case OPTION_EXTRACT_DWO:
4079           strip_symbols = STRIP_NONDWO;
4080           break;
4081
4082         case OPTION_EXTRACT_SYMBOL:
4083           extract_symbol = TRUE;
4084           break;
4085
4086         case OPTION_REVERSE_BYTES:
4087           {
4088             int prev = reverse_bytes;
4089
4090             reverse_bytes = atoi (optarg);
4091             if ((reverse_bytes <= 0) || ((reverse_bytes % 2) != 0))
4092               fatal (_("number of bytes to reverse must be positive and even"));
4093
4094             if (prev && prev != reverse_bytes)
4095               non_fatal (_("Warning: ignoring previous --reverse-bytes value of %d"),
4096                          prev);
4097             break;
4098           }
4099
4100         case OPTION_FILE_ALIGNMENT:
4101           pe_file_alignment = parse_vma (optarg, "--file-alignment");
4102           break;
4103
4104         case OPTION_HEAP:
4105             {
4106               char *end;
4107               pe_heap_reserve = strtoul (optarg, &end, 0);
4108               if (end == optarg
4109                   || (*end != '.' && *end != '\0'))
4110                 non_fatal (_("%s: invalid reserve value for --heap"),
4111                            optarg);
4112               else if (*end != '\0')
4113                 {
4114                   pe_heap_commit = strtoul (end + 1, &end, 0);
4115                   if (*end != '\0')
4116                     non_fatal (_("%s: invalid commit value for --heap"),
4117                                optarg);
4118                 }
4119             }
4120           break;
4121
4122         case OPTION_IMAGE_BASE:
4123           pe_image_base = parse_vma (optarg, "--image-base");
4124           break;
4125
4126         case OPTION_SECTION_ALIGNMENT:
4127           pe_section_alignment = parse_vma (optarg,
4128                                             "--section-alignment");
4129           break;
4130
4131         case OPTION_SUBSYSTEM:
4132           set_pe_subsystem (optarg);
4133           break;
4134
4135         case OPTION_STACK:
4136             {
4137               char *end;
4138               pe_stack_reserve = strtoul (optarg, &end, 0);
4139               if (end == optarg
4140                   || (*end != '.' && *end != '\0'))
4141                 non_fatal (_("%s: invalid reserve value for --stack"),
4142                            optarg);
4143               else if (*end != '\0')
4144                 {
4145                   pe_stack_commit = strtoul (end + 1, &end, 0);
4146                   if (*end != '\0')
4147                     non_fatal (_("%s: invalid commit value for --stack"),
4148                                optarg);
4149                 }
4150             }
4151           break;
4152
4153         case 0:
4154           /* We've been given a long option.  */
4155           break;
4156
4157         case 'H':
4158         case 'h':
4159           copy_usage (stdout, 0);
4160
4161         default:
4162           copy_usage (stderr, 1);
4163         }
4164     }
4165
4166   if (formats_info)
4167     {
4168       display_info ();
4169       return 0;
4170     }
4171
4172   if (show_version)
4173     print_version ("objcopy");
4174
4175   if (interleave && copy_byte == -1)
4176     fatal (_("interleave start byte must be set with --byte"));
4177
4178   if (copy_byte >= interleave)
4179     fatal (_("byte number must be less than interleave"));
4180
4181   if (copy_width > interleave - copy_byte)
4182     fatal (_("interleave width must be less than or equal to interleave - byte`"));
4183
4184   if (optind == argc || optind + 2 < argc)
4185     copy_usage (stderr, 1);
4186
4187   input_filename = argv[optind];
4188   if (optind + 1 < argc)
4189     output_filename = argv[optind + 1];
4190
4191   default_deterministic ();
4192
4193   /* Default is to strip no symbols.  */
4194   if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
4195     strip_symbols = STRIP_NONE;
4196
4197   if (output_target == NULL)
4198     output_target = input_target;
4199
4200   /* Convert input EFI target to PEI target.  */
4201   if (input_target != NULL
4202       && strncmp (input_target, "efi-", 4) == 0)
4203     {
4204       char *efi;
4205
4206       efi = xstrdup (output_target + 4);
4207       if (strncmp (efi, "bsdrv-", 6) == 0
4208           || strncmp (efi, "rtdrv-", 6) == 0)
4209         efi += 2;
4210       else if (strncmp (efi, "app-", 4) != 0)
4211         fatal (_("unknown input EFI target: %s"), input_target);
4212
4213       input_target = efi;
4214       convert_efi_target (efi);
4215     }
4216
4217   /* Convert output EFI target to PEI target.  */
4218   if (output_target != NULL
4219       && strncmp (output_target, "efi-", 4) == 0)
4220     {
4221       char *efi;
4222
4223       efi = xstrdup (output_target + 4);
4224       if (strncmp (efi, "app-", 4) == 0)
4225         {
4226           if (pe_subsystem == -1)
4227             pe_subsystem = IMAGE_SUBSYSTEM_EFI_APPLICATION;
4228         }
4229       else if (strncmp (efi, "bsdrv-", 6) == 0)
4230         {
4231           if (pe_subsystem == -1)
4232             pe_subsystem = IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER;
4233           efi += 2;
4234         }
4235       else if (strncmp (efi, "rtdrv-", 6) == 0)
4236         {
4237           if (pe_subsystem == -1)
4238             pe_subsystem = IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER;
4239           efi += 2;
4240         }
4241       else
4242         fatal (_("unknown output EFI target: %s"), output_target);
4243
4244       if (pe_file_alignment == (bfd_vma) -1)
4245         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
4246       if (pe_section_alignment == (bfd_vma) -1)
4247         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
4248
4249       output_target = efi;
4250       convert_efi_target (efi);
4251     }
4252
4253   if (preserve_dates)
4254     if (stat (input_filename, & statbuf) < 0)
4255       fatal (_("warning: could not locate '%s'.  System error message: %s"),
4256              input_filename, strerror (errno));
4257
4258   /* If there is no destination file, or the source and destination files
4259      are the same, then create a temp and rename the result into the input.  */
4260   if (output_filename == NULL
4261       || filename_cmp (input_filename, output_filename) == 0)
4262     tmpname = make_tempname (input_filename);
4263   else
4264     tmpname = output_filename;
4265
4266   if (tmpname == NULL)
4267     fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"),
4268            input_filename, strerror (errno));
4269
4270   copy_file (input_filename, tmpname, input_target, output_target, input_arch);
4271   if (status == 0)
4272     {
4273       if (preserve_dates)
4274         set_times (tmpname, &statbuf);
4275       if (tmpname != output_filename)
4276         status = (smart_rename (tmpname, input_filename,
4277                                 preserve_dates) != 0);
4278     }
4279   else
4280     unlink_if_ordinary (tmpname);
4281
4282   if (change_warn)
4283     {
4284       struct section_list *p;
4285
4286       for (p = change_sections; p != NULL; p = p->next)
4287         {
4288           if (! p->used)
4289             {
4290               if (p->context & (SECTION_CONTEXT_SET_VMA | SECTION_CONTEXT_ALTER_VMA))
4291                 {
4292                   char buff [20];
4293
4294                   sprintf_vma (buff, p->vma_val);
4295
4296                   /* xgettext:c-format */
4297                   non_fatal (_("%s %s%c0x%s never used"),
4298                              "--change-section-vma",
4299                              p->pattern,
4300                              p->context & SECTION_CONTEXT_SET_VMA ? '=' : '+',
4301                              buff);
4302                 }
4303
4304               if (p->context & (SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_ALTER_LMA))
4305                 {
4306                   char buff [20];
4307
4308                   sprintf_vma (buff, p->lma_val);
4309
4310                   /* xgettext:c-format */
4311                   non_fatal (_("%s %s%c0x%s never used"),
4312                              "--change-section-lma",
4313                              p->pattern,
4314                              p->context & SECTION_CONTEXT_SET_LMA ? '=' : '+',
4315                              buff);
4316                 }
4317             }
4318         }
4319     }
4320
4321   return 0;
4322 }
4323
4324 int
4325 main (int argc, char *argv[])
4326 {
4327 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
4328   setlocale (LC_MESSAGES, "");
4329 #endif
4330 #if defined (HAVE_SETLOCALE)
4331   setlocale (LC_CTYPE, "");
4332 #endif
4333   bindtextdomain (PACKAGE, LOCALEDIR);
4334   textdomain (PACKAGE);
4335
4336   program_name = argv[0];
4337   xmalloc_set_program_name (program_name);
4338
4339   START_PROGRESS (program_name, 0);
4340
4341   expandargv (&argc, &argv);
4342
4343   strip_symbols = STRIP_UNDEF;
4344   discard_locals = LOCALS_UNDEF;
4345
4346   bfd_init ();
4347   set_default_bfd_target ();
4348
4349   if (is_strip < 0)
4350     {
4351       int i = strlen (program_name);
4352 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4353       /* Drop the .exe suffix, if any.  */
4354       if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
4355         {
4356           i -= 4;
4357           program_name[i] = '\0';
4358         }
4359 #endif
4360       is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
4361     }
4362
4363   create_symbol_htabs ();
4364
4365   if (is_strip)
4366     strip_main (argc, argv);
4367   else
4368     copy_main (argc, argv);
4369
4370   END_PROGRESS (program_name);
4371
4372   return status;
4373 }