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