]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/objcopy.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* objcopy.c (copy_usage): Fix description of -K switch.
[thirdparty/binutils-gdb.git] / binutils / objcopy.c
CommitLineData
252b5132 1/* objcopy.c -- copy object file from input to output, optionally massaging it.
8c2bc687 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
aef6203b 3 2001, 2002, 2003, 2004, 2005
252b5132
RH		 4 Free Software Foundation, Inc.
5
6 This file is part of GNU Binutils.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
22\f
23#include "bfd.h"
24#include "progress.h"
25#include "bucomm.h"
26#include "getopt.h"
27#include "libiberty.h"
28#include "budbg.h"
5af11cab 29#include "filenames.h"
5fe11841 30#include "fnmatch.h"
f0312d39 31#include "elf-bfd.h"
252b5132
RH		 32#include <sys/stat.h>
33
34/* A list of symbols to explicitly strip out, or to keep. A linked
35 list is good enough for a small number from the command line, but
36 this will slow things down a lot if many symbols are being
0af11b59 37 deleted. */
252b5132
RH		 38
39struct symlist
40{
41 const char *name;
42 struct symlist *next;
43};
44
57938635
AM		 45/* A list to support redefine_sym. */
46struct redefine_node
47{
48 char *source;
49 char *target;
50 struct redefine_node *next;
51};
52
594ef5db
NC		 53typedef struct section_rename
54{
55 const char * old_name;
56 const char * new_name;
57 flagword flags;
58 struct section_rename * next;
59}
60section_rename;
61
62/* List of sections to be renamed. */
84e2f313 63static section_rename *section_rename_list;
594ef5db 64
252b5132
RH		 65#define RETURN_NONFATAL(s) {bfd_nonfatal (s); status = 1; return;}
66
84e2f313
NC		 67static asymbol **isympp = NULL; /* Input symbols. */
68static asymbol **osympp = NULL; /* Output symbols that survive stripping. */
252b5132
RH		 69
70/* If `copy_byte' >= 0, copy only that byte of every `interleave' bytes. */
71static int copy_byte = -1;
72static int interleave = 4;
73
b34976b6
AM		 74static bfd_boolean verbose; /* Print file and target names. */
75static bfd_boolean preserve_dates; /* Preserve input file timestamp. */
252b5132
RH		 76static int status = 0; /* Exit status. */
77
78enum strip_action
79 {
80 STRIP_UNDEF,
84e2f313
NC		 81 STRIP_NONE, /* Don't strip. */
82 STRIP_DEBUG, /* Strip all debugger symbols. */
83 STRIP_UNNEEDED, /* Strip unnecessary symbols. */
ed1653a7 84 STRIP_NONDEBUG, /* Strip everything but debug info. */
84e2f313 85 STRIP_ALL /* Strip all symbols. */
252b5132
RH		 86 };
87
0af11b59 88/* Which symbols to remove. */
252b5132
RH		 89static enum strip_action strip_symbols;
90
91enum locals_action
92 {
93 LOCALS_UNDEF,
84e2f313
NC		 94 LOCALS_START_L, /* Discard locals starting with L. */
95 LOCALS_ALL /* Discard all locals. */
252b5132
RH		 96 };
97
98/* Which local symbols to remove. Overrides STRIP_ALL. */
99static enum locals_action discard_locals;
100
101/* What kind of change to perform. */
102enum change_action
103{
104 CHANGE_IGNORE,
105 CHANGE_MODIFY,
106 CHANGE_SET
107};
108
109/* Structure used to hold lists of sections and actions to take. */
110struct section_list
111{
b34976b6
AM		 112 struct section_list * next; /* Next section to change. */
113 const char * name; /* Section name. */
114 bfd_boolean used; /* Whether this entry was used. */
115 bfd_boolean remove; /* Whether to remove this section. */
116 bfd_boolean copy; /* Whether to copy this section. */
117 enum change_action change_vma;/* Whether to change or set VMA. */
118 bfd_vma vma_val; /* Amount to change by or set to. */
119 enum change_action change_lma;/* Whether to change or set LMA. */
120 bfd_vma lma_val; /* Amount to change by or set to. */
121 bfd_boolean set_flags; /* Whether to set the section flags. */
122 flagword flags; /* What to set the section flags to. */
252b5132
RH		 123};
124
125static struct section_list *change_sections;
594ef5db 126
b34976b6
AM		 127/* TRUE if some sections are to be removed. */
128static bfd_boolean sections_removed;
594ef5db 129
b34976b6
AM		 130/* TRUE if only some sections are to be copied. */
131static bfd_boolean sections_copied;
252b5132
RH		 132
133/* Changes to the start address. */
134static bfd_vma change_start = 0;
b34976b6 135static bfd_boolean set_start_set = FALSE;
252b5132
RH		 136static bfd_vma set_start;
137
138/* Changes to section addresses. */
139static bfd_vma change_section_address = 0;
140
141/* Filling gaps between sections. */
b34976b6 142static bfd_boolean gap_fill_set = FALSE;
252b5132
RH		 143static bfd_byte gap_fill = 0;
144
145/* Pad to a given address. */
b34976b6 146static bfd_boolean pad_to_set = FALSE;
252b5132
RH		 147static bfd_vma pad_to;
148
1ae8b3d2
AO		 149/* Use alternate machine code? */
150static int use_alt_mach_code = 0;
151
4087920c
MR		 152/* Output BFD flags user wants to set or clear */
153static flagword bfd_flags_to_set;
154static flagword bfd_flags_to_clear;
155
252b5132 156/* List of sections to add. */
252b5132
RH		 157struct section_add
158{
159 /* Next section to add. */
160 struct section_add *next;
161 /* Name of section to add. */
162 const char *name;
163 /* Name of file holding section contents. */
164 const char *filename;
165 /* Size of file. */
166 size_t size;
167 /* Contents of file. */
168 bfd_byte *contents;
169 /* BFD section, after it has been added. */
170 asection *section;
171};
172
594ef5db 173/* List of sections to add to the output BFD. */
252b5132
RH		 174static struct section_add *add_sections;
175
2593f09a
NC		 176/* If non-NULL the argument to --add-gnu-debuglink.
177 This should be the filename to store in the .gnu_debuglink section. */
178static const char * gnu_debuglink_filename = NULL;
179
252b5132 180/* Whether to convert debugging information. */
b34976b6 181static bfd_boolean convert_debugging = FALSE;
252b5132
RH		 182
183/* Whether to change the leading character in symbol names. */
b34976b6 184static bfd_boolean change_leading_char = FALSE;
252b5132
RH		 185
186/* Whether to remove the leading character from global symbol names. */
b34976b6 187static bfd_boolean remove_leading_char = FALSE;
252b5132 188
aaad4cf3 189/* Whether to permit wildcard in symbol comparison. */
5fe11841
NC		 190static bfd_boolean wildcard = FALSE;
191
16b2b71c
NC		 192/* List of symbols to strip, keep, localize, keep-global, weaken,
193 or redefine. */
252b5132 194static struct symlist *strip_specific_list = NULL;
bcf32829 195static struct symlist *strip_unneeded_list = NULL;
252b5132
RH		 196static struct symlist *keep_specific_list = NULL;
197static struct symlist *localize_specific_list = NULL;
7b4a0685 198static struct symlist *globalize_specific_list = NULL;
16b2b71c 199static struct symlist *keepglobal_specific_list = NULL;
252b5132 200static struct symlist *weaken_specific_list = NULL;
57938635 201static struct redefine_node *redefine_sym_list = NULL;
252b5132 202
b34976b6
AM		 203/* If this is TRUE, we weaken global symbols (set BSF_WEAK). */
204static bfd_boolean weaken = FALSE;
252b5132 205
d7fb0dd2
NC		 206/* Prefix symbols/sections. */
207static char *prefix_symbols_string = 0;
208static char *prefix_sections_string = 0;
209static char *prefix_alloc_sections_string = 0;
210
252b5132 211/* 150 isn't special; it's just an arbitrary non-ASCII char value. */
84e2f313
NC		 212enum command_line_switch
213 {
214 OPTION_ADD_SECTION=150,
215 OPTION_CHANGE_ADDRESSES,
216 OPTION_CHANGE_LEADING_CHAR,
217 OPTION_CHANGE_START,
218 OPTION_CHANGE_SECTION_ADDRESS,
219 OPTION_CHANGE_SECTION_LMA,
220 OPTION_CHANGE_SECTION_VMA,
221 OPTION_CHANGE_WARNINGS,
222 OPTION_DEBUGGING,
223 OPTION_GAP_FILL,
224 OPTION_NO_CHANGE_WARNINGS,
225 OPTION_PAD_TO,
226 OPTION_REMOVE_LEADING_CHAR,
227 OPTION_SET_SECTION_FLAGS,
228 OPTION_SET_START,
229 OPTION_STRIP_UNNEEDED,
230 OPTION_WEAKEN,
231 OPTION_REDEFINE_SYM,
232 OPTION_REDEFINE_SYMS,
233 OPTION_SREC_LEN,
234 OPTION_SREC_FORCES3,
235 OPTION_STRIP_SYMBOLS,
bcf32829
JB		 236 OPTION_STRIP_UNNEEDED_SYMBOL,
237 OPTION_STRIP_UNNEEDED_SYMBOLS,
84e2f313
NC		 238 OPTION_KEEP_SYMBOLS,
239 OPTION_LOCALIZE_SYMBOLS,
7b4a0685
NC		 240 OPTION_GLOBALIZE_SYMBOL,
241 OPTION_GLOBALIZE_SYMBOLS,
84e2f313
NC		 242 OPTION_KEEPGLOBAL_SYMBOLS,
243 OPTION_WEAKEN_SYMBOLS,
244 OPTION_RENAME_SECTION,
245 OPTION_ALT_MACH_CODE,
246 OPTION_PREFIX_SYMBOLS,
247 OPTION_PREFIX_SECTIONS,
248 OPTION_PREFIX_ALLOC_SECTIONS,
249 OPTION_FORMATS_INFO,
250 OPTION_ADD_GNU_DEBUGLINK,
4087920c
MR		 251 OPTION_ONLY_KEEP_DEBUG,
252 OPTION_READONLY_TEXT,
253 OPTION_WRITABLE_TEXT,
254 OPTION_PURE,
255 OPTION_IMPURE
84e2f313 256 };
252b5132
RH		 257
258/* Options to handle if running as "strip". */
259
260static struct option strip_options[] =
261{
262 {"discard-all", no_argument, 0, 'x'},
263 {"discard-locals", no_argument, 0, 'X'},
264 {"format", required_argument, 0, 'F'}, /* Obsolete */
265 {"help", no_argument, 0, 'h'},
7c29036b 266 {"info", no_argument, 0, OPTION_FORMATS_INFO},
252b5132
RH		 267 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
268 {"input-target", required_argument, 0, 'I'},
269 {"keep-symbol", required_argument, 0, 'K'},
ed1653a7 270 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
252b5132
RH		 271 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
272 {"output-target", required_argument, 0, 'O'},
af3bdff7 273 {"output-file", required_argument, 0, 'o'},
252b5132
RH		 274 {"preserve-dates", no_argument, 0, 'p'},
275 {"remove-section", required_argument, 0, 'R'},
276 {"strip-all", no_argument, 0, 's'},
277 {"strip-debug", no_argument, 0, 'S'},
278 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
279 {"strip-symbol", required_argument, 0, 'N'},
280 {"target", required_argument, 0, 'F'},
281 {"verbose", no_argument, 0, 'v'},
282 {"version", no_argument, 0, 'V'},
5fe11841 283 {"wildcard", no_argument, 0, 'w'},
252b5132
RH		 284 {0, no_argument, 0, 0}
285};
286
287/* Options to handle if running as "objcopy". */
288
289static struct option copy_options[] =
290{
2593f09a 291 {"add-gnu-debuglink", required_argument, 0, OPTION_ADD_GNU_DEBUGLINK},
252b5132
RH		 292 {"add-section", required_argument, 0, OPTION_ADD_SECTION},
293 {"adjust-start", required_argument, 0, OPTION_CHANGE_START},
294 {"adjust-vma", required_argument, 0, OPTION_CHANGE_ADDRESSES},
295 {"adjust-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
296 {"adjust-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
d7fb0dd2 297 {"alt-machine-code", required_argument, 0, OPTION_ALT_MACH_CODE},
43a0748c 298 {"binary-architecture", required_argument, 0, 'B'},
252b5132
RH		 299 {"byte", required_argument, 0, 'b'},
300 {"change-addresses", required_argument, 0, OPTION_CHANGE_ADDRESSES},
301 {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR},
302 {"change-section-address", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
303 {"change-section-lma", required_argument, 0, OPTION_CHANGE_SECTION_LMA},
304 {"change-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_VMA},
305 {"change-start", required_argument, 0, OPTION_CHANGE_START},
306 {"change-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
307 {"debugging", no_argument, 0, OPTION_DEBUGGING},
308 {"discard-all", no_argument, 0, 'x'},
309 {"discard-locals", no_argument, 0, 'X'},
310 {"format", required_argument, 0, 'F'}, /* Obsolete */
311 {"gap-fill", required_argument, 0, OPTION_GAP_FILL},
7b4a0685
NC		 312 {"globalize-symbol", required_argument, 0, OPTION_GLOBALIZE_SYMBOL},
313 {"globalize-symbols", required_argument, 0, OPTION_GLOBALIZE_SYMBOLS},
252b5132 314 {"help", no_argument, 0, 'h'},
4087920c 315 {"impure", no_argument, 0, OPTION_IMPURE},
7c29036b 316 {"info", no_argument, 0, OPTION_FORMATS_INFO},
252b5132
RH		 317 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
318 {"input-target", required_argument, 0, 'I'},
319 {"interleave", required_argument, 0, 'i'},
d7fb0dd2
NC		 320 {"keep-global-symbol", required_argument, 0, 'G'},
321 {"keep-global-symbols", required_argument, 0, OPTION_KEEPGLOBAL_SYMBOLS},
252b5132 322 {"keep-symbol", required_argument, 0, 'K'},
d7fb0dd2
NC		 323 {"keep-symbols", required_argument, 0, OPTION_KEEP_SYMBOLS},
324 {"localize-symbol", required_argument, 0, 'L'},
325 {"localize-symbols", required_argument, 0, OPTION_LOCALIZE_SYMBOLS},
252b5132
RH		 326 {"no-adjust-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
327 {"no-change-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
ed1653a7 328 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
d7fb0dd2 329 {"only-section", required_argument, 0, 'j'},
252b5132
RH		 330 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
331 {"output-target", required_argument, 0, 'O'},
332 {"pad-to", required_argument, 0, OPTION_PAD_TO},
d7fb0dd2
NC		 333 {"prefix-symbols", required_argument, 0, OPTION_PREFIX_SYMBOLS},
334 {"prefix-sections", required_argument, 0, OPTION_PREFIX_SECTIONS},
335 {"prefix-alloc-sections", required_argument, 0, OPTION_PREFIX_ALLOC_SECTIONS},
252b5132 336 {"preserve-dates", no_argument, 0, 'p'},
4087920c
MR		 337 {"pure", no_argument, 0, OPTION_PURE},
338 {"readonly-text", no_argument, 0, OPTION_READONLY_TEXT},
d7fb0dd2 339 {"redefine-sym", required_argument, 0, OPTION_REDEFINE_SYM},
92991082 340 {"redefine-syms", required_argument, 0, OPTION_REDEFINE_SYMS},
252b5132
RH		 341 {"remove-leading-char", no_argument, 0, OPTION_REMOVE_LEADING_CHAR},
342 {"remove-section", required_argument, 0, 'R'},
594ef5db 343 {"rename-section", required_argument, 0, OPTION_RENAME_SECTION},
252b5132
RH		 344 {"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS},
345 {"set-start", required_argument, 0, OPTION_SET_START},
d7fb0dd2
NC		 346 {"srec-len", required_argument, 0, OPTION_SREC_LEN},
347 {"srec-forceS3", no_argument, 0, OPTION_SREC_FORCES3},
252b5132
RH		 348 {"strip-all", no_argument, 0, 'S'},
349 {"strip-debug", no_argument, 0, 'g'},
350 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
bcf32829
JB		 351 {"strip-unneeded-symbol", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOL},
352 {"strip-unneeded-symbols", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOLS},
252b5132 353 {"strip-symbol", required_argument, 0, 'N'},
d7fb0dd2 354 {"strip-symbols", required_argument, 0, OPTION_STRIP_SYMBOLS},
252b5132
RH		 355 {"target", required_argument, 0, 'F'},
356 {"verbose", no_argument, 0, 'v'},
357 {"version", no_argument, 0, 'V'},
358 {"weaken", no_argument, 0, OPTION_WEAKEN},
359 {"weaken-symbol", required_argument, 0, 'W'},
16b2b71c 360 {"weaken-symbols", required_argument, 0, OPTION_WEAKEN_SYMBOLS},
5fe11841 361 {"wildcard", no_argument, 0, 'w'},
4087920c 362 {"writable-text", no_argument, 0, OPTION_WRITABLE_TEXT},
252b5132
RH		 363 {0, no_argument, 0, 0}
364};
365
366/* IMPORTS */
367extern char *program_name;
368
369/* This flag distinguishes between strip and objcopy:
370 1 means this is 'strip'; 0 means this is 'objcopy'.
0af11b59 371 -1 means if we should use argv[0] to decide. */
252b5132
RH		 372extern int is_strip;
373
420496c1
NC		 374/* The maximum length of an S record. This variable is declared in srec.c
375 and can be modified by the --srec-len parameter. */
376extern unsigned int Chunk;
377
378/* Restrict the generation of Srecords to type S3 only.
379 This variable is declare in bfd/srec.c and can be toggled
380 on by the --srec-forceS3 command line switch. */
b34976b6 381extern bfd_boolean S3Forced;
252b5132 382
b749473b
NC		 383/* Defined in bfd/binary.c. Used to set architecture and machine of input
384 binary files. */
385extern enum bfd_architecture bfd_external_binary_architecture;
386extern unsigned long bfd_external_machine;
43a0748c 387
d3ba0551
AM		 388/* Forward declarations. */
389static void setup_section (bfd *, asection *, void *);
80fccad2 390static void setup_bfd_headers (bfd *, bfd *);
d3ba0551
AM		 391static void copy_section (bfd *, asection *, void *);
392static void get_sections (bfd *, asection *, void *);
393static int compare_section_lma (const void *, const void *);
394static void mark_symbols_used_in_relocations (bfd *, asection *, void *);
395static bfd_boolean write_debugging_info (bfd *, void *, long *, asymbol ***);
396static const char *lookup_sym_redefinition (const char *);
594ef5db 397\f
252b5132 398static void
84e2f313 399copy_usage (FILE *stream, int exit_status)
252b5132 400{
8b53311e
NC		 401 fprintf (stream, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name);
402 fprintf (stream, _(" Copies a binary file, possibly transforming it in the process\n"));
6364e0b4 403 fprintf (stream, _(" The options are:\n"));
252b5132 404 fprintf (stream, _("\
d5bcb29d
NC		 405 -I --input-target <bfdname> Assume input file is in format <bfdname>\n\
406 -O --output-target <bfdname> Create an output file in format <bfdname>\n\
43a0748c 407 -B --binary-architecture <arch> Set arch of output file, when input is binary\n\
d5bcb29d
NC		 408 -F --target <bfdname> Set both input and output format to <bfdname>\n\
409 --debugging Convert debugging information, if possible\n\
410 -p --preserve-dates Copy modified/access timestamps to the output\n\
411 -j --only-section <name> Only copy section <name> into the output\n\
2593f09a 412 --add-gnu-debuglink=<file> Add section .gnu_debuglink linking to <file>\n\
d5bcb29d
NC		 413 -R --remove-section <name> Remove section <name> from the output\n\
414 -S --strip-all Remove all symbol and relocation information\n\
2593f09a 415 -g --strip-debug Remove all debugging symbols & sections\n\
d5bcb29d
NC		 416 --strip-unneeded Remove all symbols not needed by relocations\n\
417 -N --strip-symbol <name> Do not copy symbol <name>\n\
bcf32829
JB		 418 --strip-unneeded-symbol <name>\n\
419 Do not copy symbol <name> unless needed by\n\
420 relocations\n\
6ea3dd37 421 --only-keep-debug Strip everything but the debug information\n\
e7f918ad 422 -K --keep-symbol <name> Do not strip symbol <name>\n\
d5bcb29d 423 -L --localize-symbol <name> Force symbol <name> to be marked as a local\n\
7b4a0685 424 --globalize-symbol <name> Force symbol <name> to be marked as a global\n\
16b2b71c 425 -G --keep-global-symbol <name> Localize all symbols except <name>\n\
d5bcb29d
NC		 426 -W --weaken-symbol <name> Force symbol <name> to be marked as a weak\n\
427 --weaken Force all global symbols to be marked as weak\n\
a95b5cf9 428 -w --wildcard Permit wildcard in symbol comparison\n\
d5bcb29d
NC		 429 -x --discard-all Remove all non-global symbols\n\
430 -X --discard-locals Remove any compiler-generated symbols\n\
431 -i --interleave <number> Only copy one out of every <number> bytes\n\
432 -b --byte <num> Select byte <num> in every interleaved block\n\
433 --gap-fill <val> Fill gaps between sections with <val>\n\
434 --pad-to <addr> Pad the last section up to address <addr>\n\
435 --set-start <addr> Set the start address to <addr>\n\
436 {--change-start|--adjust-start} <incr>\n\
437 Add <incr> to the start address\n\
438 {--change-addresses|--adjust-vma} <incr>\n\
439 Add <incr> to LMA, VMA and start addresses\n\
440 {--change-section-address|--adjust-section-vma} <name>{=|+|-}<val>\n\
441 Change LMA and VMA of section <name> by <val>\n\
442 --change-section-lma <name>{=|+|-}<val>\n\
443 Change the LMA of section <name> by <val>\n\
444 --change-section-vma <name>{=|+|-}<val>\n\
445 Change the VMA of section <name> by <val>\n\
446 {--[no-]change-warnings|--[no-]adjust-warnings}\n\
447 Warn if a named section does not exist\n\
448 --set-section-flags <name>=<flags>\n\
449 Set section <name>'s properties to <flags>\n\
450 --add-section <name>=<file> Add section <name> found in <file> to output\n\
594ef5db 451 --rename-section <old>=<new>[,<flags>] Rename section <old> to <new>\n\
d5bcb29d
NC		 452 --change-leading-char Force output format's leading character style\n\
453 --remove-leading-char Remove leading character from global symbols\n\
57938635 454 --redefine-sym <old>=<new> Redefine symbol name <old> to <new>\n\
92991082
JT		 455 --redefine-syms <file> --redefine-sym for all symbol pairs \n\
456 listed in <file>\n\
420496c1
NC		 457 --srec-len <number> Restrict the length of generated Srecords\n\
458 --srec-forceS3 Restrict the type of generated Srecords to S3\n\
16b2b71c 459 --strip-symbols <file> -N for all symbols listed in <file>\n\
bcf32829
JB		 460 --strip-unneeded-symbols <file>\n\
461 --strip-unneeded-symbol for all symbols listed\n\
462 in <file>\n\
16b2b71c
NC		 463 --keep-symbols <file> -K for all symbols listed in <file>\n\
464 --localize-symbols <file> -L for all symbols listed in <file>\n\
7b4a0685 465 --globalize-symbols <file> --globalize-symbol for all in <file>\n\
16b2b71c
NC		 466 --keep-global-symbols <file> -G for all symbols listed in <file>\n\
467 --weaken-symbols <file> -W for all symbols listed in <file>\n\
1ae8b3d2 468 --alt-machine-code <index> Use alternate machine code for output\n\
4087920c
MR		 469 --writable-text Mark the output text as writable\n\
470 --readonly-text Make the output text write protected\n\
471 --pure Mark the output file as demand paged\n\
472 --impure Mark the output file as impure\n\
d7fb0dd2
NC		 473 --prefix-symbols <prefix> Add <prefix> to start of every symbol name\n\
474 --prefix-sections <prefix> Add <prefix> to start of every section name\n\
475 --prefix-alloc-sections <prefix>\n\
476 Add <prefix> to start of every allocatable\n\
477 section name\n\
d5bcb29d
NC		 478 -v --verbose List all object files modified\n\
479 -V --version Display this program's version number\n\
480 -h --help Display this output\n\
7c29036b 481 --info List object formats & architectures supported\n\
d5bcb29d 482"));
252b5132
RH		 483 list_supported_targets (program_name, stream);
484 if (exit_status == 0)
8ad3436c 485 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132
RH		 486 exit (exit_status);
487}
488
489static void
84e2f313 490strip_usage (FILE *stream, int exit_status)
252b5132 491{
8b53311e
NC		 492 fprintf (stream, _("Usage: %s <option(s)> in-file(s)\n"), program_name);
493 fprintf (stream, _(" Removes symbols and sections from files\n"));
6364e0b4 494 fprintf (stream, _(" The options are:\n"));
252b5132 495 fprintf (stream, _("\
8b53311e
NC		 496 -I --input-target=<bfdname> Assume input file is in format <bfdname>\n\
497 -O --output-target=<bfdname> Create an output file in format <bfdname>\n\
498 -F --target=<bfdname> Set both input and output format to <bfdname>\n\
d5bcb29d 499 -p --preserve-dates Copy modified/access timestamps to the output\n\
8b53311e 500 -R --remove-section=<name> Remove section <name> from the output\n\
d5bcb29d 501 -s --strip-all Remove all symbol and relocation information\n\
2593f09a 502 -g -S -d --strip-debug Remove all debugging symbols & sections\n\
d5bcb29d 503 --strip-unneeded Remove all symbols not needed by relocations\n\
6ea3dd37 504 --only-keep-debug Strip everything but the debug information\n\
8b53311e
NC		 505 -N --strip-symbol=<name> Do not copy symbol <name>\n\
506 -K --keep-symbol=<name> Only copy symbol <name>\n\
a95b5cf9 507 -w --wildcard Permit wildcard in symbol comparison\n\
d5bcb29d
NC		 508 -x --discard-all Remove all non-global symbols\n\
509 -X --discard-locals Remove any compiler-generated symbols\n\
510 -v --verbose List all object files modified\n\
511 -V --version Display this program's version number\n\
512 -h --help Display this output\n\
7c29036b 513 --info List object formats & architectures supported\n\
d5bcb29d
NC		 514 -o <file> Place stripped output into <file>\n\
515"));
516
252b5132
RH		 517 list_supported_targets (program_name, stream);
518 if (exit_status == 0)
8ad3436c 519 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132
RH		 520 exit (exit_status);
521}
522
523/* Parse section flags into a flagword, with a fatal error if the
524 string can't be parsed. */
525
526static flagword
84e2f313 527parse_flags (const char *s)
252b5132
RH		 528{
529 flagword ret;
530 const char *snext;
531 int len;
532
533 ret = SEC_NO_FLAGS;
534
535 do
536 {
537 snext = strchr (s, ',');
538 if (snext == NULL)
539 len = strlen (s);
540 else
541 {
542 len = snext - s;
543 ++snext;
544 }
545
546 if (0) ;
547#define PARSE_FLAG(fname,fval) \
548 else if (strncasecmp (fname, s, len) == 0) ret |= fval
549 PARSE_FLAG ("alloc", SEC_ALLOC);
550 PARSE_FLAG ("load", SEC_LOAD);
3994e2c6 551 PARSE_FLAG ("noload", SEC_NEVER_LOAD);
252b5132 552 PARSE_FLAG ("readonly", SEC_READONLY);
3994e2c6 553 PARSE_FLAG ("debug", SEC_DEBUGGING);
252b5132
RH		 554 PARSE_FLAG ("code", SEC_CODE);
555 PARSE_FLAG ("data", SEC_DATA);
556 PARSE_FLAG ("rom", SEC_ROM);
ebe372c1 557 PARSE_FLAG ("share", SEC_COFF_SHARED);
252b5132
RH		 558 PARSE_FLAG ("contents", SEC_HAS_CONTENTS);
559#undef PARSE_FLAG
560 else
561 {
562 char *copy;
563
564 copy = xmalloc (len + 1);
565 strncpy (copy, s, len);
566 copy[len] = '\0';
567 non_fatal (_("unrecognized section flag `%s'"), copy);
57938635
AM		 568 fatal (_("supported flags: %s"),
569 "alloc, load, noload, readonly, debug, code, data, rom, share, contents");
252b5132
RH		 570 }
571
572 s = snext;
573 }
574 while (s != NULL);
575
576 return ret;
577}
578
579/* Find and optionally add an entry in the change_sections list. */
580
581static struct section_list *
84e2f313 582find_section_list (const char *name, bfd_boolean add)
252b5132 583{
84e2f313 584 struct section_list *p;
252b5132
RH		 585
586 for (p = change_sections; p != NULL; p = p->next)
587 if (strcmp (p->name, name) == 0)
588 return p;
589
590 if (! add)
591 return NULL;
592
d3ba0551 593 p = xmalloc (sizeof (struct section_list));
252b5132 594 p->name = name;
b34976b6
AM		 595 p->used = FALSE;
596 p->remove = FALSE;
597 p->copy = FALSE;
252b5132
RH		 598 p->change_vma = CHANGE_IGNORE;
599 p->change_lma = CHANGE_IGNORE;
600 p->vma_val = 0;
601 p->lma_val = 0;
b34976b6 602 p->set_flags = FALSE;
252b5132
RH		 603 p->flags = 0;
604
605 p->next = change_sections;
606 change_sections = p;
607
608 return p;
609}
610
611/* Add a symbol to strip_specific_list. */
612
57938635 613static void
84e2f313 614add_specific_symbol (const char *name, struct symlist **list)
252b5132
RH		 615{
616 struct symlist *tmp_list;
617
d3ba0551 618 tmp_list = xmalloc (sizeof (struct symlist));
252b5132
RH		 619 tmp_list->name = name;
620 tmp_list->next = *list;
621 *list = tmp_list;
622}
623
0af11b59 624/* Add symbols listed in `filename' to strip_specific_list. */
16b2b71c
NC		 625
626#define IS_WHITESPACE(c) ((c) == ' ' || (c) == '\t')
627#define IS_LINE_TERMINATOR(c) ((c) == '\n' || (c) == '\r' || (c) == '\0')
628
629static void
84e2f313 630add_specific_symbols (const char *filename, struct symlist **list)
16b2b71c 631{
f24ddbdd 632 off_t size;
16b2b71c
NC		 633 FILE * f;
634 char * line;
635 char * buffer;
636 unsigned int line_count;
0af11b59 637
f24ddbdd
NC		 638 size = get_file_size (filename);
639 if (size == 0)
16b2b71c
NC		 640 return;
641
f24ddbdd 642 buffer = xmalloc (size + 2);
16b2b71c
NC		 643 f = fopen (filename, FOPEN_RT);
644 if (f == NULL)
f24ddbdd 645 fatal (_("cannot open '%s': %s"), filename, strerror (errno));
16b2b71c 646
f24ddbdd 647 if (fread (buffer, 1, size, f) == 0 || ferror (f))
16b2b71c
NC		 648 fatal (_("%s: fread failed"), filename);
649
650 fclose (f);
f24ddbdd
NC		 651 buffer [size] = '\n';
652 buffer [size + 1] = '\0';
16b2b71c
NC		 653
654 line_count = 1;
0af11b59 655
16b2b71c
NC		 656 for (line = buffer; * line != '\0'; line ++)
657 {
658 char * eol;
659 char * name;
660 char * name_end;
b34976b6 661 int finished = FALSE;
16b2b71c
NC		 662
663 for (eol = line;; eol ++)
664 {
665 switch (* eol)
666 {
667 case '\n':
668 * eol = '\0';
669 /* Cope with \n\r. */
670 if (eol[1] == '\r')
671 ++ eol;
b34976b6 672 finished = TRUE;
16b2b71c 673 break;
0af11b59 674
16b2b71c
NC		 675 case '\r':
676 * eol = '\0';
677 /* Cope with \r\n. */
678 if (eol[1] == '\n')
679 ++ eol;
b34976b6 680 finished = TRUE;
16b2b71c 681 break;
0af11b59 682
16b2b71c 683 case 0:
b34976b6 684 finished = TRUE;
16b2b71c 685 break;
0af11b59 686
16b2b71c
NC		 687 case '#':
688 /* Line comment, Terminate the line here, in case a
689 name is present and then allow the rest of the
690 loop to find the real end of the line. */
691 * eol = '\0';
692 break;
0af11b59 693
16b2b71c
NC		 694 default:
695 break;
696 }
697
698 if (finished)
699 break;
700 }
701
702 /* A name may now exist somewhere between 'line' and 'eol'.
703 Strip off leading whitespace and trailing whitespace,
704 then add it to the list. */
705 for (name = line; IS_WHITESPACE (* name); name ++)
706 ;
707 for (name_end = name;
708 (! IS_WHITESPACE (* name_end))
709 && (! IS_LINE_TERMINATOR (* name_end));
0af11b59
KH		 710 name_end ++)
711 ;
16b2b71c
NC		 712
713 if (! IS_LINE_TERMINATOR (* name_end))
714 {
715 char * extra;
716
717 for (extra = name_end + 1; IS_WHITESPACE (* extra); extra ++)
718 ;
719
720 if (! IS_LINE_TERMINATOR (* extra))
d412a550
NC		 721 non_fatal (_("%s:%d: Ignoring rubbish found on this line"),
722 filename, line_count);
16b2b71c 723 }
0af11b59 724
16b2b71c
NC		 725 * name_end = '\0';
726
727 if (name_end > name)
728 add_specific_symbol (name, list);
729
730 /* Advance line pointer to end of line. The 'eol ++' in the for
731 loop above will then advance us to the start of the next line. */
732 line = eol;
733 line_count ++;
734 }
735}
736
252b5132
RH		 737/* See whether a symbol should be stripped or kept based on
738 strip_specific_list and keep_symbols. */
739
b34976b6 740static bfd_boolean
84e2f313 741is_specified_symbol (const char *name, struct symlist *list)
252b5132
RH		 742{
743 struct symlist *tmp_list;
744
5fe11841
NC		 745 if (wildcard)
746 {
747 for (tmp_list = list; tmp_list; tmp_list = tmp_list->next)
748 if (*(tmp_list->name) != '!')
749 {
750 if (!fnmatch (tmp_list->name, name, 0))
751 return TRUE;
752 }
753 else
754 {
755 if (fnmatch (tmp_list->name + 1, name, 0))
756 return TRUE;
757 }
758 }
759 else
760 {
761 for (tmp_list = list; tmp_list; tmp_list = tmp_list->next)
762 if (strcmp (name, tmp_list->name) == 0)
763 return TRUE;
764 }
594ef5db 765
b34976b6 766 return FALSE;
252b5132
RH		 767}
768
769/* See if a section is being removed. */
770
b34976b6 771static bfd_boolean
84e2f313 772is_strip_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
252b5132 773{
2593f09a
NC		 774 if (sections_removed || sections_copied)
775 {
776 struct section_list *p;
777
778 p = find_section_list (bfd_get_section_name (abfd, sec), FALSE);
779
780 if (sections_removed && p != NULL && p->remove)
781 return TRUE;
782 if (sections_copied && (p == NULL || ! p->copy))
783 return TRUE;
784 }
252b5132 785
2593f09a
NC		 786 if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0)
787 {
788 if (strip_symbols == STRIP_DEBUG
252b5132
RH		 789 || strip_symbols == STRIP_UNNEEDED
790 || strip_symbols == STRIP_ALL
791 || discard_locals == LOCALS_ALL
2593f09a
NC		 792 || convert_debugging)
793 return TRUE;
ed1653a7
NC		 794
795 if (strip_symbols == STRIP_NONDEBUG)
796 return FALSE;
2593f09a 797 }
f91ea849 798
f0312d39 799 return FALSE;
252b5132
RH		 800}
801
802/* Choose which symbol entries to copy; put the result in OSYMS.
803 We don't copy in place, because that confuses the relocs.
804 Return the number of symbols to print. */
805
806static unsigned int
84e2f313
NC		 807filter_symbols (bfd *abfd, bfd *obfd, asymbol **osyms,
808 asymbol **isyms, long symcount)
252b5132 809{
84e2f313 810 asymbol **from = isyms, **to = osyms;
252b5132 811 long src_count = 0, dst_count = 0;
d8121479
L		 812 int relocatable = (abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
813 == HAS_RELOC;
252b5132
RH		 814
815 for (; src_count < symcount; src_count++)
816 {
817 asymbol *sym = from[src_count];
818 flagword flags = sym->flags;
d7fb0dd2 819 char *name = (char *) bfd_asymbol_name (sym);
252b5132 820 int keep;
b34976b6 821 bfd_boolean undefined;
d7fb0dd2
NC		 822 bfd_boolean rem_leading_char;
823 bfd_boolean add_leading_char;
824
825 undefined = bfd_is_und_section (bfd_get_section (sym));
252b5132 826
57938635
AM		 827 if (redefine_sym_list)
828 {
d7fb0dd2 829 char *old_name, *new_name;
57938635 830
d7fb0dd2
NC		 831 old_name = (char *) bfd_asymbol_name (sym);
832 new_name = (char *) lookup_sym_redefinition (old_name);
66491ebc
AM		 833 bfd_asymbol_name (sym) = new_name;
834 name = new_name;
57938635
AM		 835 }
836
d7fb0dd2
NC		 837 /* Check if we will remove the current leading character. */
838 rem_leading_char =
839 (name[0] == bfd_get_symbol_leading_char (abfd))
840 && (change_leading_char
841 || (remove_leading_char
842 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
843 || undefined
844 || bfd_is_com_section (bfd_get_section (sym)))));
845
846 /* Check if we will add a new leading character. */
847 add_leading_char =
848 change_leading_char
849 && (bfd_get_symbol_leading_char (obfd) != '\0')
850 && (bfd_get_symbol_leading_char (abfd) == '\0'
851 || (name[0] == bfd_get_symbol_leading_char (abfd)));
852
853 /* Short circuit for change_leading_char if we can do it in-place. */
854 if (rem_leading_char && add_leading_char && !prefix_symbols_string)
855 {
856 name[0] = bfd_get_symbol_leading_char (obfd);
857 bfd_asymbol_name (sym) = name;
858 rem_leading_char = FALSE;
859 add_leading_char = FALSE;
860 }
861
862 /* Remove leading char. */
863 if (rem_leading_char)
66491ebc 864 bfd_asymbol_name (sym) = ++name;
d7fb0dd2
NC		 865
866 /* Add new leading char and/or prefix. */
867 if (add_leading_char || prefix_symbols_string)
868 {
869 char *n, *ptr;
870
84e2f313
NC		 871 ptr = n = xmalloc (1 + strlen (prefix_symbols_string)
872 + strlen (name) + 1);
d7fb0dd2
NC		 873 if (add_leading_char)
874 *ptr++ = bfd_get_symbol_leading_char (obfd);
875
876 if (prefix_symbols_string)
877 {
878 strcpy (ptr, prefix_symbols_string);
879 ptr += strlen (prefix_symbols_string);
880 }
881
882 strcpy (ptr, name);
66491ebc
AM		 883 bfd_asymbol_name (sym) = n;
884 name = n;
252b5132
RH		 885 }
886
252b5132
RH		 887 if (strip_symbols == STRIP_ALL)
888 keep = 0;
889 else if ((flags & BSF_KEEP) != 0 /* Used in relocation. */
890 || ((flags & BSF_SECTION_SYM) != 0
891 && ((*bfd_get_section (sym)->symbol_ptr_ptr)->flags
892 & BSF_KEEP) != 0))
893 keep = 1;
0af11b59 894 else if (relocatable /* Relocatable file. */
d8121479
L		 895 && (flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
896 keep = 1;
16b2b71c
NC		 897 else if (bfd_decode_symclass (sym) == 'I')
898 /* Global symbols in $idata sections need to be retained
b34976b6 899 even if relocatable is FALSE. External users of the
16b2b71c
NC		 900 library containing the $idata section may reference these
901 symbols. */
af3bdff7 902 keep = 1;
252b5132
RH		 903 else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */
904 || (flags & BSF_WEAK) != 0
24e01a36 905 || undefined
252b5132
RH		 906 || bfd_is_com_section (bfd_get_section (sym)))
907 keep = strip_symbols != STRIP_UNNEEDED;
908 else if ((flags & BSF_DEBUGGING) != 0) /* Debugging symbol. */
909 keep = (strip_symbols != STRIP_DEBUG
910 && strip_symbols != STRIP_UNNEEDED
911 && ! convert_debugging);
082b7297 912 else if (bfd_coff_get_comdat_section (abfd, bfd_get_section (sym)))
af3bdff7
NC		 913 /* COMDAT sections store special information in local
914 symbols, so we cannot risk stripping any of them. */
915 keep = 1;
252b5132
RH		 916 else /* Local symbol. */
917 keep = (strip_symbols != STRIP_UNNEEDED
918 && (discard_locals != LOCALS_ALL
919 && (discard_locals != LOCALS_START_L
920 || ! bfd_is_local_label (abfd, sym))));
921
922 if (keep && is_specified_symbol (name, strip_specific_list))
923 keep = 0;
bcf32829
JB		 924 if (keep
925 && !(flags & BSF_KEEP)
926 && is_specified_symbol (name, strip_unneeded_list))
927 keep = 0;
252b5132
RH		 928 if (!keep && is_specified_symbol (name, keep_specific_list))
929 keep = 1;
930 if (keep && is_strip_section (abfd, bfd_get_section (sym)))
931 keep = 0;
e0c60db2 932
7b4a0685 933 if (keep)
252b5132 934 {
7b4a0685
NC		 935 if ((flags & BSF_GLOBAL) != 0
936 && (weaken || is_specified_symbol (name, weaken_specific_list)))
937 {
938 sym->flags &= ~ BSF_GLOBAL;
939 sym->flags |= BSF_WEAK;
940 }
252b5132 941
7b4a0685
NC		 942 if (!undefined
943 && (flags & (BSF_GLOBAL | BSF_WEAK))
944 && (is_specified_symbol (name, localize_specific_list)
945 || (keepglobal_specific_list != NULL
946 && ! is_specified_symbol (name, keepglobal_specific_list))))
947 {
948 sym->flags &= ~ (BSF_GLOBAL | BSF_WEAK);
949 sym->flags |= BSF_LOCAL;
950 }
951
952 if (!undefined
953 && (flags & BSF_LOCAL)
954 && is_specified_symbol (name, globalize_specific_list))
955 {
956 sym->flags &= ~ BSF_LOCAL;
957 sym->flags |= BSF_GLOBAL;
958 }
959
960 to[dst_count++] = sym;
961 }
252b5132
RH		 962 }
963
964 to[dst_count] = NULL;
965
966 return dst_count;
967}
968
594ef5db
NC		 969/* Find the redefined name of symbol SOURCE. */
970
57938635 971static const char *
84e2f313 972lookup_sym_redefinition (const char *source)
57938635 973{
57938635
AM		 974 struct redefine_node *list;
975
57938635 976 for (list = redefine_sym_list; list != NULL; list = list->next)
594ef5db
NC		 977 if (strcmp (source, list->source) == 0)
978 return list->target;
979
980 return source;
57938635
AM		 981}
982
594ef5db 983/* Add a node to a symbol redefine list. */
57938635
AM		 984
985static void
84e2f313 986redefine_list_append (const char *cause, const char *source, const char *target)
57938635
AM		 987{
988 struct redefine_node **p;
989 struct redefine_node *list;
990 struct redefine_node *new_node;
991
992 for (p = &redefine_sym_list; (list = *p) != NULL; p = &list->next)
993 {
994 if (strcmp (source, list->source) == 0)
594ef5db 995 fatal (_("%s: Multiple redefinition of symbol \"%s\""),
92991082 996 cause, source);
57938635
AM		 997
998 if (strcmp (target, list->target) == 0)
594ef5db 999 fatal (_("%s: Symbol \"%s\" is target of more than one redefinition"),
92991082 1000 cause, target);
57938635
AM		 1001 }
1002
d3ba0551 1003 new_node = xmalloc (sizeof (struct redefine_node));
57938635
AM		 1004
1005 new_node->source = strdup (source);
1006 new_node->target = strdup (target);
1007 new_node->next = NULL;
1008
1009 *p = new_node;
1010}
1011
92991082
JT		 1012/* Handle the --redefine-syms option. Read lines containing "old new"
1013 from the file, and add them to the symbol redefine list. */
1014
2593f09a 1015static void
84e2f313 1016add_redefine_syms_file (const char *filename)
92991082
JT		 1017{
1018 FILE *file;
1019 char *buf;
84e2f313
NC		 1020 size_t bufsize;
1021 size_t len;
1022 size_t outsym_off;
92991082
JT		 1023 int c, lineno;
1024
1025 file = fopen (filename, "r");
d3ba0551 1026 if (file == NULL)
92991082
JT		 1027 fatal (_("couldn't open symbol redefinition file %s (error: %s)"),
1028 filename, strerror (errno));
1029
1030 bufsize = 100;
d3ba0551 1031 buf = xmalloc (bufsize);
92991082
JT		 1032
1033 lineno = 1;
1034 c = getc (file);
1035 len = 0;
1036 outsym_off = 0;
1037 while (c != EOF)
1038 {
1039 /* Collect the input symbol name. */
1040 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1041 {
1042 if (c == '#')
1043 goto comment;
1044 buf[len++] = c;
1045 if (len >= bufsize)
1046 {
1047 bufsize *= 2;
1048 buf = xrealloc (buf, bufsize);
1049 }
1050 c = getc (file);
1051 }
1052 buf[len++] = '\0';
1053 if (c == EOF)
1054 break;
1055
1056 /* Eat white space between the symbol names. */
1057 while (IS_WHITESPACE (c))
1058 c = getc (file);
1059 if (c == '#' || IS_LINE_TERMINATOR (c))
1060 goto comment;
1061 if (c == EOF)
1062 break;
1063
1064 /* Collect the output symbol name. */
1065 outsym_off = len;
1066 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1067 {
1068 if (c == '#')
1069 goto comment;
1070 buf[len++] = c;
1071 if (len >= bufsize)
1072 {
1073 bufsize *= 2;
1074 buf = xrealloc (buf, bufsize);
1075 }
1076 c = getc (file);
1077 }
1078 buf[len++] = '\0';
1079 if (c == EOF)
1080 break;
1081
1082 /* Eat white space at end of line. */
1083 while (! IS_LINE_TERMINATOR(c) && c != EOF && IS_WHITESPACE (c))
1084 c = getc (file);
1085 if (c == '#')
1086 goto comment;
1087 /* Handle \r\n. */
1088 if ((c == '\r' && (c = getc (file)) == '\n')
1089 || c == '\n' || c == EOF)
1090 {
1091 end_of_line:
1092 /* Append the redefinition to the list. */
1093 if (buf[0] != '\0')
1094 redefine_list_append (filename, &buf[0], &buf[outsym_off]);
1095
1096 lineno++;
1097 len = 0;
1098 outsym_off = 0;
1099 if (c == EOF)
1100 break;
1101 c = getc (file);
1102 continue;
1103 }
1104 else
d412a550 1105 fatal (_("%s:%d: garbage found at end of line"), filename, lineno);
92991082
JT		 1106 comment:
1107 if (len != 0 && (outsym_off == 0 || outsym_off == len))
d412a550 1108 fatal (_("%s:%d: missing new symbol name"), filename, lineno);
92991082
JT		 1109 buf[len++] = '\0';
1110
1111 /* Eat the rest of the line and finish it. */
1112 while (c != '\n' && c != EOF)
1113 c = getc (file);
1114 goto end_of_line;
1115 }
1116
1117 if (len != 0)
d412a550 1118 fatal (_("%s:%d: premature end of file"), filename, lineno);
92991082
JT		 1119
1120 free (buf);
1121}
1122
950d48e7 1123/* Copy object file IBFD onto OBFD.
5b8c74e6 1124 Returns TRUE upon success, FALSE otherwise. */
252b5132 1125
950d48e7 1126static bfd_boolean
84e2f313 1127copy_object (bfd *ibfd, bfd *obfd)
252b5132
RH		 1128{
1129 bfd_vma start;
1130 long symcount;
1131 asection **osections = NULL;
84e2f313 1132 asection *gnu_debuglink_section = NULL;
252b5132
RH		 1133 bfd_size_type *gaps = NULL;
1134 bfd_size_type max_gap = 0;
1135 long symsize;
84e2f313 1136 void *dhandle;
66491ebc
AM		 1137 enum bfd_architecture iarch;
1138 unsigned int imach;
252b5132 1139
23719f39
NC		 1140 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1141 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1142 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
950d48e7 1143 fatal (_("Unable to change endianness of input file(s)"));
252b5132
RH		 1144
1145 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
950d48e7
NC		 1146 {
1147 bfd_nonfatal (bfd_get_filename (obfd));
1148 return FALSE;
1149 }
252b5132
RH		 1150
1151 if (verbose)
1152 printf (_("copy from %s(%s) to %s(%s)\n"),
1153 bfd_get_filename (ibfd), bfd_get_target (ibfd),
1154 bfd_get_filename (obfd), bfd_get_target (obfd));
1155
1156 if (set_start_set)
1157 start = set_start;
1158 else
1159 start = bfd_get_start_address (ibfd);
1160 start += change_start;
1161
0af11b59
KH		 1162 /* Neither the start address nor the flags
1163 need to be set for a core file. */
4dd67f29
MS		 1164 if (bfd_get_format (obfd) != bfd_core)
1165 {
4087920c
MR		 1166 flagword flags;
1167
1168 flags = bfd_get_file_flags (ibfd);
1169 flags |= bfd_flags_to_set;
1170 flags &= ~bfd_flags_to_clear;
1171 flags &= bfd_applicable_file_flags (obfd);
1172
4dd67f29 1173 if (!bfd_set_start_address (obfd, start)
4087920c 1174 || !bfd_set_file_flags (obfd, flags))
950d48e7
NC		 1175 {
1176 bfd_nonfatal (bfd_get_filename (ibfd));
1177 return FALSE;
1178 }
4dd67f29 1179 }
252b5132 1180
594ef5db 1181 /* Copy architecture of input file to output file. */
66491ebc
AM		 1182 iarch = bfd_get_arch (ibfd);
1183 imach = bfd_get_mach (ibfd);
1184 if (!bfd_set_arch_mach (obfd, iarch, imach)
212a3c4d
L		 1185 && (ibfd->target_defaulted
1186 || bfd_get_arch (ibfd) != bfd_get_arch (obfd)))
f57a841a
NC		 1187 {
1188 if (bfd_get_arch (ibfd) == bfd_arch_unknown)
1189 fatal (_("Unable to recognise the format of the input file %s"),
1190 bfd_get_filename (ibfd));
1191 else
1192 {
1193 non_fatal (_("Warning: Output file cannot represent architecture %s"),
1194 bfd_printable_arch_mach (bfd_get_arch (ibfd),
1195 bfd_get_mach (ibfd)));
950d48e7 1196 return FALSE;
f57a841a
NC		 1197 }
1198 }
57938635 1199
252b5132 1200 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
950d48e7
NC		 1201 {
1202 bfd_nonfatal (bfd_get_filename (ibfd));
1203 return FALSE;
1204 }
252b5132
RH		 1205
1206 if (isympp)
1207 free (isympp);
57938635 1208
252b5132
RH		 1209 if (osympp != isympp)
1210 free (osympp);
1211
1212 /* BFD mandates that all output sections be created and sizes set before
1213 any output is done. Thus, we traverse all sections multiple times. */
d3ba0551 1214 bfd_map_over_sections (ibfd, setup_section, obfd);
252b5132 1215
80fccad2
BW		 1216 setup_bfd_headers (ibfd, obfd);
1217
252b5132
RH		 1218 if (add_sections != NULL)
1219 {
1220 struct section_add *padd;
1221 struct section_list *pset;
1222
1223 for (padd = add_sections; padd != NULL; padd = padd->next)
1224 {
2593f09a
NC		 1225 flagword flags;
1226
252b5132
RH		 1227 padd->section = bfd_make_section (obfd, padd->name);
1228 if (padd->section == NULL)
1229 {
1230 non_fatal (_("can't create section `%s': %s"),
1231 padd->name, bfd_errmsg (bfd_get_error ()));
950d48e7 1232 return FALSE;
252b5132 1233 }
252b5132 1234
2593f09a 1235 if (! bfd_set_section_size (obfd, padd->section, padd->size))
950d48e7
NC		 1236 {
1237 bfd_nonfatal (bfd_get_filename (obfd));
1238 return FALSE;
1239 }
252b5132 1240
2593f09a
NC		 1241 pset = find_section_list (padd->name, FALSE);
1242 if (pset != NULL)
1243 pset->used = TRUE;
57938635 1244
2593f09a
NC		 1245 if (pset != NULL && pset->set_flags)
1246 flags = pset->flags | SEC_HAS_CONTENTS;
1247 else
1248 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
252b5132 1249
2593f09a 1250 if (! bfd_set_section_flags (obfd, padd->section, flags))
950d48e7
NC		 1251 {
1252 bfd_nonfatal (bfd_get_filename (obfd));
1253 return FALSE;
1254 }
57938635 1255
2593f09a
NC		 1256 if (pset != NULL)
1257 {
1258 if (pset->change_vma != CHANGE_IGNORE)
84e2f313
NC		 1259 if (! bfd_set_section_vma (obfd, padd->section,
1260 pset->vma_val))
950d48e7
NC		 1261 {
1262 bfd_nonfatal (bfd_get_filename (obfd));
1263 return FALSE;
1264 }
57938635 1265
2593f09a
NC		 1266 if (pset->change_lma != CHANGE_IGNORE)
1267 {
1268 padd->section->lma = pset->lma_val;
950d48e7 1269
2593f09a
NC		 1270 if (! bfd_set_section_alignment
1271 (obfd, padd->section,
1272 bfd_section_alignment (obfd, padd->section)))
950d48e7
NC		 1273 {
1274 bfd_nonfatal (bfd_get_filename (obfd));
1275 return FALSE;
1276 }
252b5132
RH		 1277 }
1278 }
1279 }
1280 }
1281
2593f09a
NC		 1282 if (gnu_debuglink_filename != NULL)
1283 {
84e2f313
NC		 1284 gnu_debuglink_section = bfd_create_gnu_debuglink_section
1285 (obfd, gnu_debuglink_filename);
e7c81c25
NC		 1286
1287 if (gnu_debuglink_section == NULL)
950d48e7
NC		 1288 {
1289 bfd_nonfatal (gnu_debuglink_filename);
1290 return FALSE;
1291 }
1292 }
1293
1294 if (bfd_count_sections (obfd) == 0)
1295 {
1296 non_fatal (_("there are no sections to be copied!"));
1297 return FALSE;
2593f09a
NC		 1298 }
1299
252b5132
RH		 1300 if (gap_fill_set || pad_to_set)
1301 {
1302 asection **set;
1303 unsigned int c, i;
1304
1305 /* We must fill in gaps between the sections and/or we must pad
1306 the last section to a specified address. We do this by
1307 grabbing a list of the sections, sorting them by VMA, and
1308 increasing the section sizes as required to fill the gaps.
1309 We write out the gap contents below. */
1310
1311 c = bfd_count_sections (obfd);
d3ba0551 1312 osections = xmalloc (c * sizeof (asection *));
252b5132 1313 set = osections;
d3ba0551 1314 bfd_map_over_sections (obfd, get_sections, &set);
252b5132
RH		 1315
1316 qsort (osections, c, sizeof (asection *), compare_section_lma);
1317
d3ba0551 1318 gaps = xmalloc (c * sizeof (bfd_size_type));
252b5132
RH		 1319 memset (gaps, 0, c * sizeof (bfd_size_type));
1320
1321 if (gap_fill_set)
1322 {
1323 for (i = 0; i < c - 1; i++)
1324 {
1325 flagword flags;
1326 bfd_size_type size;
1327 bfd_vma gap_start, gap_stop;
1328
1329 flags = bfd_get_section_flags (obfd, osections[i]);
1330 if ((flags & SEC_HAS_CONTENTS) == 0
1331 || (flags & SEC_LOAD) == 0)
1332 continue;
1333
1334 size = bfd_section_size (obfd, osections[i]);
1335 gap_start = bfd_section_lma (obfd, osections[i]) + size;
1336 gap_stop = bfd_section_lma (obfd, osections[i + 1]);
1337 if (gap_start < gap_stop)
1338 {
1339 if (! bfd_set_section_size (obfd, osections[i],
1340 size + (gap_stop - gap_start)))
1341 {
1342 non_fatal (_("Can't fill gap after %s: %s"),
0af11b59
KH		 1343 bfd_get_section_name (obfd, osections[i]),
1344 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 1345 status = 1;
1346 break;
1347 }
1348 gaps[i] = gap_stop - gap_start;
1349 if (max_gap < gap_stop - gap_start)
1350 max_gap = gap_stop - gap_start;
1351 }
1352 }
1353 }
1354
1355 if (pad_to_set)
1356 {
1357 bfd_vma lma;
1358 bfd_size_type size;
1359
1360 lma = bfd_section_lma (obfd, osections[c - 1]);
1361 size = bfd_section_size (obfd, osections[c - 1]);
1362 if (lma + size < pad_to)
1363 {
1364 if (! bfd_set_section_size (obfd, osections[c - 1],
1365 pad_to - lma))
1366 {
1367 non_fatal (_("Can't add padding to %s: %s"),
0af11b59
KH		 1368 bfd_get_section_name (obfd, osections[c - 1]),
1369 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 1370 status = 1;
1371 }
1372 else
1373 {
1374 gaps[c - 1] = pad_to - (lma + size);
1375 if (max_gap < pad_to - (lma + size))
1376 max_gap = pad_to - (lma + size);
1377 }
1378 }
1379 }
1380 }
1381
594ef5db
NC		 1382 /* Symbol filtering must happen after the output sections
1383 have been created, but before their contents are set. */
252b5132
RH		 1384 dhandle = NULL;
1385 symsize = bfd_get_symtab_upper_bound (ibfd);
1386 if (symsize < 0)
950d48e7
NC		 1387 {
1388 bfd_nonfatal (bfd_get_filename (ibfd));
1389 return FALSE;
1390 }
57938635 1391
d3ba0551 1392 osympp = isympp = xmalloc (symsize);
252b5132
RH		 1393 symcount = bfd_canonicalize_symtab (ibfd, isympp);
1394 if (symcount < 0)
950d48e7
NC		 1395 {
1396 bfd_nonfatal (bfd_get_filename (ibfd));
1397 return FALSE;
1398 }
57938635 1399
252b5132
RH		 1400 if (convert_debugging)
1401 dhandle = read_debugging_info (ibfd, isympp, symcount);
57938635
AM		 1402
1403 if (strip_symbols == STRIP_DEBUG
252b5132
RH		 1404 || strip_symbols == STRIP_ALL
1405 || strip_symbols == STRIP_UNNEEDED
ed1653a7 1406 || strip_symbols == STRIP_NONDEBUG
252b5132
RH		 1407 || discard_locals != LOCALS_UNDEF
1408 || strip_specific_list != NULL
1409 || keep_specific_list != NULL
1410 || localize_specific_list != NULL
7b4a0685 1411 || globalize_specific_list != NULL
16b2b71c 1412 || keepglobal_specific_list != NULL
252b5132 1413 || weaken_specific_list != NULL
d7fb0dd2 1414 || prefix_symbols_string
252b5132 1415 || sections_removed
f91ea849 1416 || sections_copied
252b5132
RH		 1417 || convert_debugging
1418 || change_leading_char
1419 || remove_leading_char
57938635 1420 || redefine_sym_list
252b5132
RH		 1421 || weaken)
1422 {
1423 /* Mark symbols used in output relocations so that they
1424 are kept, even if they are local labels or static symbols.
57938635 1425
252b5132
RH		 1426 Note we iterate over the input sections examining their
1427 relocations since the relocations for the output sections
1428 haven't been set yet. mark_symbols_used_in_relocations will
1429 ignore input sections which have no corresponding output
1430 section. */
1431 if (strip_symbols != STRIP_ALL)
1432 bfd_map_over_sections (ibfd,
1433 mark_symbols_used_in_relocations,
d3ba0551
AM		 1434 isympp);
1435 osympp = xmalloc ((symcount + 1) * sizeof (asymbol *));
252b5132
RH		 1436 symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
1437 }
1438
1439 if (convert_debugging && dhandle != NULL)
1440 {
1441 if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
1442 {
1443 status = 1;
950d48e7 1444 return FALSE;
252b5132
RH		 1445 }
1446 }
1447
1448 bfd_set_symtab (obfd, osympp, symcount);
1449
1450 /* This has to happen after the symbol table has been set. */
d3ba0551 1451 bfd_map_over_sections (ibfd, copy_section, obfd);
252b5132
RH		 1452
1453 if (add_sections != NULL)
1454 {
1455 struct section_add *padd;
1456
1457 for (padd = add_sections; padd != NULL; padd = padd->next)
1458 {
d3ba0551
AM		 1459 if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
1460 0, padd->size))
950d48e7
NC		 1461 {
1462 bfd_nonfatal (bfd_get_filename (obfd));
1463 return FALSE;
1464 }
252b5132
RH		 1465 }
1466 }
1467
e7c81c25
NC		 1468 if (gnu_debuglink_filename != NULL)
1469 {
1470 if (! bfd_fill_in_gnu_debuglink_section
1471 (obfd, gnu_debuglink_section, gnu_debuglink_filename))
950d48e7
NC		 1472 {
1473 bfd_nonfatal (gnu_debuglink_filename);
1474 return FALSE;
1475 }
e7c81c25
NC		 1476 }
1477
252b5132
RH		 1478 if (gap_fill_set || pad_to_set)
1479 {
1480 bfd_byte *buf;
1481 int c, i;
1482
1483 /* Fill in the gaps. */
252b5132
RH		 1484 if (max_gap > 8192)
1485 max_gap = 8192;
d3ba0551
AM		 1486 buf = xmalloc (max_gap);
1487 memset (buf, gap_fill, max_gap);
252b5132
RH		 1488
1489 c = bfd_count_sections (obfd);
1490 for (i = 0; i < c; i++)
1491 {
1492 if (gaps[i] != 0)
1493 {
1494 bfd_size_type left;
1495 file_ptr off;
1496
1497 left = gaps[i];
1498 off = bfd_section_size (obfd, osections[i]) - left;
594ef5db 1499
252b5132
RH		 1500 while (left > 0)
1501 {
1502 bfd_size_type now;
1503
1504 if (left > 8192)
1505 now = 8192;
1506 else
1507 now = left;
1508
1509 if (! bfd_set_section_contents (obfd, osections[i], buf,
1510 off, now))
950d48e7
NC		 1511 {
1512 bfd_nonfatal (bfd_get_filename (obfd));
1513 return FALSE;
1514 }
252b5132
RH		 1515
1516 left -= now;
1517 off += now;
1518 }
1519 }
1520 }
1521 }
1522
1523 /* Allow the BFD backend to copy any private data it understands
1524 from the input BFD to the output BFD. This is done last to
1525 permit the routine to look at the filtered symbol table, which is
1526 important for the ECOFF code at least. */
ed1653a7
NC		 1527 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
1528 && strip_symbols == STRIP_NONDEBUG)
1529 /* Do not copy the private data when creating an ELF format
1530 debug info file. We do not want the program headers. */
1531 ;
1532 else if (! bfd_copy_private_bfd_data (ibfd, obfd))
252b5132
RH		 1533 {
1534 non_fatal (_("%s: error copying private BFD data: %s"),
1535 bfd_get_filename (obfd),
1536 bfd_errmsg (bfd_get_error ()));
950d48e7 1537 return FALSE;
252b5132 1538 }
1ae8b3d2
AO		 1539
1540 /* Switch to the alternate machine code. We have to do this at the
1541 very end, because we only initialize the header when we create
1542 the first section. */
950d48e7
NC		 1543 if (use_alt_mach_code != 0
1544 && ! bfd_alt_mach_code (obfd, use_alt_mach_code))
1545 non_fatal (_("unknown alternate machine code, ignored"));
1546
1547 return TRUE;
252b5132
RH		 1548}
1549
4c168fa3
AM		 1550#undef MKDIR
1551#if defined (_WIN32) && !defined (__CYGWIN32__)
1552#define MKDIR(DIR, MODE) mkdir (DIR)
1553#else
1554#define MKDIR(DIR, MODE) mkdir (DIR, MODE)
1555#endif
1556
252b5132
RH		 1557/* Read each archive element in turn from IBFD, copy the
1558 contents to temp file, and keep the temp file handle. */
1559
1560static void
84e2f313 1561copy_archive (bfd *ibfd, bfd *obfd, const char *output_target)
252b5132
RH		 1562{
1563 struct name_list
1564 {
1565 struct name_list *next;
4c168fa3 1566 const char *name;
252b5132
RH		 1567 bfd *obfd;
1568 } *list, *l;
1569 bfd **ptr = &obfd->archive_head;
1570 bfd *this_element;
1571 char *dir = make_tempname (bfd_get_filename (obfd));
1572
1573 /* Make a temp directory to hold the contents. */
4c168fa3 1574 if (MKDIR (dir, 0700) != 0)
84e2f313
NC		 1575 fatal (_("cannot mkdir %s for archive copying (error: %s)"),
1576 dir, strerror (errno));
1577
252b5132
RH		 1578 obfd->has_armap = ibfd->has_armap;
1579
1580 list = NULL;
1581
1582 this_element = bfd_openr_next_archived_file (ibfd, NULL);
594ef5db 1583
b667df2e
AM		 1584 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1585 RETURN_NONFATAL (bfd_get_filename (obfd));
1586
d3ba0551 1587 while (!status && this_element != NULL)
252b5132 1588 {
4c168fa3
AM		 1589 char *output_name;
1590 bfd *output_bfd;
252b5132 1591 bfd *last_element;
8066d1a2
AS		 1592 struct stat buf;
1593 int stat_status = 0;
950d48e7 1594 bfd_boolean delete = TRUE;
8066d1a2 1595
4c168fa3
AM		 1596 /* Create an output file for this member. */
1597 output_name = concat (dir, "/",
1598 bfd_get_filename (this_element), (char *) 0);
1599
1600 /* If the file already exists, make another temp dir. */
1601 if (stat (output_name, &buf) >= 0)
1602 {
1603 output_name = make_tempname (output_name);
1604 if (MKDIR (output_name, 0700) != 0)
84e2f313
NC		 1605 fatal (_("cannot mkdir %s for archive copying (error: %s)"),
1606 output_name, strerror (errno));
1607
d3ba0551 1608 l = xmalloc (sizeof (struct name_list));
4c168fa3
AM		 1609 l->name = output_name;
1610 l->next = list;
1611 l->obfd = NULL;
1612 list = l;
1613 output_name = concat (output_name, "/",
1614 bfd_get_filename (this_element), (char *) 0);
1615 }
1616
1617 output_bfd = bfd_openw (output_name, output_target);
8066d1a2
AS		 1618 if (preserve_dates)
1619 {
1620 stat_status = bfd_stat_arch_elt (this_element, &buf);
594ef5db 1621
8066d1a2
AS		 1622 if (stat_status != 0)
1623 non_fatal (_("internal stat error on %s"),
1624 bfd_get_filename (this_element));
1625 }
252b5132 1626
d3ba0551 1627 l = xmalloc (sizeof (struct name_list));
252b5132
RH		 1628 l->name = output_name;
1629 l->next = list;
1630 list = l;
1631
d3ba0551 1632 if (output_bfd == NULL)
252b5132
RH		 1633 RETURN_NONFATAL (output_name);
1634
b34976b6 1635 if (bfd_check_format (this_element, bfd_object))
950d48e7 1636 delete = ! copy_object (this_element, output_bfd);
252b5132
RH		 1637
1638 if (!bfd_close (output_bfd))
1639 {
1640 bfd_nonfatal (bfd_get_filename (output_bfd));
0af11b59 1641 /* Error in new object file. Don't change archive. */
252b5132
RH		 1642 status = 1;
1643 }
1644
950d48e7
NC		 1645 if (delete)
1646 {
1647 unlink (output_name);
1648 status = 1;
1649 }
1650 else
1651 {
1652 if (preserve_dates && stat_status == 0)
1653 set_times (output_name, &buf);
8066d1a2 1654
950d48e7
NC		 1655 /* Open the newly output file and attach to our list. */
1656 output_bfd = bfd_openr (output_name, output_target);
252b5132 1657
950d48e7 1658 l->obfd = output_bfd;
252b5132 1659
950d48e7
NC		 1660 *ptr = output_bfd;
1661 ptr = &output_bfd->next;
252b5132 1662
950d48e7 1663 last_element = this_element;
252b5132 1664
950d48e7 1665 this_element = bfd_openr_next_archived_file (ibfd, last_element);
252b5132 1666
950d48e7
NC		 1667 bfd_close (last_element);
1668 }
252b5132 1669 }
d3ba0551 1670 *ptr = NULL;
252b5132
RH		 1671
1672 if (!bfd_close (obfd))
1673 RETURN_NONFATAL (bfd_get_filename (obfd));
1674
1675 if (!bfd_close (ibfd))
1676 RETURN_NONFATAL (bfd_get_filename (ibfd));
1677
1678 /* Delete all the files that we opened. */
1679 for (l = list; l != NULL; l = l->next)
1680 {
4c168fa3
AM		 1681 if (l->obfd == NULL)
1682 rmdir (l->name);
1683 else
1684 {
1685 bfd_close (l->obfd);
1686 unlink (l->name);
1687 }
252b5132
RH		 1688 }
1689 rmdir (dir);
1690}
1691
1692/* The top-level control. */
1693
1694static void
84e2f313
NC		 1695copy_file (const char *input_filename, const char *output_filename,
1696 const char *input_target, const char *output_target)
252b5132
RH		 1697{
1698 bfd *ibfd;
49c12576
AM		 1699 char **obj_matching;
1700 char **core_matching;
252b5132 1701
f24ddbdd
NC		 1702 if (get_file_size (input_filename) < 1)
1703 {
ac559f4a 1704 non_fatal (_("error: the input file '%s' is empty"), input_filename);
f24ddbdd
NC		 1705 status = 1;
1706 return;
1707 }
1708
252b5132
RH		 1709 /* To allow us to do "strip *" without dying on the first
1710 non-object file, failures are nonfatal. */
252b5132
RH		 1711 ibfd = bfd_openr (input_filename, input_target);
1712 if (ibfd == NULL)
1713 RETURN_NONFATAL (input_filename);
1714
1715 if (bfd_check_format (ibfd, bfd_archive))
1716 {
1717 bfd *obfd;
1718
1719 /* bfd_get_target does not return the correct value until
1720 bfd_check_format succeeds. */
1721 if (output_target == NULL)
1722 output_target = bfd_get_target (ibfd);
1723
1724 obfd = bfd_openw (output_filename, output_target);
1725 if (obfd == NULL)
1726 RETURN_NONFATAL (output_filename);
1727
1728 copy_archive (ibfd, obfd, output_target);
1729 }
49c12576 1730 else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
252b5132
RH		 1731 {
1732 bfd *obfd;
950d48e7 1733 bfd_boolean delete;
49c12576 1734 do_copy:
950d48e7 1735
252b5132
RH		 1736 /* bfd_get_target does not return the correct value until
1737 bfd_check_format succeeds. */
1738 if (output_target == NULL)
1739 output_target = bfd_get_target (ibfd);
1740
1741 obfd = bfd_openw (output_filename, output_target);
1742 if (obfd == NULL)
1743 RETURN_NONFATAL (output_filename);
1744
950d48e7 1745 delete = ! copy_object (ibfd, obfd);
252b5132
RH		 1746
1747 if (!bfd_close (obfd))
1748 RETURN_NONFATAL (output_filename);
1749
1750 if (!bfd_close (ibfd))
1751 RETURN_NONFATAL (input_filename);
950d48e7
NC		 1752
1753 if (delete)
1754 {
bb14f524 1755 unlink_if_ordinary (output_filename);
950d48e7
NC		 1756 status = 1;
1757 }
252b5132
RH		 1758 }
1759 else
1760 {
49c12576
AM		 1761 bfd_error_type obj_error = bfd_get_error ();
1762 bfd_error_type core_error;
b34976b6 1763
49c12576
AM		 1764 if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
1765 {
1766 /* This probably can't happen.. */
1767 if (obj_error == bfd_error_file_ambiguously_recognized)
1768 free (obj_matching);
1769 goto do_copy;
1770 }
1771
1772 core_error = bfd_get_error ();
1773 /* Report the object error in preference to the core error. */
1774 if (obj_error != core_error)
1775 bfd_set_error (obj_error);
1776
252b5132 1777 bfd_nonfatal (input_filename);
57938635 1778
49c12576
AM		 1779 if (obj_error == bfd_error_file_ambiguously_recognized)
1780 {
1781 list_matching_formats (obj_matching);
1782 free (obj_matching);
1783 }
1784 if (core_error == bfd_error_file_ambiguously_recognized)
252b5132 1785 {
49c12576
AM		 1786 list_matching_formats (core_matching);
1787 free (core_matching);
252b5132 1788 }
57938635 1789
252b5132
RH		 1790 status = 1;
1791 }
1792}
1793
594ef5db
NC		 1794/* Add a name to the section renaming list. */
1795
1796static void
84e2f313
NC		 1797add_section_rename (const char * old_name, const char * new_name,
1798 flagword flags)
594ef5db
NC		 1799{
1800 section_rename * rename;
1801
1802 /* Check for conflicts first. */
1803 for (rename = section_rename_list; rename != NULL; rename = rename->next)
1804 if (strcmp (rename->old_name, old_name) == 0)
1805 {
1806 /* Silently ignore duplicate definitions. */
1807 if (strcmp (rename->new_name, new_name) == 0
1808 && rename->flags == flags)
1809 return;
0af11b59 1810
594ef5db
NC		 1811 fatal (_("Multiple renames of section %s"), old_name);
1812 }
1813
d3ba0551 1814 rename = xmalloc (sizeof (* rename));
594ef5db
NC		 1815
1816 rename->old_name = old_name;
1817 rename->new_name = new_name;
1818 rename->flags = flags;
1819 rename->next = section_rename_list;
0af11b59 1820
594ef5db
NC		 1821 section_rename_list = rename;
1822}
1823
1824/* Check the section rename list for a new name of the input section
1825 ISECTION. Return the new name if one is found.
1826 Also set RETURNED_FLAGS to the flags to be used for this section. */
1827
1828static const char *
84e2f313
NC		 1829find_section_rename (bfd * ibfd ATTRIBUTE_UNUSED, sec_ptr isection,
1830 flagword * returned_flags)
594ef5db
NC		 1831{
1832 const char * old_name = bfd_section_name (ibfd, isection);
1833 section_rename * rename;
1834
1835 /* Default to using the flags of the input section. */
1836 * returned_flags = bfd_get_section_flags (ibfd, isection);
1837
1838 for (rename = section_rename_list; rename != NULL; rename = rename->next)
1839 if (strcmp (rename->old_name, old_name) == 0)
1840 {
1841 if (rename->flags != (flagword) -1)
1842 * returned_flags = rename->flags;
1843
1844 return rename->new_name;
1845 }
1846
1847 return old_name;
1848}
1849
80fccad2
BW		 1850/* Once each of the sections is copied, we may still need to do some
1851 finalization work for private section headers. Do that here. */
1852
1853static void
1854setup_bfd_headers (bfd *ibfd, bfd *obfd)
1855{
1856 const char *err;
1857
1858 /* Allow the BFD backend to copy any private data it understands
1859 from the input section to the output section. */
1860 if (! bfd_copy_private_header_data (ibfd, obfd))
1861 {
1862 err = _("private header data");
1863 goto loser;
1864 }
1865
1866 /* All went well. */
1867 return;
1868
1869loser:
1870 non_fatal (_("%s: error in %s: %s"),
1871 bfd_get_filename (ibfd),
1872 err, bfd_errmsg (bfd_get_error ()));
1873 status = 1;
1874}
1875
594ef5db
NC		 1876/* Create a section in OBFD with the same
1877 name and attributes as ISECTION in IBFD. */
252b5132
RH		 1878
1879static void
84e2f313 1880setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
252b5132 1881{
d3ba0551 1882 bfd *obfd = obfdarg;
252b5132
RH		 1883 struct section_list *p;
1884 sec_ptr osection;
1885 bfd_size_type size;
1886 bfd_vma vma;
1887 bfd_vma lma;
1888 flagword flags;
1a89cc7d 1889 const char *err;
594ef5db 1890 const char * name;
d7fb0dd2 1891 char *prefix = NULL;
0af11b59 1892
2593f09a 1893 if (is_strip_section (ibfd, isection))
252b5132
RH		 1894 return;
1895
b34976b6 1896 p = find_section_list (bfd_section_name (ibfd, isection), FALSE);
252b5132 1897 if (p != NULL)
b34976b6 1898 p->used = TRUE;
252b5132 1899
594ef5db
NC		 1900 /* Get the, possibly new, name of the output section. */
1901 name = find_section_rename (ibfd, isection, & flags);
0af11b59 1902
d7fb0dd2 1903 /* Prefix sections. */
84e2f313
NC		 1904 if ((prefix_alloc_sections_string)
1905 && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
d7fb0dd2
NC		 1906 prefix = prefix_alloc_sections_string;
1907 else if (prefix_sections_string)
1908 prefix = prefix_sections_string;
1909
1910 if (prefix)
1911 {
1912 char *n;
1913
1914 n = xmalloc (strlen (prefix) + strlen (name) + 1);
1915 strcpy (n, prefix);
1916 strcat (n, name);
1917 name = n;
1918 }
66491ebc 1919
594ef5db 1920 osection = bfd_make_section_anyway (obfd, name);
57938635 1921
252b5132
RH		 1922 if (osection == NULL)
1923 {
1a89cc7d 1924 err = _("making");
252b5132
RH		 1925 goto loser;
1926 }
1927
1928 size = bfd_section_size (ibfd, isection);
1929 if (copy_byte >= 0)
1930 size = (size + interleave - 1) / interleave;
1931 if (! bfd_set_section_size (obfd, osection, size))
1932 {
1a89cc7d 1933 err = _("size");
252b5132
RH		 1934 goto loser;
1935 }
57938635 1936
252b5132
RH		 1937 vma = bfd_section_vma (ibfd, isection);
1938 if (p != NULL && p->change_vma == CHANGE_MODIFY)
1939 vma += p->vma_val;
1940 else if (p != NULL && p->change_vma == CHANGE_SET)
1941 vma = p->vma_val;
1942 else
1943 vma += change_section_address;
57938635 1944
252b5132
RH		 1945 if (! bfd_set_section_vma (obfd, osection, vma))
1946 {
1a89cc7d 1947 err = _("vma");
252b5132
RH		 1948 goto loser;
1949 }
1950
1951 lma = isection->lma;
1952 if ((p != NULL) && p->change_lma != CHANGE_IGNORE)
1953 {
1954 if (p->change_lma == CHANGE_MODIFY)
1955 lma += p->lma_val;
1956 else if (p->change_lma == CHANGE_SET)
1957 lma = p->lma_val;
1958 else
1959 abort ();
1960 }
1961 else
1962 lma += change_section_address;
57938635 1963
252b5132
RH		 1964 osection->lma = lma;
1965
1966 /* FIXME: This is probably not enough. If we change the LMA we
1967 may have to recompute the header for the file as well. */
b34976b6
AM		 1968 if (!bfd_set_section_alignment (obfd,
1969 osection,
1970 bfd_section_alignment (ibfd, isection)))
252b5132 1971 {
1a89cc7d 1972 err = _("alignment");
252b5132
RH		 1973 goto loser;
1974 }
1975
252b5132 1976 if (p != NULL && p->set_flags)
17978339 1977 flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
f0312d39
JJ		 1978 else if (strip_symbols == STRIP_NONDEBUG && (flags & SEC_ALLOC) != 0)
1979 {
1980 flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD);
1981 if (obfd->xvec->flavour == bfd_target_elf_flavour)
1982 elf_section_type (osection) = SHT_NOBITS;
1983 }
1984
252b5132
RH		 1985 if (!bfd_set_section_flags (obfd, osection, flags))
1986 {
1a89cc7d 1987 err = _("flags");
252b5132
RH		 1988 goto loser;
1989 }
1990
bc408b8a
JJ		 1991 /* Copy merge entity size. */
1992 osection->entsize = isection->entsize;
1993
252b5132
RH		 1994 /* This used to be mangle_section; we do here to avoid using
1995 bfd_get_section_by_name since some formats allow multiple
1996 sections with the same name. */
1997 isection->output_section = osection;
1998 isection->output_offset = 0;
1999
2000 /* Allow the BFD backend to copy any private data it understands
2001 from the input section to the output section. */
ed1653a7
NC		 2002 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
2003 && strip_symbols == STRIP_NONDEBUG)
2004 /* Do not copy the private data when creating an ELF format
2005 debug info file. We do not want the program headers. */
2006 ;
2007 else if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
252b5132 2008 {
1a89cc7d 2009 err = _("private data");
252b5132
RH		 2010 goto loser;
2011 }
2012
594ef5db 2013 /* All went well. */
252b5132
RH		 2014 return;
2015
2016loser:
2017 non_fatal (_("%s: section `%s': error in %s: %s"),
2018 bfd_get_filename (ibfd),
2019 bfd_section_name (ibfd, isection),
2020 err, bfd_errmsg (bfd_get_error ()));
2021 status = 1;
2022}
2023
2024/* Copy the data of input section ISECTION of IBFD
2025 to an output section with the same name in OBFD.
2026 If stripping then don't copy any relocation info. */
2027
2028static void
84e2f313 2029copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
252b5132 2030{
d3ba0551 2031 bfd *obfd = obfdarg;
252b5132
RH		 2032 struct section_list *p;
2033 arelent **relpp;
2034 long relcount;
2035 sec_ptr osection;
2036 bfd_size_type size;
2037 long relsize;
dc156bc0 2038 flagword flags;
252b5132 2039
594ef5db
NC		 2040 /* If we have already failed earlier on,
2041 do not keep on generating complaints now. */
252b5132
RH		 2042 if (status != 0)
2043 return;
57938635 2044
2593f09a 2045 if (is_strip_section (ibfd, isection))
e0c60db2 2046 return;
252b5132 2047
2593f09a 2048 flags = bfd_get_section_flags (ibfd, isection);
dc156bc0
AM		 2049 if ((flags & SEC_GROUP) != 0)
2050 return;
2051
252b5132 2052 osection = isection->output_section;
135dfb4a 2053 size = bfd_get_section_size (isection);
252b5132
RH		 2054
2055 if (size == 0 || osection == 0)
2056 return;
2057
2593f09a
NC		 2058 p = find_section_list (bfd_get_section_name (ibfd, isection), FALSE);
2059
0af11b59 2060 /* Core files do not need to be relocated. */
4dd67f29
MS		 2061 if (bfd_get_format (obfd) == bfd_core)
2062 relsize = 0;
2063 else
ed570f48
NC		 2064 {
2065 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
4dd67f29 2066
ed570f48
NC		 2067 if (relsize < 0)
2068 {
2069 /* Do not complain if the target does not support relocations. */
2070 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2071 relsize = 0;
2072 else
2073 RETURN_NONFATAL (bfd_get_filename (ibfd));
2074 }
2075 }
57938635 2076
252b5132 2077 if (relsize == 0)
d3ba0551 2078 bfd_set_reloc (obfd, osection, NULL, 0);
252b5132
RH		 2079 else
2080 {
d3ba0551 2081 relpp = xmalloc (relsize);
252b5132
RH		 2082 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
2083 if (relcount < 0)
2084 RETURN_NONFATAL (bfd_get_filename (ibfd));
57938635 2085
252b5132
RH		 2086 if (strip_symbols == STRIP_ALL)
2087 {
2088 /* Remove relocations which are not in
0af11b59 2089 keep_strip_specific_list. */
252b5132
RH		 2090 arelent **temp_relpp;
2091 long temp_relcount = 0;
2092 long i;
57938635 2093
d3ba0551 2094 temp_relpp = xmalloc (relsize);
252b5132 2095 for (i = 0; i < relcount; i++)
d3ba0551
AM		 2096 if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
2097 keep_specific_list))
252b5132
RH		 2098 temp_relpp [temp_relcount++] = relpp [i];
2099 relcount = temp_relcount;
2100 free (relpp);
2101 relpp = temp_relpp;
2102 }
e0c60db2 2103
d3ba0551 2104 bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
f0312d39
JJ		 2105 if (relcount == 0)
2106 free (relpp);
252b5132 2107 }
57938635 2108
0af11b59 2109 if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
4dd67f29 2110 && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
252b5132 2111 {
d3ba0551 2112 void *memhunk = xmalloc (size);
252b5132 2113
d3ba0551 2114 if (!bfd_get_section_contents (ibfd, isection, memhunk, 0, size))
252b5132
RH		 2115 RETURN_NONFATAL (bfd_get_filename (ibfd));
2116
57938635 2117 if (copy_byte >= 0)
5e675b72
AM		 2118 {
2119 /* Keep only every `copy_byte'th byte in MEMHUNK. */
2f01ffbf 2120 char *from = (char *) memhunk + copy_byte;
5e675b72 2121 char *to = memhunk;
2f01ffbf 2122 char *end = (char *) memhunk + size;
5e675b72
AM		 2123
2124 for (; from < end; from += interleave)
2125 *to++ = *from;
2126
2127 size = (size + interleave - 1 - copy_byte) / interleave;
2128 osection->lma /= interleave;
2129 }
252b5132 2130
d3ba0551 2131 if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
252b5132
RH		 2132 RETURN_NONFATAL (bfd_get_filename (obfd));
2133
2134 free (memhunk);
2135 }
2136 else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
2137 {
d3ba0551 2138 void *memhunk = xmalloc (size);
252b5132
RH		 2139
2140 /* We don't permit the user to turn off the SEC_HAS_CONTENTS
2141 flag--they can just remove the section entirely and add it
2142 back again. However, we do permit them to turn on the
2143 SEC_HAS_CONTENTS flag, and take it to mean that the section
2144 contents should be zeroed out. */
2145
2146 memset (memhunk, 0, size);
d3ba0551 2147 if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
252b5132
RH		 2148 RETURN_NONFATAL (bfd_get_filename (obfd));
2149 free (memhunk);
2150 }
2151}
2152
2153/* Get all the sections. This is used when --gap-fill or --pad-to is
2154 used. */
2155
2156static void
84e2f313 2157get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
252b5132 2158{
d3ba0551 2159 asection ***secppp = secppparg;
252b5132
RH		 2160
2161 **secppp = osection;
2162 ++(*secppp);
2163}
2164
2165/* Sort sections by VMA. This is called via qsort, and is used when
2166 --gap-fill or --pad-to is used. We force non loadable or empty
2167 sections to the front, where they are easier to ignore. */
2168
2169static int
84e2f313 2170compare_section_lma (const void *arg1, const void *arg2)
252b5132 2171{
d3ba0551
AM		 2172 const asection *const *sec1 = arg1;
2173 const asection *const *sec2 = arg2;
252b5132
RH		 2174 flagword flags1, flags2;
2175
2176 /* Sort non loadable sections to the front. */
2177 flags1 = (*sec1)->flags;
2178 flags2 = (*sec2)->flags;
2179 if ((flags1 & SEC_HAS_CONTENTS) == 0
2180 || (flags1 & SEC_LOAD) == 0)
2181 {
2182 if ((flags2 & SEC_HAS_CONTENTS) != 0
2183 && (flags2 & SEC_LOAD) != 0)
2184 return -1;
2185 }
2186 else
2187 {
2188 if ((flags2 & SEC_HAS_CONTENTS) == 0
2189 || (flags2 & SEC_LOAD) == 0)
2190 return 1;
2191 }
2192
2193 /* Sort sections by LMA. */
2194 if ((*sec1)->lma > (*sec2)->lma)
2195 return 1;
2196 else if ((*sec1)->lma < (*sec2)->lma)
2197 return -1;
2198
2199 /* Sort sections with the same LMA by size. */
135dfb4a 2200 if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
252b5132 2201 return 1;
135dfb4a 2202 else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
252b5132
RH		 2203 return -1;
2204
2205 return 0;
2206}
2207
2208/* Mark all the symbols which will be used in output relocations with
2209 the BSF_KEEP flag so that those symbols will not be stripped.
2210
2211 Ignore relocations which will not appear in the output file. */
2212
2213static void
84e2f313 2214mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
252b5132 2215{
d3ba0551 2216 asymbol **symbols = symbolsarg;
252b5132
RH		 2217 long relsize;
2218 arelent **relpp;
2219 long relcount, i;
2220
2221 /* Ignore an input section with no corresponding output section. */
2222 if (isection->output_section == NULL)
2223 return;
2224
2225 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2226 if (relsize < 0)
ed570f48
NC		 2227 {
2228 /* Do not complain if the target does not support relocations. */
2229 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2230 return;
2231 bfd_fatal (bfd_get_filename (ibfd));
2232 }
252b5132
RH		 2233
2234 if (relsize == 0)
2235 return;
2236
d3ba0551 2237 relpp = xmalloc (relsize);
252b5132
RH		 2238 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
2239 if (relcount < 0)
2240 bfd_fatal (bfd_get_filename (ibfd));
2241
ec5d57d5
NC		 2242 /* Examine each symbol used in a relocation. If it's not one of the
2243 special bfd section symbols, then mark it with BSF_KEEP. */
252b5132
RH		 2244 for (i = 0; i < relcount; i++)
2245 {
ec5d57d5
NC		 2246 if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
2247 && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
2248 && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
2249 (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
252b5132
RH		 2250 }
2251
2252 if (relpp != NULL)
2253 free (relpp);
2254}
2255
2256/* Write out debugging information. */
2257
b34976b6 2258static bfd_boolean
84e2f313
NC		 2259write_debugging_info (bfd *obfd, void *dhandle,
2260 long *symcountp ATTRIBUTE_UNUSED,
2261 asymbol ***symppp ATTRIBUTE_UNUSED)
252b5132
RH		 2262{
2263 if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
2264 return write_ieee_debugging_info (obfd, dhandle);
2265
2266 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
2267 || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2268 {
2269 bfd_byte *syms, *strings;
2270 bfd_size_type symsize, stringsize;
2271 asection *stabsec, *stabstrsec;
2272
2273 if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
2274 &symsize, &strings,
2275 &stringsize))
b34976b6 2276 return FALSE;
252b5132
RH		 2277
2278 stabsec = bfd_make_section (obfd, ".stab");
2279 stabstrsec = bfd_make_section (obfd, ".stabstr");
2280 if (stabsec == NULL
2281 || stabstrsec == NULL
2282 || ! bfd_set_section_size (obfd, stabsec, symsize)
2283 || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
2284 || ! bfd_set_section_alignment (obfd, stabsec, 2)
2285 || ! bfd_set_section_alignment (obfd, stabstrsec, 0)
2286 || ! bfd_set_section_flags (obfd, stabsec,
2287 (SEC_HAS_CONTENTS
2288 | SEC_READONLY
2289 | SEC_DEBUGGING))
2290 || ! bfd_set_section_flags (obfd, stabstrsec,
2291 (SEC_HAS_CONTENTS
2292 | SEC_READONLY
2293 | SEC_DEBUGGING)))
2294 {
2295 non_fatal (_("%s: can't create debugging section: %s"),
2296 bfd_get_filename (obfd),
2297 bfd_errmsg (bfd_get_error ()));
b34976b6 2298 return FALSE;
252b5132
RH		 2299 }
2300
2301 /* We can get away with setting the section contents now because
2302 the next thing the caller is going to do is copy over the
2303 real sections. We may someday have to split the contents
2304 setting out of this function. */
d3ba0551
AM		 2305 if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
2306 || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
2307 stringsize))
252b5132
RH		 2308 {
2309 non_fatal (_("%s: can't set debugging section contents: %s"),
2310 bfd_get_filename (obfd),
2311 bfd_errmsg (bfd_get_error ()));
b34976b6 2312 return FALSE;
252b5132
RH		 2313 }
2314
b34976b6 2315 return TRUE;
252b5132
RH		 2316 }
2317
2318 non_fatal (_("%s: don't know how to write debugging information for %s"),
2319 bfd_get_filename (obfd), bfd_get_target (obfd));
b34976b6 2320 return FALSE;
252b5132
RH		 2321}
2322
2323static int
84e2f313 2324strip_main (int argc, char *argv[])
252b5132 2325{
7c29036b
NC		 2326 char *input_target = NULL;
2327 char *output_target = NULL;
b34976b6 2328 bfd_boolean show_version = FALSE;
7c29036b
NC		 2329 bfd_boolean formats_info = FALSE;
2330 int c;
2331 int i;
252b5132
RH		 2332 struct section_list *p;
2333 char *output_file = NULL;
2334
5fe11841 2335 while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
252b5132
RH		 2336 strip_options, (int *) 0)) != EOF)
2337 {
2338 switch (c)
2339 {
2340 case 'I':
2341 input_target = optarg;
2342 break;
2343 case 'O':
2344 output_target = optarg;
2345 break;
2346 case 'F':
2347 input_target = output_target = optarg;
2348 break;
2349 case 'R':
b34976b6
AM		 2350 p = find_section_list (optarg, TRUE);
2351 p->remove = TRUE;
2352 sections_removed = TRUE;
252b5132
RH		 2353 break;
2354 case 's':
2355 strip_symbols = STRIP_ALL;
2356 break;
2357 case 'S':
2358 case 'g':
db4f6831 2359 case 'd': /* Historic BSD alias for -g. Used by early NetBSD. */
252b5132
RH		 2360 strip_symbols = STRIP_DEBUG;
2361 break;
2362 case OPTION_STRIP_UNNEEDED:
2363 strip_symbols = STRIP_UNNEEDED;
2364 break;
2365 case 'K':
2366 add_specific_symbol (optarg, &keep_specific_list);
2367 break;
2368 case 'N':
2369 add_specific_symbol (optarg, &strip_specific_list);
2370 break;
2371 case 'o':
2372 output_file = optarg;
2373 break;
2374 case 'p':
b34976b6 2375 preserve_dates = TRUE;
252b5132
RH		 2376 break;
2377 case 'x':
2378 discard_locals = LOCALS_ALL;
2379 break;
2380 case 'X':
2381 discard_locals = LOCALS_START_L;
2382 break;
2383 case 'v':
b34976b6 2384 verbose = TRUE;
252b5132
RH		 2385 break;
2386 case 'V':
b34976b6 2387 show_version = TRUE;
252b5132 2388 break;
7c29036b
NC		 2389 case OPTION_FORMATS_INFO:
2390 formats_info = TRUE;
2391 break;
ed1653a7
NC		 2392 case OPTION_ONLY_KEEP_DEBUG:
2393 strip_symbols = STRIP_NONDEBUG;
2394 break;
252b5132 2395 case 0:
594ef5db
NC		 2396 /* We've been given a long option. */
2397 break;
5fe11841
NC		 2398 case 'w':
2399 wildcard = TRUE;
2400 break;
8b53311e 2401 case 'H':
252b5132
RH		 2402 case 'h':
2403 strip_usage (stdout, 0);
2404 default:
2405 strip_usage (stderr, 1);
2406 }
2407 }
2408
84e2f313
NC		 2409 if (formats_info)
2410 {
2411 display_info ();
2412 return 0;
2413 }
7c29036b 2414
252b5132
RH		 2415 if (show_version)
2416 print_version ("strip");
2417
2418 /* Default is to strip all symbols. */
2419 if (strip_symbols == STRIP_UNDEF
2420 && discard_locals == LOCALS_UNDEF
2421 && strip_specific_list == NULL)
2422 strip_symbols = STRIP_ALL;
2423
d3ba0551 2424 if (output_target == NULL)
252b5132
RH		 2425 output_target = input_target;
2426
2427 i = optind;
2428 if (i == argc
2429 || (output_file != NULL && (i + 1) < argc))
2430 strip_usage (stderr, 1);
2431
2432 for (; i < argc; i++)
2433 {
2434 int hold_status = status;
2435 struct stat statbuf;
2436 char *tmpname;
2437
f24ddbdd
NC		 2438 if (get_file_size (argv[i]) < 1)
2439 continue;
2440
252b5132 2441 if (preserve_dates)
f24ddbdd
NC		 2442 /* No need to check the return value of stat().
2443 It has already been checked in get_file_size(). */
2444 stat (argv[i], &statbuf);
252b5132
RH		 2445
2446 if (output_file != NULL)
2447 tmpname = output_file;
2448 else
2449 tmpname = make_tempname (argv[i]);
2450 status = 0;
2451
2452 copy_file (argv[i], tmpname, input_target, output_target);
2453 if (status == 0)
2454 {
2455 if (preserve_dates)
2456 set_times (tmpname, &statbuf);
2457 if (output_file == NULL)
2458 smart_rename (tmpname, argv[i], preserve_dates);
2459 status = hold_status;
2460 }
2461 else
bb14f524 2462 unlink_if_ordinary (tmpname);
252b5132
RH		 2463 if (output_file == NULL)
2464 free (tmpname);
2465 }
2466
2467 return 0;
2468}
2469
2470static int
84e2f313 2471copy_main (int argc, char *argv[])
252b5132 2472{
43a0748c 2473 char * binary_architecture = NULL;
7c29036b
NC		 2474 char *input_filename = NULL;
2475 char *output_filename = NULL;
2476 char *input_target = NULL;
2477 char *output_target = NULL;
b34976b6
AM		 2478 bfd_boolean show_version = FALSE;
2479 bfd_boolean change_warn = TRUE;
7c29036b 2480 bfd_boolean formats_info = FALSE;
252b5132
RH		 2481 int c;
2482 struct section_list *p;
2483 struct stat statbuf;
2484
5fe11841 2485 while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
252b5132
RH		 2486 copy_options, (int *) 0)) != EOF)
2487 {
2488 switch (c)
2489 {
2490 case 'b':
2491 copy_byte = atoi (optarg);
2492 if (copy_byte < 0)
2493 fatal (_("byte number must be non-negative"));
2494 break;
57938635 2495
0af11b59
KH		 2496 case 'B':
2497 binary_architecture = optarg;
2498 break;
43a0748c 2499
252b5132
RH		 2500 case 'i':
2501 interleave = atoi (optarg);
2502 if (interleave < 1)
2503 fatal (_("interleave must be positive"));
2504 break;
57938635 2505
252b5132
RH		 2506 case 'I':
2507 case 's': /* "source" - 'I' is preferred */
2508 input_target = optarg;
2509 break;
57938635 2510
252b5132
RH		 2511 case 'O':
2512 case 'd': /* "destination" - 'O' is preferred */
2513 output_target = optarg;
2514 break;
57938635 2515
252b5132
RH		 2516 case 'F':
2517 input_target = output_target = optarg;
2518 break;
57938635 2519
f91ea849 2520 case 'j':
b34976b6 2521 p = find_section_list (optarg, TRUE);
f91ea849
ILT		 2522 if (p->remove)
2523 fatal (_("%s both copied and removed"), optarg);
b34976b6
AM		 2524 p->copy = TRUE;
2525 sections_copied = TRUE;
f91ea849 2526 break;
57938635 2527
252b5132 2528 case 'R':
b34976b6 2529 p = find_section_list (optarg, TRUE);
f91ea849
ILT		 2530 if (p->copy)
2531 fatal (_("%s both copied and removed"), optarg);
b34976b6
AM		 2532 p->remove = TRUE;
2533 sections_removed = TRUE;
252b5132 2534 break;
57938635 2535
252b5132
RH		 2536 case 'S':
2537 strip_symbols = STRIP_ALL;
2538 break;
57938635 2539
252b5132
RH		 2540 case 'g':
2541 strip_symbols = STRIP_DEBUG;
2542 break;
57938635 2543
252b5132
RH		 2544 case OPTION_STRIP_UNNEEDED:
2545 strip_symbols = STRIP_UNNEEDED;
2546 break;
57938635 2547
ed1653a7
NC		 2548 case OPTION_ONLY_KEEP_DEBUG:
2549 strip_symbols = STRIP_NONDEBUG;
2550 break;
2551
2593f09a
NC		 2552 case OPTION_ADD_GNU_DEBUGLINK:
2553 gnu_debuglink_filename = optarg;
2554 break;
2555
252b5132
RH		 2556 case 'K':
2557 add_specific_symbol (optarg, &keep_specific_list);
2558 break;
57938635 2559
252b5132
RH		 2560 case 'N':
2561 add_specific_symbol (optarg, &strip_specific_list);
2562 break;
57938635 2563
bcf32829
JB		 2564 case OPTION_STRIP_UNNEEDED_SYMBOL:
2565 add_specific_symbol (optarg, &strip_unneeded_list);
2566 break;
2567
252b5132
RH		 2568 case 'L':
2569 add_specific_symbol (optarg, &localize_specific_list);
2570 break;
57938635 2571
7b4a0685
NC		 2572 case OPTION_GLOBALIZE_SYMBOL:
2573 add_specific_symbol (optarg, &globalize_specific_list);
2574 break;
2575
16b2b71c
NC		 2576 case 'G':
2577 add_specific_symbol (optarg, &keepglobal_specific_list);
2578 break;
2579
252b5132
RH		 2580 case 'W':
2581 add_specific_symbol (optarg, &weaken_specific_list);
2582 break;
57938635 2583
252b5132 2584 case 'p':
b34976b6 2585 preserve_dates = TRUE;
252b5132 2586 break;
57938635 2587
5fe11841
NC		 2588 case 'w':
2589 wildcard = TRUE;
2590 break;
2591
252b5132
RH		 2592 case 'x':
2593 discard_locals = LOCALS_ALL;
2594 break;
57938635 2595
252b5132
RH		 2596 case 'X':
2597 discard_locals = LOCALS_START_L;
2598 break;
57938635 2599
252b5132 2600 case 'v':
b34976b6 2601 verbose = TRUE;
252b5132 2602 break;
57938635 2603
252b5132 2604 case 'V':
b34976b6 2605 show_version = TRUE;
252b5132 2606 break;
57938635 2607
7c29036b
NC		 2608 case OPTION_FORMATS_INFO:
2609 formats_info = TRUE;
2610 break;
2611
252b5132 2612 case OPTION_WEAKEN:
b34976b6 2613 weaken = TRUE;
252b5132 2614 break;
57938635 2615
252b5132
RH		 2616 case OPTION_ADD_SECTION:
2617 {
2618 const char *s;
f24ddbdd 2619 off_t size;
252b5132
RH		 2620 struct section_add *pa;
2621 int len;
2622 char *name;
2623 FILE *f;
2624
2625 s = strchr (optarg, '=');
57938635 2626
252b5132 2627 if (s == NULL)
57938635 2628 fatal (_("bad format for %s"), "--add-section");
252b5132 2629
f24ddbdd
NC		 2630 size = get_file_size (s + 1);
2631 if (size < 1)
2632 break;
252b5132 2633
d3ba0551 2634 pa = xmalloc (sizeof (struct section_add));
252b5132
RH		 2635
2636 len = s - optarg;
d3ba0551 2637 name = xmalloc (len + 1);
252b5132
RH		 2638 strncpy (name, optarg, len);
2639 name[len] = '\0';
2640 pa->name = name;
2641
2642 pa->filename = s + 1;
f24ddbdd
NC		 2643 pa->size = size;
2644 pa->contents = xmalloc (size);
252b5132 2645
252b5132 2646 f = fopen (pa->filename, FOPEN_RB);
57938635 2647
252b5132 2648 if (f == NULL)
84e2f313
NC		 2649 fatal (_("cannot open: %s: %s"),
2650 pa->filename, strerror (errno));
57938635 2651
252b5132
RH		 2652 if (fread (pa->contents, 1, pa->size, f) == 0
2653 || ferror (f))
2654 fatal (_("%s: fread failed"), pa->filename);
2655
2656 fclose (f);
2657
2658 pa->next = add_sections;
2659 add_sections = pa;
2660 }
2661 break;
57938635 2662
252b5132
RH		 2663 case OPTION_CHANGE_START:
2664 change_start = parse_vma (optarg, "--change-start");
2665 break;
57938635 2666
252b5132
RH		 2667 case OPTION_CHANGE_SECTION_ADDRESS:
2668 case OPTION_CHANGE_SECTION_LMA:
2669 case OPTION_CHANGE_SECTION_VMA:
2670 {
2671 const char *s;
2672 int len;
2673 char *name;
b4c96d0d 2674 char *option = NULL;
252b5132 2675 bfd_vma val;
b4c96d0d 2676 enum change_action what = CHANGE_IGNORE;
57938635 2677
252b5132
RH		 2678 switch (c)
2679 {
b4c96d0d
ILT		 2680 case OPTION_CHANGE_SECTION_ADDRESS:
2681 option = "--change-section-address";
2682 break;
2683 case OPTION_CHANGE_SECTION_LMA:
2684 option = "--change-section-lma";
2685 break;
2686 case OPTION_CHANGE_SECTION_VMA:
2687 option = "--change-section-vma";
2688 break;
252b5132 2689 }
57938635 2690
252b5132
RH		 2691 s = strchr (optarg, '=');
2692 if (s == NULL)
2693 {
2694 s = strchr (optarg, '+');
2695 if (s == NULL)
2696 {
2697 s = strchr (optarg, '-');
2698 if (s == NULL)
2699 fatal (_("bad format for %s"), option);
2700 }
2701 }
2702
2703 len = s - optarg;
d3ba0551 2704 name = xmalloc (len + 1);
252b5132
RH		 2705 strncpy (name, optarg, len);
2706 name[len] = '\0';
2707
b34976b6 2708 p = find_section_list (name, TRUE);
252b5132
RH		 2709
2710 val = parse_vma (s + 1, option);
2711
2712 switch (*s)
2713 {
2714 case '=': what = CHANGE_SET; break;
2715 case '-': val = - val; /* Drop through. */
2716 case '+': what = CHANGE_MODIFY; break;
2717 }
57938635 2718
252b5132
RH		 2719 switch (c)
2720 {
2721 case OPTION_CHANGE_SECTION_ADDRESS:
2722 p->change_vma = what;
2723 p->vma_val = val;
2724 /* Drop through. */
57938635 2725
252b5132
RH		 2726 case OPTION_CHANGE_SECTION_LMA:
2727 p->change_lma = what;
2728 p->lma_val = val;
2729 break;
57938635 2730
252b5132
RH		 2731 case OPTION_CHANGE_SECTION_VMA:
2732 p->change_vma = what;
2733 p->vma_val = val;
2734 break;
2735 }
2736 }
2737 break;
57938635 2738
252b5132
RH		 2739 case OPTION_CHANGE_ADDRESSES:
2740 change_section_address = parse_vma (optarg, "--change-addresses");
2741 change_start = change_section_address;
2742 break;
57938635 2743
252b5132 2744 case OPTION_CHANGE_WARNINGS:
b34976b6 2745 change_warn = TRUE;
252b5132 2746 break;
57938635 2747
252b5132 2748 case OPTION_CHANGE_LEADING_CHAR:
b34976b6 2749 change_leading_char = TRUE;
252b5132 2750 break;
57938635 2751
252b5132 2752 case OPTION_DEBUGGING:
b34976b6 2753 convert_debugging = TRUE;
252b5132 2754 break;
57938635 2755
252b5132
RH		 2756 case OPTION_GAP_FILL:
2757 {
2758 bfd_vma gap_fill_vma;
2759
2760 gap_fill_vma = parse_vma (optarg, "--gap-fill");
2761 gap_fill = (bfd_byte) gap_fill_vma;
2762 if ((bfd_vma) gap_fill != gap_fill_vma)
2763 {
2764 char buff[20];
57938635 2765
252b5132 2766 sprintf_vma (buff, gap_fill_vma);
57938635 2767
252b5132
RH		 2768 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
2769 buff, gap_fill);
2770 }
b34976b6 2771 gap_fill_set = TRUE;
252b5132
RH		 2772 }
2773 break;
57938635 2774
252b5132 2775 case OPTION_NO_CHANGE_WARNINGS:
b34976b6 2776 change_warn = FALSE;
252b5132 2777 break;
57938635 2778
252b5132
RH		 2779 case OPTION_PAD_TO:
2780 pad_to = parse_vma (optarg, "--pad-to");
b34976b6 2781 pad_to_set = TRUE;
252b5132 2782 break;
57938635 2783
252b5132 2784 case OPTION_REMOVE_LEADING_CHAR:
b34976b6 2785 remove_leading_char = TRUE;
252b5132 2786 break;
57938635
AM		 2787
2788 case OPTION_REDEFINE_SYM:
2789 {
2790 /* Push this redefinition onto redefine_symbol_list. */
2791
2792 int len;
2793 const char *s;
2794 const char *nextarg;
2795 char *source, *target;
2796
2797 s = strchr (optarg, '=');
2798 if (s == NULL)
594ef5db 2799 fatal (_("bad format for %s"), "--redefine-sym");
57938635
AM		 2800
2801 len = s - optarg;
d3ba0551 2802 source = xmalloc (len + 1);
57938635
AM		 2803 strncpy (source, optarg, len);
2804 source[len] = '\0';
2805
2806 nextarg = s + 1;
2807 len = strlen (nextarg);
d3ba0551 2808 target = xmalloc (len + 1);
57938635
AM		 2809 strcpy (target, nextarg);
2810
92991082 2811 redefine_list_append ("--redefine-sym", source, target);
57938635
AM		 2812
2813 free (source);
2814 free (target);
2815 }
2816 break;
2817
92991082
JT		 2818 case OPTION_REDEFINE_SYMS:
2819 add_redefine_syms_file (optarg);
2820 break;
2821
252b5132
RH		 2822 case OPTION_SET_SECTION_FLAGS:
2823 {
2824 const char *s;
2825 int len;
2826 char *name;
2827
2828 s = strchr (optarg, '=');
2829 if (s == NULL)
57938635 2830 fatal (_("bad format for %s"), "--set-section-flags");
252b5132
RH		 2831
2832 len = s - optarg;
d3ba0551 2833 name = xmalloc (len + 1);
252b5132
RH		 2834 strncpy (name, optarg, len);
2835 name[len] = '\0';
2836
b34976b6 2837 p = find_section_list (name, TRUE);
252b5132 2838
b34976b6 2839 p->set_flags = TRUE;
252b5132
RH		 2840 p->flags = parse_flags (s + 1);
2841 }
2842 break;
57938635 2843
594ef5db
NC		 2844 case OPTION_RENAME_SECTION:
2845 {
2846 flagword flags;
3bcfb3e4
AM		 2847 const char *eq, *fl;
2848 char *old_name;
2849 char *new_name;
594ef5db
NC		 2850 unsigned int len;
2851
3bcfb3e4
AM		 2852 eq = strchr (optarg, '=');
2853 if (eq == NULL)
594ef5db
NC		 2854 fatal (_("bad format for %s"), "--rename-section");
2855
3bcfb3e4 2856 len = eq - optarg;
594ef5db 2857 if (len == 0)
3bcfb3e4 2858 fatal (_("bad format for %s"), "--rename-section");
594ef5db 2859
d3ba0551 2860 old_name = xmalloc (len + 1);
594ef5db
NC		 2861 strncpy (old_name, optarg, len);
2862 old_name[len] = 0;
2863
3bcfb3e4
AM		 2864 eq++;
2865 fl = strchr (eq, ',');
2866 if (fl)
594ef5db 2867 {
3bcfb3e4
AM		 2868 flags = parse_flags (fl + 1);
2869 len = fl - eq;
594ef5db
NC		 2870 }
2871 else
2872 {
594ef5db 2873 flags = -1;
3bcfb3e4 2874 len = strlen (eq);
594ef5db
NC		 2875 }
2876
3bcfb3e4
AM		 2877 if (len == 0)
2878 fatal (_("bad format for %s"), "--rename-section");
2879
d3ba0551 2880 new_name = xmalloc (len + 1);
3bcfb3e4
AM		 2881 strncpy (new_name, eq, len);
2882 new_name[len] = 0;
2883
594ef5db
NC		 2884 add_section_rename (old_name, new_name, flags);
2885 }
2886 break;
2887
252b5132
RH		 2888 case OPTION_SET_START:
2889 set_start = parse_vma (optarg, "--set-start");
b34976b6 2890 set_start_set = TRUE;
252b5132 2891 break;
57938635 2892
0af11b59
KH		 2893 case OPTION_SREC_LEN:
2894 Chunk = parse_vma (optarg, "--srec-len");
2895 break;
420496c1 2896
0af11b59 2897 case OPTION_SREC_FORCES3:
b34976b6 2898 S3Forced = TRUE;
0af11b59 2899 break;
420496c1 2900
16b2b71c
NC		 2901 case OPTION_STRIP_SYMBOLS:
2902 add_specific_symbols (optarg, &strip_specific_list);
2903 break;
2904
bcf32829
JB		 2905 case OPTION_STRIP_UNNEEDED_SYMBOLS:
2906 add_specific_symbols (optarg, &strip_unneeded_list);
2907 break;
2908
16b2b71c
NC		 2909 case OPTION_KEEP_SYMBOLS:
2910 add_specific_symbols (optarg, &keep_specific_list);
2911 break;
2912
2913 case OPTION_LOCALIZE_SYMBOLS:
2914 add_specific_symbols (optarg, &localize_specific_list);
2915 break;
2916
7b4a0685
NC		 2917 case OPTION_GLOBALIZE_SYMBOLS:
2918 add_specific_symbols (optarg, &globalize_specific_list);
2919 break;
2920
16b2b71c
NC		 2921 case OPTION_KEEPGLOBAL_SYMBOLS:
2922 add_specific_symbols (optarg, &keepglobal_specific_list);
2923 break;
2924
2925 case OPTION_WEAKEN_SYMBOLS:
2926 add_specific_symbols (optarg, &weaken_specific_list);
2927 break;
2928
1ae8b3d2
AO		 2929 case OPTION_ALT_MACH_CODE:
2930 use_alt_mach_code = atoi (optarg);
2931 if (use_alt_mach_code <= 0)
2932 fatal (_("alternate machine code index must be positive"));
2933 break;
2934
d7fb0dd2
NC		 2935 case OPTION_PREFIX_SYMBOLS:
2936 prefix_symbols_string = optarg;
2937 break;
2938
2939 case OPTION_PREFIX_SECTIONS:
2940 prefix_sections_string = optarg;
2941 break;
2942
2943 case OPTION_PREFIX_ALLOC_SECTIONS:
2944 prefix_alloc_sections_string = optarg;
2945 break;
2946
4087920c
MR		 2947 case OPTION_READONLY_TEXT:
2948 bfd_flags_to_set |= WP_TEXT;
2949 bfd_flags_to_clear &= ~WP_TEXT;
2950 break;
2951
2952 case OPTION_WRITABLE_TEXT:
2953 bfd_flags_to_clear |= WP_TEXT;
2954 bfd_flags_to_set &= ~WP_TEXT;
2955 break;
2956
2957 case OPTION_PURE:
2958 bfd_flags_to_set |= D_PAGED;
2959 bfd_flags_to_clear &= ~D_PAGED;
2960 break;
2961
2962 case OPTION_IMPURE:
2963 bfd_flags_to_clear |= D_PAGED;
2964 bfd_flags_to_set &= ~D_PAGED;
2965 break;
2966
252b5132 2967 case 0:
2593f09a
NC		 2968 /* We've been given a long option. */
2969 break;
57938635 2970
8b53311e 2971 case 'H':
252b5132
RH		 2972 case 'h':
2973 copy_usage (stdout, 0);
57938635 2974
252b5132
RH		 2975 default:
2976 copy_usage (stderr, 1);
2977 }
2978 }
2979
7c29036b
NC		 2980 if (formats_info)
2981 {
2982 display_info ();
2983 return 0;
2984 }
2985
252b5132
RH		 2986 if (show_version)
2987 print_version ("objcopy");
2988
2989 if (copy_byte >= interleave)
2990 fatal (_("byte number must be less than interleave"));
2991
2992 if (optind == argc || optind + 2 < argc)
2993 copy_usage (stderr, 1);
2994
2995 input_filename = argv[optind];
2996 if (optind + 1 < argc)
2997 output_filename = argv[optind + 1];
2998
2999 /* Default is to strip no symbols. */
3000 if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
3001 strip_symbols = STRIP_NONE;
3002
d3ba0551 3003 if (output_target == NULL)
252b5132
RH		 3004 output_target = input_target;
3005
d3ba0551 3006 if (binary_architecture != NULL)
252b5132 3007 {
43a0748c 3008 if (input_target && strcmp (input_target, "binary") == 0)
0af11b59
KH		 3009 {
3010 const bfd_arch_info_type * temp_arch_info;
43a0748c
NC		 3011
3012 temp_arch_info = bfd_scan_arch (binary_architecture);
3013
0af11b59 3014 if (temp_arch_info != NULL)
b749473b
NC		 3015 {
3016 bfd_external_binary_architecture = temp_arch_info->arch;
3017 bfd_external_machine = temp_arch_info->mach;
3018 }
0af11b59
KH		 3019 else
3020 fatal (_("architecture %s unknown"), binary_architecture);
3021 }
43a0748c
NC		 3022 else
3023 {
3024 non_fatal (_("Warning: input target 'binary' required for binary architecture parameter."));
3025 non_fatal (_(" Argument %s ignored"), binary_architecture);
3026 }
252b5132
RH		 3027 }
3028
43a0748c
NC		 3029 if (preserve_dates)
3030 if (stat (input_filename, & statbuf) < 0)
f24ddbdd
NC		 3031 fatal (_("warning: could not locate '%s'. System error message: %s"),
3032 input_filename, strerror (errno));
43a0748c 3033
0fcdcb91 3034 /* If there is no destination file, or the source and destination files
d3ba0551
AM		 3035 are the same, then create a temp and rename the result into the input. */
3036 if (output_filename == NULL || strcmp (input_filename, output_filename) == 0)
252b5132
RH		 3037 {
3038 char *tmpname = make_tempname (input_filename);
3039
3040 copy_file (input_filename, tmpname, input_target, output_target);
3041 if (status == 0)
57938635 3042 {
252b5132
RH		 3043 if (preserve_dates)
3044 set_times (tmpname, &statbuf);
3045 smart_rename (tmpname, input_filename, preserve_dates);
3046 }
3047 else
3048 unlink (tmpname);
3049 }
3050 else
3051 {
3052 copy_file (input_filename, output_filename, input_target, output_target);
594ef5db 3053
252b5132
RH		 3054 if (status == 0 && preserve_dates)
3055 set_times (output_filename, &statbuf);
3056 }
3057
3058 if (change_warn)
3059 {
3060 for (p = change_sections; p != NULL; p = p->next)
3061 {
3062 if (! p->used)
3063 {
3064 if (p->change_vma != CHANGE_IGNORE)
3065 {
3066 char buff [20];
3067
3068 sprintf_vma (buff, p->vma_val);
57938635 3069
252b5132 3070 /* xgettext:c-format */
57938635
AM		 3071 non_fatal (_("%s %s%c0x%s never used"),
3072 "--change-section-vma",
252b5132
RH		 3073 p->name,
3074 p->change_vma == CHANGE_SET ? '=' : '+',
3075 buff);
3076 }
57938635 3077
252b5132
RH		 3078 if (p->change_lma != CHANGE_IGNORE)
3079 {
3080 char buff [20];
3081
3082 sprintf_vma (buff, p->lma_val);
57938635 3083
252b5132 3084 /* xgettext:c-format */
57938635
AM		 3085 non_fatal (_("%s %s%c0x%s never used"),
3086 "--change-section-lma",
252b5132
RH		 3087 p->name,
3088 p->change_lma == CHANGE_SET ? '=' : '+',
3089 buff);
3090 }
3091 }
3092 }
3093 }
3094
3095 return 0;
3096}
3097
3098int
84e2f313 3099main (int argc, char *argv[])
252b5132
RH		 3100{
3101#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3102 setlocale (LC_MESSAGES, "");
3882b010
L		 3103#endif
3104#if defined (HAVE_SETLOCALE)
3105 setlocale (LC_CTYPE, "");
252b5132
RH		 3106#endif
3107 bindtextdomain (PACKAGE, LOCALEDIR);
3108 textdomain (PACKAGE);
3109
3110 program_name = argv[0];
3111 xmalloc_set_program_name (program_name);
3112
3113 START_PROGRESS (program_name, 0);
3114
3115 strip_symbols = STRIP_UNDEF;
3116 discard_locals = LOCALS_UNDEF;
3117
3118 bfd_init ();
3119 set_default_bfd_target ();
3120
3121 if (is_strip < 0)
3122 {
3123 int i = strlen (program_name);
5af11cab
AM		 3124#ifdef HAVE_DOS_BASED_FILE_SYSTEM
3125 /* Drop the .exe suffix, if any. */
3126 if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
3127 {
3128 i -= 4;
3129 program_name[i] = '\0';
3130 }
3131#endif
3132 is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
252b5132
RH		 3133 }
3134
3135 if (is_strip)
3136 strip_main (argc, argv);
3137 else
3138 copy_main (argc, argv);
3139
3140 END_PROGRESS (program_name);
3141
3142 return status;
3143}
A mirror of the official binutils-gdb repository