1 /* objcopy.c -- copy object file from input to output, optionally massaging it.
2 Copyright (C) 1991, 92, 93, 94 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25 #include "libiberty.h"
27 static bfd_vma parse_vma
PARAMS ((const char *, const char *));
28 static flagword parse_flags
PARAMS ((const char *));
29 static struct section_list
*find_section_list
PARAMS ((const char *, boolean
));
30 static void setup_section
PARAMS ((bfd
*, asection
*, PTR
));
31 static void copy_section
PARAMS ((bfd
*, asection
*, PTR
));
32 static void get_sections
PARAMS ((bfd
*, asection
*, PTR
));
33 static int compare_section_vma
PARAMS ((const PTR
, const PTR
));
34 static void add_strip_symbol
PARAMS ((const char *));
35 static boolean is_strip_symbol
PARAMS ((const char *));
36 static boolean is_strip_section
PARAMS ((bfd
*, asection
*));
37 static unsigned int filter_symbols
38 PARAMS ((bfd
*, asymbol
**, asymbol
**, long));
39 static void mark_symbols_used_in_relocations
PARAMS ((bfd
*, asection
*, PTR
));
41 #define nonfatal(s) {bfd_nonfatal(s); status = 1; return;}
43 static asymbol
**isympp
= NULL
; /* Input symbols */
44 static asymbol
**osympp
= NULL
; /* Output symbols that survive stripping */
46 /* If `copy_byte' >= 0, copy only that byte of every `interleave' bytes. */
47 static int copy_byte
= -1;
48 static int interleave
= 4;
50 static boolean verbose
; /* Print file and target names. */
51 static int status
= 0; /* Exit status. */
56 strip_none
, /* don't strip */
57 strip_debug
, /* strip all debugger symbols */
58 strip_unneeded
, /* strip unnecessary symbols */
59 strip_all
/* strip all symbols */
62 /* Which symbols to remove. */
63 static enum strip_action strip_symbols
;
68 locals_start_L
, /* discard locals starting with L */
69 locals_all
/* discard all locals */
72 /* Which local symbols to remove. Overrides strip_all. */
73 static enum locals_action discard_locals
;
75 /* Structure used to hold lists of sections and actions to take. */
79 /* Next section to adjust. */
80 struct section_list
*next
;
83 /* Whether this entry was used. */
85 /* Whether to remove this section. */
87 /* Whether to adjust or set VMA. */
88 enum { ignore_vma
, adjust_vma
, set_vma
} adjust
;
89 /* Amount to adjust by or set to. */
91 /* Whether to set the section flags. */
93 /* What to set the section flags to. */
97 static struct section_list
*adjust_sections
;
98 static boolean sections_removed
;
100 /* Adjustments to the start address. */
101 static bfd_vma adjust_start
= 0;
102 static boolean set_start_set
= false;
103 static bfd_vma set_start
;
105 /* Adjustments to section VMA's. */
106 static bfd_vma adjust_section_vma
= 0;
108 /* Filling gaps between sections. */
109 static boolean gap_fill_set
= false;
110 static bfd_byte gap_fill
= 0;
112 /* Pad to a given address. */
113 static boolean pad_to_set
= false;
114 static bfd_vma pad_to
;
116 /* List of sections to add. */
120 /* Next section to add. */
121 struct section_add
*next
;
122 /* Name of section to add. */
124 /* Name of file holding section contents. */
125 const char *filename
;
128 /* Contents of file. */
130 /* BFD section, after it has been added. */
134 static struct section_add
*add_sections
;
136 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
138 #define OPTION_ADD_SECTION 150
139 #define OPTION_ADJUST_START (OPTION_ADD_SECTION + 1)
140 #define OPTION_ADJUST_VMA (OPTION_ADJUST_START + 1)
141 #define OPTION_ADJUST_SECTION_VMA (OPTION_ADJUST_VMA + 1)
142 #define OPTION_ADJUST_WARNINGS (OPTION_ADJUST_SECTION_VMA + 1)
143 #define OPTION_GAP_FILL (OPTION_ADJUST_WARNINGS + 1)
144 #define OPTION_NO_ADJUST_WARNINGS (OPTION_GAP_FILL + 1)
145 #define OPTION_PAD_TO (OPTION_NO_ADJUST_WARNINGS + 1)
146 #define OPTION_SET_SECTION_FLAGS (OPTION_PAD_TO + 1)
147 #define OPTION_SET_START (OPTION_SET_SECTION_FLAGS + 1)
148 #define OPTION_STRIP_UNNEEDED (OPTION_SET_START + 1)
150 /* Options to handle if running as "strip". */
152 static struct option strip_options
[] =
154 {"discard-all", no_argument
, 0, 'x'},
155 {"discard-locals", no_argument
, 0, 'X'},
156 {"format", required_argument
, 0, 'F'}, /* Obsolete */
157 {"help", no_argument
, 0, 'h'},
158 {"input-format", required_argument
, 0, 'I'}, /* Obsolete */
159 {"input-target", required_argument
, 0, 'I'},
160 {"keep-symbol", required_argument
, 0, 'K'},
161 {"output-format", required_argument
, 0, 'O'}, /* Obsolete */
162 {"output-target", required_argument
, 0, 'O'},
163 {"remove-section", required_argument
, 0, 'R'},
164 {"strip-all", no_argument
, 0, 's'},
165 {"strip-debug", no_argument
, 0, 'S'},
166 {"strip-unneeded", no_argument
, 0, OPTION_STRIP_UNNEEDED
},
167 {"strip-symbol", required_argument
, 0, 'N'},
168 {"target", required_argument
, 0, 'F'},
169 {"verbose", no_argument
, 0, 'v'},
170 {"version", no_argument
, 0, 'V'},
171 {0, no_argument
, 0, 0}
174 /* Options to handle if running as "objcopy". */
176 static struct option copy_options
[] =
178 {"add-section", required_argument
, 0, OPTION_ADD_SECTION
},
179 {"adjust-start", required_argument
, 0, OPTION_ADJUST_START
},
180 {"adjust-vma", required_argument
, 0, OPTION_ADJUST_VMA
},
181 {"adjust-section-vma", required_argument
, 0, OPTION_ADJUST_SECTION_VMA
},
182 {"adjust-warnings", no_argument
, 0, OPTION_ADJUST_WARNINGS
},
183 {"byte", required_argument
, 0, 'b'},
184 {"discard-all", no_argument
, 0, 'x'},
185 {"discard-locals", no_argument
, 0, 'X'},
186 {"format", required_argument
, 0, 'F'}, /* Obsolete */
187 {"gap-fill", required_argument
, 0, OPTION_GAP_FILL
},
188 {"help", no_argument
, 0, 'h'},
189 {"input-format", required_argument
, 0, 'I'}, /* Obsolete */
190 {"input-target", required_argument
, 0, 'I'},
191 {"interleave", required_argument
, 0, 'i'},
192 {"keep-symbol", required_argument
, 0, 'K'},
193 {"no-adjust-warnings", no_argument
, 0, OPTION_NO_ADJUST_WARNINGS
},
194 {"output-format", required_argument
, 0, 'O'}, /* Obsolete */
195 {"output-target", required_argument
, 0, 'O'},
196 {"pad-to", required_argument
, 0, OPTION_PAD_TO
},
197 {"remove-section", required_argument
, 0, 'R'},
198 {"set-section-flags", required_argument
, 0, OPTION_SET_SECTION_FLAGS
},
199 {"set-start", required_argument
, 0, OPTION_SET_START
},
200 {"strip-all", no_argument
, 0, 'S'},
201 {"strip-debug", no_argument
, 0, 'g'},
202 {"strip-unneeded", no_argument
, 0, OPTION_STRIP_UNNEEDED
},
203 {"strip-symbol", required_argument
, 0, 'N'},
204 {"target", required_argument
, 0, 'F'},
205 {"verbose", no_argument
, 0, 'v'},
206 {"version", no_argument
, 0, 'V'},
207 {0, no_argument
, 0, 0}
211 extern char *program_name
;
212 extern char *program_version
;
214 /* This flag distinguishes between strip and objcopy:
215 1 means this is 'strip'; 0 means this is 'objcopy'.
216 -1 means if we should use argv[0] to decide. */
221 copy_usage (stream
, exit_status
)
226 Usage: %s [-vVSgxX] [-I bfdname] [-O bfdname] [-F bfdname] [-b byte]\n\
227 [-R section] [-i interleave] [--interleave=interleave] [--byte=byte]\n\
228 [--input-target=bfdname] [--output-target=bfdname] [--target=bfdname]\n\
229 [--strip-all] [--strip-debug] [--strip-unneeded] [--discard-all]\n\
230 [--discard-locals] [--remove-section=section] [--gap-fill=val]\n",
233 [--pad-to=address] [--set-start=val] [--adjust-start=incr]\n\
234 [--adjust-vma=incr] [--adjust-section-vma=section{=,+,-}val]\n\
235 [--adjust-warnings] [--no-adjust-warnings]\n\
236 [--set-section-flags=section=flags] [--add-section=sectionname=filename]\n\
237 [--keep-symbol symbol] [-K symbol] [--strip-symbol symbol] [-N symbol]\n\
238 [--verbose] [--version] [--help]\n\
239 in-file [out-file]\n");
240 list_supported_targets (program_name
, stream
);
245 strip_usage (stream
, exit_status
)
250 Usage: %s [-vVsSgxX] [-I bfdname] [-O bfdname] [-F bfdname] [-R section]\n\
251 [--input-target=bfdname] [--output-target=bfdname] [--target=bfdname]\n\
252 [--strip-all] [--strip-debug] [--strip-unneeded] [--discard-all]\n\
253 [--discard-locals] [--keep-symbol symbol] [-K symbol]\n\
254 [--strip-symbol symbol] [-N symbol] [--remove-section=section]\n\
255 [--verbose] [--version] [--help] file...\n",
257 list_supported_targets (program_name
, stream
);
261 /* Parse a string into a VMA, with a fatal error if it can't be
272 ret
= bfd_scan_vma (s
, &end
, 0);
275 fprintf (stderr
, "%s: %s: bad number: %s\n", program_name
, arg
, s
);
281 /* Parse section flags into a flagword, with a fatal error if the
282 string can't be parsed. */
296 snext
= strchr (s
, ',');
305 #define PARSE_FLAG(fname,fval) if (strncmp (fname, s, len) == 0) ret |= fval;
306 PARSE_FLAG ("alloc", SEC_ALLOC
);
307 PARSE_FLAG ("load", SEC_LOAD
);
308 PARSE_FLAG ("readonly", SEC_READONLY
);
309 PARSE_FLAG ("code", SEC_CODE
);
310 PARSE_FLAG ("data", SEC_DATA
);
311 PARSE_FLAG ("rom", SEC_ROM
);
321 /* Find and optionally add an entry in the adjust_sections list. */
323 static struct section_list
*
324 find_section_list (name
, add
)
328 register struct section_list
*p
;
330 for (p
= adjust_sections
; p
!= NULL
; p
= p
->next
)
331 if (strcmp (p
->name
, name
) == 0)
337 p
= (struct section_list
*) xmalloc (sizeof (struct section_list
));
341 p
->adjust
= ignore_vma
;
343 p
->set_flags
= false;
346 p
->next
= adjust_sections
;
352 /* Make a list of symbols to explicitly strip out, or to keep. A
353 linked list is good enough for a small number from the command
354 line, but this will slow things down a lot if many symbols are
360 struct symlist
*next
;
363 /* List of symbols to strip. */
365 static struct symlist
*strip_specific_list
= NULL
;
367 /* If this is false, we strip the symbols in strip_specific_list.
368 Otherwise, we keep only the symbols in the list. */
370 static boolean keep_symbols
= false;
372 /* Add a symbol to strip_specific_list. */
375 add_strip_symbol (name
)
378 struct symlist
*tmp_list
;
380 tmp_list
= (struct symlist
*) xmalloc (sizeof (struct symlist
));
381 tmp_list
->name
= name
;
382 tmp_list
->next
= strip_specific_list
;
383 strip_specific_list
= tmp_list
;
386 /* See whether a symbol should be stripped or kept based on
387 strip_specific_list and keep_symbols. */
390 is_strip_symbol (name
)
393 struct symlist
*tmp_list
;
395 for (tmp_list
= strip_specific_list
; tmp_list
; tmp_list
= tmp_list
->next
)
397 if (strcmp (name
, tmp_list
->name
) == 0)
398 return keep_symbols
? false : true;
403 /* See if a section is being removed. */
406 is_strip_section (abfd
, sec
)
410 struct section_list
*p
;
412 if ((bfd_get_section_flags (abfd
, sec
) & SEC_DEBUGGING
) != 0
413 && (strip_symbols
== strip_debug
414 || strip_symbols
== strip_unneeded
415 || strip_symbols
== strip_all
416 || discard_locals
== locals_all
))
419 if (! sections_removed
)
421 p
= find_section_list (bfd_get_section_name (abfd
, sec
), false);
422 return p
!= NULL
&& p
->remove
? true : false;
425 /* Choose which symbol entries to copy; put the result in OSYMS.
426 We don't copy in place, because that confuses the relocs.
427 Return the number of symbols to print. */
430 filter_symbols (abfd
, osyms
, isyms
, symcount
)
432 asymbol
**osyms
, **isyms
;
435 register asymbol
**from
= isyms
, **to
= osyms
;
436 long src_count
= 0, dst_count
= 0;
438 for (; src_count
< symcount
; src_count
++)
440 asymbol
*sym
= from
[src_count
];
441 flagword flags
= sym
->flags
;
444 if ((flags
& BSF_KEEP
) != 0) /* Used in relocation. */
446 else if ((flags
& BSF_GLOBAL
) != 0 /* Global symbol. */
447 || bfd_is_und_section (bfd_get_section (sym
))
448 || bfd_is_com_section (bfd_get_section (sym
)))
449 keep
= strip_symbols
!= strip_unneeded
;
450 else if ((flags
& BSF_DEBUGGING
) != 0) /* Debugging symbol. */
451 keep
= (strip_symbols
!= strip_debug
452 && strip_symbols
!= strip_unneeded
);
453 else /* Local symbol. */
454 keep
= (strip_symbols
!= strip_unneeded
455 && (discard_locals
!= locals_all
456 && (discard_locals
!= locals_start_L
457 || ! bfd_is_local_label (abfd
, sym
))));
459 if (keep
&& is_strip_symbol (bfd_asymbol_name (sym
)))
461 if (keep
&& is_strip_section (abfd
, bfd_get_section (sym
)))
465 to
[dst_count
++] = sym
;
471 /* Keep only every `copy_byte'th byte in MEMHUNK, which is *SIZE bytes long.
475 filter_bytes (memhunk
, size
)
479 char *from
= memhunk
+ copy_byte
, *to
= memhunk
, *end
= memhunk
+ *size
;
481 for (; from
< end
; from
+= interleave
)
486 /* Copy object file IBFD onto OBFD. */
489 copy_object (ibfd
, obfd
)
495 asection
**osections
= NULL
;
496 bfd_size_type
*gaps
= NULL
;
497 bfd_size_type max_gap
= 0;
499 if (!bfd_set_format (obfd
, bfd_get_format (ibfd
)))
501 nonfatal (bfd_get_filename (obfd
));
505 printf ("copy from %s(%s) to %s(%s)\n",
506 bfd_get_filename(ibfd
), bfd_get_target(ibfd
),
507 bfd_get_filename(obfd
), bfd_get_target(obfd
));
512 start
= bfd_get_start_address (ibfd
);
513 start
+= adjust_start
;
515 if (!bfd_set_start_address (obfd
, start
)
516 || !bfd_set_file_flags (obfd
,
517 (bfd_get_file_flags (ibfd
)
518 & bfd_applicable_file_flags (obfd
))))
520 nonfatal (bfd_get_filename (ibfd
));
523 /* Copy architecture of input file to output file */
524 if (!bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
525 bfd_get_mach (ibfd
)))
527 fprintf (stderr
, "Output file cannot represent architecture %s\n",
528 bfd_printable_arch_mach (bfd_get_arch (ibfd
),
529 bfd_get_mach (ibfd
)));
531 if (!bfd_set_format (obfd
, bfd_get_format (ibfd
)))
533 nonfatal (bfd_get_filename(ibfd
));
538 if (osympp
!= isympp
)
541 /* bfd mandates that all output sections be created and sizes set before
542 any output is done. Thus, we traverse all sections multiple times. */
543 bfd_map_over_sections (ibfd
, setup_section
, (void *) obfd
);
545 if (add_sections
!= NULL
)
547 struct section_add
*padd
;
548 struct section_list
*pset
;
550 for (padd
= add_sections
; padd
!= NULL
; padd
= padd
->next
)
552 padd
->section
= bfd_make_section (obfd
, padd
->name
);
553 if (padd
->section
== NULL
)
555 fprintf (stderr
, "%s: can't create section `%s': %s\n",
556 program_name
, padd
->name
,
557 bfd_errmsg (bfd_get_error ()));
565 if (! bfd_set_section_size (obfd
, padd
->section
, padd
->size
))
566 nonfatal (bfd_get_filename (obfd
));
568 pset
= find_section_list (padd
->name
, false);
572 if (pset
!= NULL
&& pset
->set_flags
)
573 flags
= pset
->flags
| SEC_HAS_CONTENTS
;
575 flags
= SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_DATA
;
576 if (! bfd_set_section_flags (obfd
, padd
->section
, flags
))
577 nonfatal (bfd_get_filename (obfd
));
580 && (pset
->adjust
== adjust_vma
581 || pset
->adjust
== set_vma
))
583 if (! bfd_set_section_vma (obfd
, padd
->section
, pset
->val
))
584 nonfatal (bfd_get_filename (obfd
));
590 if (gap_fill_set
|| pad_to_set
)
595 /* We must fill in gaps between the sections and/or we must pad
596 the last section to a specified address. We do this by
597 grabbing a list of the sections, sorting them by VMA, and
598 increasing the section sizes as required to fill the gaps.
599 We write out the gap contents below. */
601 c
= bfd_count_sections (obfd
);
602 osections
= (asection
**) xmalloc (c
* sizeof (asection
*));
604 bfd_map_over_sections (obfd
, get_sections
, (void *) &set
);
606 qsort (osections
, c
, sizeof (asection
*), compare_section_vma
);
608 gaps
= (bfd_size_type
*) xmalloc (c
* sizeof (bfd_size_type
));
609 memset (gaps
, 0, c
* sizeof (bfd_size_type
));
613 for (i
= 0; i
< c
- 1; i
++)
617 bfd_vma gap_start
, gap_stop
;
619 flags
= bfd_get_section_flags (obfd
, osections
[i
]);
620 if ((flags
& SEC_HAS_CONTENTS
) == 0
621 || (flags
& SEC_LOAD
) == 0)
624 size
= bfd_section_size (obfd
, osections
[i
]);
625 gap_start
= bfd_section_vma (obfd
, osections
[i
]) + size
;
626 gap_stop
= bfd_section_vma (obfd
, osections
[i
+ 1]);
627 if (gap_start
< gap_stop
)
629 if (! bfd_set_section_size (obfd
, osections
[i
],
630 size
+ (gap_stop
- gap_start
)))
632 fprintf (stderr
, "%s: Can't fill gap after %s: %s\n",
634 bfd_get_section_name (obfd
, osections
[i
]),
635 bfd_errmsg (bfd_get_error()));
639 gaps
[i
] = gap_stop
- gap_start
;
640 if (max_gap
< gap_stop
- gap_start
)
641 max_gap
= gap_stop
- gap_start
;
651 vma
= bfd_section_vma (obfd
, osections
[c
- 1]);
652 size
= bfd_section_size (obfd
, osections
[c
- 1]);
653 if (vma
+ size
< pad_to
)
655 if (! bfd_set_section_size (obfd
, osections
[c
- 1],
658 fprintf (stderr
, "%s: Can't add padding to %s: %s\n",
660 bfd_get_section_name (obfd
, osections
[c
- 1]),
661 bfd_errmsg (bfd_get_error ()));
666 gaps
[c
- 1] = pad_to
- (vma
+ size
);
667 if (max_gap
< pad_to
- (vma
+ size
))
668 max_gap
= pad_to
- (vma
+ size
);
674 /* Symbol filtering must happen after the output sections have
675 been created, but before their contents are set. */
676 if (strip_symbols
== strip_all
)
678 osympp
= isympp
= NULL
;
685 symsize
= bfd_get_symtab_upper_bound (ibfd
);
688 nonfatal (bfd_get_filename (ibfd
));
691 osympp
= isympp
= (asymbol
**) xmalloc (symsize
);
692 symcount
= bfd_canonicalize_symtab (ibfd
, isympp
);
695 nonfatal (bfd_get_filename (ibfd
));
698 if (strip_symbols
== strip_debug
699 || strip_symbols
== strip_unneeded
700 || discard_locals
!= locals_undef
701 || strip_specific_list
!= NULL
704 /* Mark symbols used in output relocations so that they
705 are kept, even if they are local labels or static symbols.
707 Note we iterate over the input sections examining their
708 relocations since the relocations for the output sections
709 haven't been set yet. mark_symbols_used_in_relocations will
710 ignore input sections which have no corresponding output
712 bfd_map_over_sections (ibfd
,
713 mark_symbols_used_in_relocations
,
715 osympp
= (asymbol
**) xmalloc (symcount
* sizeof (asymbol
*));
716 symcount
= filter_symbols (ibfd
, osympp
, isympp
, symcount
);
720 bfd_set_symtab (obfd
, osympp
, symcount
);
722 /* This has to happen after the symbol table has been set. */
723 bfd_map_over_sections (ibfd
, copy_section
, (void *) obfd
);
725 if (add_sections
!= NULL
)
727 struct section_add
*padd
;
729 for (padd
= add_sections
; padd
!= NULL
; padd
= padd
->next
)
731 if (! bfd_set_section_contents (obfd
, padd
->section
,
732 (PTR
) padd
->contents
,
734 (bfd_size_type
) padd
->size
))
735 nonfatal (bfd_get_filename (obfd
));
739 if (gap_fill_set
|| pad_to_set
)
744 /* Fill in the gaps. */
748 buf
= (bfd_byte
*) xmalloc (max_gap
);
749 memset (buf
, gap_fill
, max_gap
);
751 c
= bfd_count_sections (obfd
);
752 for (i
= 0; i
< c
; i
++)
760 off
= bfd_section_size (obfd
, osections
[i
]) - left
;
769 if (! bfd_set_section_contents (obfd
, osections
[i
], buf
,
772 nonfatal (bfd_get_filename (obfd
));
781 /* Allow the BFD backend to copy any private data it understands
782 from the input BFD to the output BFD. This is done last to
783 permit the routine to look at the filtered symbol table, which is
784 important for the ECOFF code at least. */
785 if (!bfd_copy_private_bfd_data (ibfd
, obfd
))
787 fprintf (stderr
, "%s: %s: error copying private BFD data: %s\n",
788 program_name
, bfd_get_filename (obfd
),
789 bfd_errmsg (bfd_get_error ()));
801 size_t size
= strlen (a
) + strlen (b
) + strlen (c
);
802 char *r
= xmalloc (size
+ 1);
810 /* Read each archive element in turn from IBFD, copy the
811 contents to temp file, and keep the temp file handle. */
814 copy_archive (ibfd
, obfd
, output_target
)
821 struct name_list
*next
;
825 bfd
**ptr
= &obfd
->archive_head
;
827 char *dir
= make_tempname (bfd_get_filename (obfd
));
829 /* Make a temp directory to hold the contents. */
830 if (mkdir (dir
, 0700) != 0)
832 fatal ("cannot mkdir %s for archive copying (error: %s)",
833 dir
, strerror (errno
));
835 obfd
->has_armap
= ibfd
->has_armap
;
839 this_element
= bfd_openr_next_archived_file (ibfd
, NULL
);
840 while (this_element
!= (bfd
*) NULL
)
842 /* Create an output file for this member. */
843 char *output_name
= cat (dir
, "/", bfd_get_filename(this_element
));
844 bfd
*output_bfd
= bfd_openw (output_name
, output_target
);
847 l
= (struct name_list
*) xmalloc (sizeof (struct name_list
));
848 l
->name
= output_name
;
852 if (output_bfd
== (bfd
*) NULL
)
854 nonfatal (output_name
);
856 if (!bfd_set_format (obfd
, bfd_get_format (ibfd
)))
858 nonfatal (bfd_get_filename (obfd
));
861 if (bfd_check_format (this_element
, bfd_object
) == true)
863 copy_object (this_element
, output_bfd
);
866 bfd_close (output_bfd
);
868 /* Open the newly output file and attach to our list. */
869 output_bfd
= bfd_openr (output_name
, output_target
);
871 l
->obfd
= output_bfd
;
874 ptr
= &output_bfd
->next
;
876 last_element
= this_element
;
878 this_element
= bfd_openr_next_archived_file (ibfd
, last_element
);
880 bfd_close (last_element
);
884 if (!bfd_close (obfd
))
886 nonfatal (bfd_get_filename (obfd
));
889 if (!bfd_close (ibfd
))
891 nonfatal (bfd_get_filename (ibfd
));
894 /* Delete all the files that we opened. */
895 for (l
= list
; l
!= NULL
; l
= l
->next
)
903 /* The top-level control. */
906 copy_file (input_filename
, output_filename
, input_target
, output_target
)
907 char *input_filename
;
908 char *output_filename
;
915 /* To allow us to do "strip *" without dying on the first
916 non-object file, failures are nonfatal. */
918 ibfd
= bfd_openr (input_filename
, input_target
);
921 nonfatal (input_filename
);
924 if (bfd_check_format (ibfd
, bfd_archive
))
928 /* bfd_get_target does not return the correct value until
929 bfd_check_format succeeds. */
930 if (output_target
== NULL
)
931 output_target
= bfd_get_target (ibfd
);
933 obfd
= bfd_openw (output_filename
, output_target
);
936 nonfatal (output_filename
);
938 copy_archive (ibfd
, obfd
, output_target
);
940 else if (bfd_check_format_matches (ibfd
, bfd_object
, &matching
))
944 /* bfd_get_target does not return the correct value until
945 bfd_check_format succeeds. */
946 if (output_target
== NULL
)
947 output_target
= bfd_get_target (ibfd
);
949 obfd
= bfd_openw (output_filename
, output_target
);
952 nonfatal (output_filename
);
955 copy_object (ibfd
, obfd
);
957 if (!bfd_close (obfd
))
959 nonfatal (output_filename
);
962 if (!bfd_close (ibfd
))
964 nonfatal (input_filename
);
969 bfd_nonfatal (input_filename
);
970 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
972 list_matching_formats (matching
);
979 /* Create a section in OBFD with the same name and attributes
980 as ISECTION in IBFD. */
983 setup_section (ibfd
, isection
, obfdarg
)
988 bfd
*obfd
= (bfd
*) obfdarg
;
989 struct section_list
*p
;
995 if ((bfd_get_section_flags (ibfd
, isection
) & SEC_DEBUGGING
) != 0
996 && (strip_symbols
== strip_debug
997 || strip_symbols
== strip_unneeded
998 || strip_symbols
== strip_all
999 || discard_locals
== locals_all
))
1002 p
= find_section_list (bfd_section_name (ibfd
, isection
), false);
1006 if (p
!= NULL
&& p
->remove
)
1009 osection
= bfd_make_section_anyway (obfd
, bfd_section_name (ibfd
, isection
));
1010 if (osection
== NULL
)
1016 if (!bfd_set_section_size (obfd
,
1018 bfd_section_size (ibfd
, isection
)))
1024 vma
= bfd_section_vma (ibfd
, isection
);
1025 if (p
!= NULL
&& p
->adjust
== adjust_vma
)
1027 else if (p
!= NULL
&& p
->adjust
== set_vma
)
1030 vma
+= adjust_section_vma
;
1031 if (! bfd_set_section_vma (obfd
, osection
, vma
))
1037 if (bfd_set_section_alignment (obfd
,
1039 bfd_section_alignment (ibfd
, isection
))
1046 flags
= bfd_get_section_flags (ibfd
, isection
);
1047 if (p
!= NULL
&& p
->set_flags
)
1048 flags
= p
->flags
| (flags
& SEC_HAS_CONTENTS
);
1049 if (!bfd_set_section_flags (obfd
, osection
, flags
))
1055 /* This used to be mangle_section; we do here to avoid using
1056 bfd_get_section_by_name since some formats allow multiple
1057 sections with the same name. */
1058 isection
->output_section
= osection
;
1059 isection
->output_offset
= 0;
1061 /* Allow the BFD backend to copy any private data it understands
1062 from the input section to the output section. */
1063 if (!bfd_copy_private_section_data (ibfd
, isection
, obfd
, osection
))
1065 err
= "private data";
1073 fprintf (stderr
, "%s: %s: section `%s': error in %s: %s\n",
1075 bfd_get_filename (ibfd
), bfd_section_name (ibfd
, isection
),
1076 err
, bfd_errmsg (bfd_get_error ()));
1080 /* Copy the data of input section ISECTION of IBFD
1081 to an output section with the same name in OBFD.
1082 If stripping then don't copy any relocation info. */
1085 copy_section (ibfd
, isection
, obfdarg
)
1090 bfd
*obfd
= (bfd
*) obfdarg
;
1091 struct section_list
*p
;
1097 if ((bfd_get_section_flags (ibfd
, isection
) & SEC_DEBUGGING
) != 0
1098 && (strip_symbols
== strip_debug
1099 || strip_symbols
== strip_unneeded
1100 || strip_symbols
== strip_all
1101 || discard_locals
== locals_all
))
1106 p
= find_section_list (bfd_section_name (ibfd
, isection
), false);
1108 if (p
!= NULL
&& p
->remove
)
1111 osection
= isection
->output_section
;
1112 size
= bfd_get_section_size_before_reloc (isection
);
1114 if (size
== 0 || osection
== 0)
1117 if (strip_symbols
== strip_all
)
1118 bfd_set_reloc (obfd
, osection
, (arelent
**) NULL
, 0);
1123 relsize
= bfd_get_reloc_upper_bound (ibfd
, isection
);
1126 nonfatal (bfd_get_filename (ibfd
));
1129 bfd_set_reloc (obfd
, osection
, (arelent
**) NULL
, 0);
1132 relpp
= (arelent
**) xmalloc (relsize
);
1133 relcount
= bfd_canonicalize_reloc (ibfd
, isection
, relpp
, isympp
);
1136 nonfatal (bfd_get_filename (ibfd
));
1138 bfd_set_reloc (obfd
, osection
, relpp
, relcount
);
1142 isection
->_cooked_size
= isection
->_raw_size
;
1143 isection
->reloc_done
= true;
1145 if (bfd_get_section_flags (ibfd
, isection
) & SEC_HAS_CONTENTS
)
1147 PTR memhunk
= (PTR
) xmalloc ((unsigned) size
);
1149 if (!bfd_get_section_contents (ibfd
, isection
, memhunk
, (file_ptr
) 0,
1152 nonfatal (bfd_get_filename (ibfd
));
1157 filter_bytes (memhunk
, &size
);
1158 /* The section has gotten smaller. */
1159 if (!bfd_set_section_size (obfd
, osection
, size
))
1160 nonfatal (bfd_get_filename (obfd
));
1163 if (!bfd_set_section_contents (obfd
, osection
, memhunk
, (file_ptr
) 0,
1166 nonfatal (bfd_get_filename (obfd
));
1172 /* Get all the sections. This is used when --gap-fill or --pad-to is
1176 get_sections (obfd
, osection
, secppparg
)
1181 asection
***secppp
= (asection
***) secppparg
;
1183 **secppp
= osection
;
1187 /* Sort sections by VMA. This is called via qsort, and is used when
1188 --gap-fill or --pad-to is used. We force non loadable or empty
1189 sections to the front, where they are easier to ignore. */
1192 compare_section_vma (arg1
, arg2
)
1196 const asection
**sec1
= (const asection
**) arg1
;
1197 const asection
**sec2
= (const asection
**) arg2
;
1198 flagword flags1
, flags2
;
1200 /* Sort non loadable sections to the front. */
1201 flags1
= (*sec1
)->flags
;
1202 flags2
= (*sec2
)->flags
;
1203 if ((flags1
& SEC_HAS_CONTENTS
) == 0
1204 || (flags1
& SEC_LOAD
) == 0)
1206 if ((flags2
& SEC_HAS_CONTENTS
) != 0
1207 && (flags2
& SEC_LOAD
) != 0)
1212 if ((flags2
& SEC_HAS_CONTENTS
) == 0
1213 || (flags2
& SEC_LOAD
) == 0)
1217 /* Sort sections by VMA. */
1218 if ((*sec1
)->vma
> (*sec2
)->vma
)
1220 else if ((*sec1
)->vma
< (*sec2
)->vma
)
1223 /* Sort sections with the same VMA by size. */
1224 if ((*sec1
)->_raw_size
> (*sec2
)->_raw_size
)
1226 else if ((*sec1
)->_raw_size
< (*sec2
)->_raw_size
)
1232 /* Mark all the symbols which will be used in output relocations with
1233 the BSF_KEEP flag so that those symbols will not be stripped.
1235 Ignore relocations which will not appear in the output file. */
1238 mark_symbols_used_in_relocations (ibfd
, isection
, symbolsarg
)
1243 asymbol
**symbols
= (asymbol
**) symbolsarg
;
1248 /* Ignore an input section with no corresponding output section. */
1249 if (isection
->output_section
== NULL
)
1252 relsize
= bfd_get_reloc_upper_bound (ibfd
, isection
);
1254 bfd_fatal (bfd_get_filename (ibfd
));
1256 relpp
= (arelent
**) xmalloc (relsize
);
1257 relcount
= bfd_canonicalize_reloc (ibfd
, isection
, relpp
, symbols
);
1259 bfd_fatal (bfd_get_filename (ibfd
));
1261 /* Examine each symbol used in a relocation. If it's not one of the
1262 special bfd section symbols, then mark it with BSF_KEEP. */
1263 for (i
= 0; i
< relcount
; i
++)
1265 if (*relpp
[i
]->sym_ptr_ptr
!= bfd_com_section_ptr
->symbol
1266 && *relpp
[i
]->sym_ptr_ptr
!= bfd_abs_section_ptr
->symbol
1267 && *relpp
[i
]->sym_ptr_ptr
!= bfd_und_section_ptr
->symbol
)
1268 (*relpp
[i
]->sym_ptr_ptr
)->flags
|= BSF_KEEP
;
1275 /* The number of bytes to copy at once. */
1276 #define COPY_BUF 8192
1278 /* Copy file FROM to file TO, performing no translations.
1279 Return 0 if ok, -1 if error. */
1282 simple_copy (from
, to
)
1285 int fromfd
, tofd
, nread
;
1288 fromfd
= open (from
, O_RDONLY
);
1291 tofd
= open (to
, O_WRONLY
| O_CREAT
| O_TRUNC
);
1297 while ((nread
= read (fromfd
, buf
, sizeof buf
)) > 0)
1299 if (write (tofd
, buf
, nread
) != nread
)
1315 #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
1317 #define S_ISLNK(m) 0
1322 /* Rename FROM to TO, copying if TO is a link.
1323 Assumes that TO already exists, because FROM is a temp file.
1324 Return 0 if ok, -1 if error. */
1327 smart_rename (from
, to
)
1336 /* Use rename only if TO is not a symbolic link and has
1337 only one hard link. */
1338 if (!S_ISLNK (s
.st_mode
) && s
.st_nlink
== 1)
1340 ret
= rename (from
, to
);
1343 /* Try to preserve the permission bits and ownership of TO. */
1344 chmod (to
, s
.st_mode
& 07777);
1345 chown (to
, s
.st_uid
, s
.st_gid
);
1349 /* We have to clean up here. */
1351 fprintf (stderr
, "%s: `%s': ", program_name
, to
);
1359 ret
= simple_copy (from
, to
);
1367 strip_main (argc
, argv
)
1371 char *input_target
= NULL
, *output_target
= NULL
;
1372 boolean show_version
= false;
1374 struct section_list
*p
;
1376 while ((c
= getopt_long (argc
, argv
, "I:O:F:K:N:R:sSgxXVv",
1377 strip_options
, (int *) 0)) != EOF
)
1382 input_target
= optarg
;
1385 output_target
= optarg
;
1388 input_target
= output_target
= optarg
;
1391 p
= find_section_list (optarg
, true);
1393 sections_removed
= true;
1396 strip_symbols
= strip_all
;
1400 strip_symbols
= strip_debug
;
1402 case OPTION_STRIP_UNNEEDED
:
1403 strip_symbols
= strip_unneeded
;
1406 if (! keep_symbols
&& strip_specific_list
!= NULL
)
1408 fprintf (stderr
, "%s: Can not specify both -K and -N\n",
1410 strip_usage (stderr
, 1);
1412 keep_symbols
= true;
1413 add_strip_symbol (optarg
);
1418 fprintf (stderr
, "%s: Can not specify both -K and -N\n",
1420 strip_usage (stderr
, 1);
1422 add_strip_symbol (optarg
);
1425 discard_locals
= locals_all
;
1428 discard_locals
= locals_start_L
;
1434 show_version
= true;
1437 break; /* we've been given a long option */
1439 strip_usage (stdout
, 0);
1441 strip_usage (stderr
, 1);
1447 printf ("GNU %s version %s\n", program_name
, program_version
);
1451 /* Default is to strip all symbols. */
1452 if (strip_symbols
== strip_undef
1453 && discard_locals
== locals_undef
1454 && strip_specific_list
== NULL
)
1455 strip_symbols
= strip_all
;
1457 if (output_target
== (char *) NULL
)
1458 output_target
= input_target
;
1462 strip_usage (stderr
, 1);
1464 for (; i
< argc
; i
++)
1466 int hold_status
= status
;
1468 char *tmpname
= make_tempname (argv
[i
]);
1470 copy_file (argv
[i
], tmpname
, input_target
, output_target
);
1473 smart_rename (tmpname
, argv
[i
]);
1474 status
= hold_status
;
1485 copy_main (argc
, argv
)
1489 char *input_filename
= NULL
, *output_filename
= NULL
;
1490 char *input_target
= NULL
, *output_target
= NULL
;
1491 boolean show_version
= false;
1492 boolean adjust_warn
= true;
1494 struct section_list
*p
;
1496 while ((c
= getopt_long (argc
, argv
, "b:i:I:K:N:s:O:d:F:R:SgxXVv",
1497 copy_options
, (int *) 0)) != EOF
)
1502 copy_byte
= atoi(optarg
);
1505 fprintf (stderr
, "%s: byte number must be non-negative\n",
1511 interleave
= atoi(optarg
);
1514 fprintf(stderr
, "%s: interleave must be positive\n",
1520 case 's': /* "source" - 'I' is preferred */
1521 input_target
= optarg
;
1524 case 'd': /* "destination" - 'O' is preferred */
1525 output_target
= optarg
;
1528 input_target
= output_target
= optarg
;
1531 p
= find_section_list (optarg
, true);
1533 sections_removed
= true;
1536 strip_symbols
= strip_all
;
1539 strip_symbols
= strip_debug
;
1541 case OPTION_STRIP_UNNEEDED
:
1542 strip_symbols
= strip_unneeded
;
1545 if (! keep_symbols
&& strip_specific_list
!= NULL
)
1547 fprintf (stderr
, "%s: Can not specify both -K and -N\n",
1549 strip_usage (stderr
, 1);
1551 keep_symbols
= true;
1552 add_strip_symbol (optarg
);
1557 fprintf (stderr
, "%s: Can not specify both -K and -N\n",
1559 strip_usage (stderr
, 1);
1561 add_strip_symbol (optarg
);
1564 discard_locals
= locals_all
;
1567 discard_locals
= locals_start_L
;
1573 show_version
= true;
1575 case OPTION_ADD_SECTION
:
1579 struct section_add
*pa
;
1584 s
= strchr (optarg
, '=');
1588 "%s: bad format for --add-section NAME=FILENAME\n",
1593 if (stat (s
+ 1, &st
) < 0)
1595 fprintf (stderr
, "%s: ", program_name
);
1600 pa
= (struct section_add
*) xmalloc (sizeof (struct section_add
));
1603 name
= (char *) xmalloc (len
+ 1);
1604 strncpy (name
, optarg
, len
);
1608 pa
->filename
= s
+ 1;
1610 pa
->size
= st
.st_size
;
1612 pa
->contents
= (bfd_byte
*) xmalloc (pa
->size
);
1613 f
= fopen (pa
->filename
, FOPEN_RB
);
1616 fprintf (stderr
, "%s: ", program_name
);
1617 perror (pa
->filename
);
1620 if (fread (pa
->contents
, 1, pa
->size
, f
) == 0
1623 fprintf (stderr
, "%s: %s: fread failed\n",
1624 program_name
, pa
->filename
);
1629 pa
->next
= add_sections
;
1633 case OPTION_ADJUST_START
:
1634 adjust_start
= parse_vma (optarg
, "--adjust-start");
1636 case OPTION_ADJUST_SECTION_VMA
:
1642 s
= strchr (optarg
, '=');
1645 s
= strchr (optarg
, '+');
1648 s
= strchr (optarg
, '-');
1652 "%s: bad format for --adjust-section-vma\n",
1660 name
= (char *) xmalloc (len
+ 1);
1661 strncpy (name
, optarg
, len
);
1664 p
= find_section_list (name
, true);
1666 p
->val
= parse_vma (s
+ 1, "--adjust-section-vma");
1669 p
->adjust
= set_vma
;
1672 p
->adjust
= adjust_vma
;
1678 case OPTION_ADJUST_VMA
:
1679 adjust_section_vma
= parse_vma (optarg
, "--adjust-vma");
1680 adjust_start
= adjust_section_vma
;
1682 case OPTION_ADJUST_WARNINGS
:
1685 case OPTION_GAP_FILL
:
1687 bfd_vma gap_fill_vma
;
1689 gap_fill_vma
= parse_vma (optarg
, "--gap-fill");
1690 gap_fill
= (bfd_byte
) gap_fill_vma
;
1691 if ((bfd_vma
) gap_fill
!= gap_fill_vma
)
1693 fprintf (stderr
, "%s: warning: truncating gap-fill from 0x",
1695 fprintf_vma (stderr
, gap_fill_vma
);
1696 fprintf (stderr
, "to 0x%x\n", (unsigned int) gap_fill
);
1698 gap_fill_set
= true;
1701 case OPTION_NO_ADJUST_WARNINGS
:
1702 adjust_warn
= false;
1705 pad_to
= parse_vma (optarg
, "--pad-to");
1708 case OPTION_SET_SECTION_FLAGS
:
1714 s
= strchr (optarg
, '=');
1717 fprintf (stderr
, "%s: bad format for --set-section-flags\n",
1723 name
= (char *) xmalloc (len
+ 1);
1724 strncpy (name
, optarg
, len
);
1727 p
= find_section_list (name
, true);
1729 p
->set_flags
= true;
1730 p
->flags
= parse_flags (s
+ 1);
1733 case OPTION_SET_START
:
1734 set_start
= parse_vma (optarg
, "--set-start");
1735 set_start_set
= true;
1738 break; /* we've been given a long option */
1740 copy_usage (stdout
, 0);
1742 copy_usage (stderr
, 1);
1748 printf ("GNU %s version %s\n", program_name
, program_version
);
1752 if (copy_byte
>= interleave
)
1754 fprintf (stderr
, "%s: byte number must be less than interleave\n",
1759 if (optind
== argc
|| optind
+ 2 < argc
)
1760 copy_usage (stderr
, 1);
1762 input_filename
= argv
[optind
];
1763 if (optind
+ 1 < argc
)
1764 output_filename
= argv
[optind
+ 1];
1766 /* Default is to strip no symbols. */
1767 if (strip_symbols
== strip_undef
&& discard_locals
== locals_undef
)
1768 strip_symbols
= strip_none
;
1770 if (output_target
== (char *) NULL
)
1771 output_target
= input_target
;
1773 /* If there is no destination file then create a temp and rename
1774 the result into the input. */
1776 if (output_filename
== (char *) NULL
)
1778 char *tmpname
= make_tempname (input_filename
);
1779 copy_file (input_filename
, tmpname
, input_target
, output_target
);
1781 smart_rename (tmpname
, input_filename
);
1787 copy_file (input_filename
, output_filename
, input_target
, output_target
);
1792 for (p
= adjust_sections
; p
!= NULL
; p
= p
->next
)
1794 if (! p
->used
&& p
->adjust
!= ignore_vma
)
1796 fprintf (stderr
, "%s: warning: --adjust-section-vma %s%c0x",
1797 program_name
, p
->name
,
1798 p
->adjust
== set_vma
? '=' : '+');
1799 fprintf_vma (stderr
, p
->val
);
1800 fprintf (stderr
, " never used\n");
1813 program_name
= argv
[0];
1814 xmalloc_set_program_name (program_name
);
1816 START_PROGRESS (program_name
, 0);
1818 strip_symbols
= strip_undef
;
1819 discard_locals
= locals_undef
;
1825 int i
= strlen (program_name
);
1826 is_strip
= (i
>= 5 && strcmp (program_name
+ i
- 5, "strip") == 0);
1830 strip_main (argc
, argv
);
1832 copy_main (argc
, argv
);
1834 END_PROGRESS (program_name
);