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