binutils/objcopy.c

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