binutils/objcopy.c

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