binutils/objcopy.c

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