binutils/objcopy.c

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