1 /* This file is based in part on objcopy.c from GNU Binutils v2.17.
3 * Copyright (C) 1991-2006 Free Software Foundation, Inc.
4 * Copyright (C) 2008 Jeffrey Brian Arnold <jbarnold@mit.edu>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License, version 2.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 /* objmanip performs various object file manipulations for Ksplice. Its first
21 * argument is always an object file, which is modified in-place during
22 * objmanip's execution. (objmanip's code is similar to objcopy from GNU
23 * binutils because every manipulation that objmanip performs is essentially a
24 * "copy" operation with certain changes which make the new version different
25 * from the old version). objmanip has four modes of operation:
29 * This mode is the first objmanip step in processing the target object files.
31 * This mode can be broken down into two submodes, called "keep-primary" (which
32 * is used to prepare the primary kernel module) and "keep-helper" (which is
33 * used to prepare the helper kernel module):
35 * (a) keep-primary: "objmanip file.o keep-primary ADDSTR sect_1 ... sect_n"
37 * In this submode, only certain sections are kept; all other sections are
38 * discarded. Specifically, the following sections are kept: the listed
39 * sections (sect_1 ... sect_n), certain sections referenced by the listed
40 * sections, and certain special sections. The sections that are kept have
41 * ADDSTR added to the end of their names.
43 * The sections that are kept have most of their ELF relocations removed.
44 * (Relocations that point to sections that are being kept are not removed; all
45 * other relocations are removed). Information about each of the removed ELF
46 * relocations is printed to STDOUT (ksplice-create will save this information
47 * into Ksplice-specific ELF sections for the primary kernel module to use
50 * Each line of the STDOUT output represents a single place within the ELF
51 * object file at which a relocation has been removed. Each line contains the
52 * following fields, separated by spaces: an ELF symbol name, the name of a
53 * section previously containing a relocation pointing to that symbol, the
54 * offset (within that section) of the former relocation to that symbol, a bit
55 * representing whether that ELF relocation is PC-relative, and the ELF addend
56 * value for that relocation.
58 * (b) keep-helper: "objmanip file.o keep-helper ADDSTR"
60 * In this submode, essentially all sections are kept and have ADDSTR added to
61 * the end of their names.
63 * The sections that are kept have all of their ELF relocations removed.
64 * Information about each of the removed ELF relocations is printed to STDOUT
65 * (ksplice-create will save this information into Ksplice-specific ELF
66 * sections for the helper kernel module to use later).
68 * The fields of the STDOUT output are the same as with keep-primary.
70 * (2) globalize mode: "objmanip file.o globalize GLOBALIZESTR"
72 * This mode is the second objmanip step in processing the target object files.
73 * In this mode, all symbols whose names end in GLOBALIZESTR will be
74 * duplicated, with the duplicate symbols differing slightly from the original
75 * symbols. The duplicate symbols will have the string "_global" added to the
76 * end of their symbol names, and they will be global ELF symbols, regardless
77 * of whether the corresponding original symbol was global.
79 * (3) sizelist mode: "objmanip file.o sizelist"
81 * After the target object files have been linked into a single collection
82 * object file, this mode is used in order to obtain a list of all of the
83 * functions in the collection object file. Each line of the STDOUT output
84 * contains an ELF section name and that section's size, as presented by BFD's
85 * bfd_print_symbol function.
87 * (4) rmsyms mode: "objmanip file.o rmsyms sym_1 ... sym_n"
89 * This mode is the final objmanip step in preparing the Ksplice kernel
90 * modules. In this mode, any ELF relocations involving the listed symbols
91 * (sym_1 ... sym_n) are removed, and information about each of the removed
92 * relocations is printed to STDOUT.
94 * The fields of the STDOUT output are the same as with keep-primary.
98 #include "objcommon.h"
100 #include "kmodsrc/ksplice.h"
107 struct asymbolp_vec isyms
;
111 char *modestr
, *addstr_all
= "", *addstr_sect_pre
= "", *addstr_sect
= "";
113 struct wsect
*wanted_sections
= NULL
;
115 struct specsect special_sections
[] = {
116 {".altinstructions", 1, ".altinstr_replacement",
117 2 * sizeof(void *) + 4},
118 {".smp_locks", 0, NULL
, sizeof(void *)},
119 {".parainstructions", 0, NULL
, sizeof(void *) + 4},
120 }, *const end_special_sections
= *(&special_sections
+ 1);
122 #define mode(str) starts_with(modestr, str)
124 DECLARE_VEC_TYPE(unsigned long, addr_vec
);
125 DEFINE_HASH_TYPE(struct addr_vec
, addr_vec_hash
,
126 addr_vec_hash_init
, addr_vec_hash_free
, addr_vec_hash_lookup
,
128 struct addr_vec_hash system_map
;
130 void load_system_map()
132 const char *config_dir
= getenv("KSPLICE_CONFIG_DIR");
135 snprintf(file
, sizeof(file
), "%s/System.map", config_dir
);
136 FILE *fp
= fopen(file
, "r");
138 addr_vec_hash_init(&system_map
);
142 while (fscanf(fp
, "%lx %c %256s\n", &addr
, &type
, sym
) == 3)
143 *vec_grow(addr_vec_hash_lookup(&system_map
, sym
, TRUE
),
148 int main(int argc
, char **argv
)
150 char *debug_name
= malloc(strlen(argv
[1]) + 4 + strlen(argv
[2]) + 1);
151 sprintf(debug_name
, "%s.pre%s", argv
[1], argv
[2]);
152 rename(argv
[1], debug_name
);
155 bfd
*ibfd
= bfd_openr(debug_name
, NULL
);
159 assert(bfd_check_format_matches(ibfd
, bfd_object
, &matching
));
161 const char *output_target
= bfd_get_target(ibfd
);
162 bfd
*obfd
= bfd_openw(argv
[1], output_target
);
165 get_syms(ibfd
, &isyms
);
168 if (mode("keep") || mode("sizelist")) {
169 addstr_all
= argv
[3];
170 addstr_sect
= argv
[4];
172 varargs_count
= argc
- 5;
173 } else if (mode("patchlist")) {
174 addstr_all
= argv
[3];
175 addstr_sect_pre
= argv
[4];
176 addstr_sect
= argv
[5];
178 varargs_count
= argc
- 6;
181 varargs_count
= argc
- 3;
184 if (mode("keep") || mode("sizelist") || mode("rmsyms"))
189 struct wsect
*tmp
= wanted_sections
;
190 bfd_map_over_sections(ibfd
, mark_wanted_if_referenced
,
192 if (tmp
== wanted_sections
)
198 for (symp
= isyms
.data
;
199 mode("sizelist") && symp
< isyms
.data
+ isyms
.size
; symp
++) {
200 asymbol
*sym
= *symp
;
201 if ((sym
->flags
& BSF_FUNCTION
)
202 && sym
->value
== 0 && !(sym
->flags
& BSF_WEAK
))
203 write_ksplice_size(ibfd
, symp
);
206 if (mode("patchlist")) {
208 for (symname
= varargs
; symname
< varargs
+ varargs_count
;
210 write_ksplice_patch(ibfd
, *symname
);
214 for (p
= ibfd
->sections
; p
!= NULL
; p
= p
->next
) {
215 if (is_special(p
) || starts_with(p
->name
, ".ksplice"))
217 if (want_section(p
) || mode("rmsyms"))
218 rm_some_relocs(ibfd
, p
);
223 for (ss
= special_sections
; ss
!= end_special_sections
; ss
++)
224 rm_from_special(ibfd
, ss
);
227 copy_object(ibfd
, obfd
);
228 assert(bfd_close(obfd
));
229 assert(bfd_close(ibfd
));
233 void rm_some_relocs(bfd
*ibfd
, asection
*isection
)
235 struct supersect
*ss
= fetch_supersect(ibfd
, isection
, &isyms
);
236 struct arelentp_vec orig_relocs
;
237 vec_move(&orig_relocs
, &ss
->relocs
);
240 for (relocp
= orig_relocs
.data
;
241 relocp
< orig_relocs
.data
+ orig_relocs
.size
; relocp
++) {
243 asymbol
*sym_ptr
= *(*relocp
)->sym_ptr_ptr
;
245 if (mode("rmsyms") && match_varargs(sym_ptr
->name
))
251 if (mode("keep-primary") && want_section(sym_ptr
->section
))
255 write_ksplice_reloc(ibfd
, isection
, *relocp
, ss
);
257 *vec_grow(&ss
->relocs
, 1) = *relocp
;
261 struct supersect
*make_section(bfd
*abfd
, struct asymbolp_vec
*syms
, char *name
)
263 asection
*sect
= bfd_get_section_by_name(abfd
, name
);
265 return fetch_supersect(abfd
, sect
, syms
);
267 return new_supersect(name
);
270 void write_reloc(bfd
*abfd
, struct supersect
*ss
, void *addr
, asymbol
**symp
,
273 bfd_reloc_code_real_type code
;
274 switch (bfd_arch_bits_per_address(abfd
)) {
285 arelent
*reloc
= malloc(sizeof(*reloc
));
286 reloc
->sym_ptr_ptr
= symp
;
287 reloc
->address
= addr
- ss
->contents
.data
;
288 reloc
->howto
= bfd_reloc_type_lookup(abfd
, code
);
289 reloc
->addend
= offset
;
290 *vec_grow(&ss
->new_relocs
, 1) = reloc
;
293 void write_string(bfd
*ibfd
, struct supersect
*ss
, void *addr
,
294 const char *fmt
, ...)
298 int len
= vsnprintf(NULL
, 0, fmt
, ap
);
300 struct supersect
*str_ss
= make_section(ibfd
, &isyms
, ".ksplice_str");
301 char *buf
= sect_grow(str_ss
, len
+ 1, char);
303 vsnprintf(buf
, len
+ 1, fmt
, ap
);
306 write_reloc(ibfd
, ss
, addr
, &str_ss
->symbol
,
307 (void *)buf
- str_ss
->contents
.data
);
310 void write_system_map_array(bfd
*ibfd
, struct supersect
*ss
,
311 unsigned long **sym_addrs
,
312 unsigned long *num_sym_addrs
, asymbol
*sym
)
314 const char *system_map_name
= sym
->name
;
316 for (prefix
= (const char *[]){".text.", ".data.", ".bss.", NULL
};
317 *prefix
!= NULL
; prefix
++) {
318 if (starts_with(system_map_name
, *prefix
))
319 system_map_name
+= strlen(*prefix
);
321 struct addr_vec
*addrs
= addr_vec_hash_lookup(&system_map
,
322 system_map_name
, FALSE
);
324 struct supersect
*array_ss
= make_section(ibfd
, &isyms
,
326 void *buf
= sect_grow(array_ss
, addrs
->size
,
327 typeof(*addrs
->data
));
328 memcpy(buf
, addrs
->data
, addrs
->size
* sizeof(*addrs
->data
));
329 *num_sym_addrs
= addrs
->size
;
330 write_reloc(ibfd
, ss
, sym_addrs
, &array_ss
->symbol
,
331 buf
- array_ss
->contents
.data
);
338 void write_ksplice_reloc(bfd
*ibfd
, asection
*isection
, arelent
*orig_reloc
,
339 struct supersect
*ss
)
341 asymbol
*sym_ptr
= *orig_reloc
->sym_ptr_ptr
;
343 reloc_howto_type
*howto
= orig_reloc
->howto
;
345 bfd_vma inplace
= blot_section(ibfd
, isection
, orig_reloc
->address
,
348 struct supersect
*kreloc_ss
= make_section(ibfd
, &isyms
,
350 ".ksplice_init_relocs" :
352 struct ksplice_reloc
*kreloc
= sect_grow(kreloc_ss
, 1,
353 struct ksplice_reloc
);
355 write_string(ibfd
, kreloc_ss
, &kreloc
->sym_name
, "%s%s",
356 sym_ptr
->name
, addstr_all
);
357 write_reloc(ibfd
, kreloc_ss
, &kreloc
->blank_addr
,
358 &ss
->symbol
, orig_reloc
->address
);
359 kreloc
->blank_offset
= (unsigned long)orig_reloc
->address
;
360 write_system_map_array(ibfd
, kreloc_ss
, &kreloc
->sym_addrs
,
361 &kreloc
->num_sym_addrs
, sym_ptr
);
362 kreloc
->pcrel
= howto
->pc_relative
;
363 if (howto
->partial_inplace
)
364 kreloc
->addend
= inplace
;
366 kreloc
->addend
= orig_reloc
->addend
;
367 kreloc
->size
= bfd_get_reloc_size(howto
);
368 kreloc
->dst_mask
= howto
->dst_mask
;
369 kreloc
->rightshift
= howto
->rightshift
;
372 #define CANARY(x, canary) ((x & ~howto->dst_mask) | (canary & howto->dst_mask))
374 bfd_vma
blot_section(bfd
*abfd
, asection
*sect
, int offset
,
375 reloc_howto_type
*howto
)
377 struct supersect
*ss
= fetch_supersect(abfd
, sect
, &isyms
);
378 void *address
= ss
->contents
.data
+ offset
;
379 switch (howto
->size
) {
382 int8_t x
= bfd_get_8(abfd
, address
);
383 bfd_vma newx
= CANARY(x
, 0x77);
384 bfd_put_8(abfd
, newx
, address
);
385 return x
& howto
->src_mask
;
389 int16_t x
= bfd_get_16(abfd
, address
);
390 bfd_vma newx
= CANARY(x
, 0x7777);
391 bfd_put_16(abfd
, newx
, address
);
392 return x
& howto
->src_mask
;
396 int32_t x
= bfd_get_32(abfd
, address
);
397 bfd_vma newx
= CANARY(x
, 0x77777777);
398 bfd_put_32(abfd
, newx
, address
);
399 return x
& howto
->src_mask
;
403 int64_t x
= bfd_get_64(abfd
, address
);
404 bfd_vma newx
= CANARY(x
, 0x7777777777777777ll
);
405 bfd_put_64(abfd
, newx
, address
);
406 return x
& howto
->src_mask
;
409 fprintf(stderr
, "ksplice: Unsupported howto->size %d\n",
415 void write_ksplice_size(bfd
*ibfd
, asymbol
**symp
)
417 asymbol
*sym
= *symp
;
419 /* We call bfd_print_symbol in order to get access to
420 * the size associated with the function symbol, which
421 * is not otherwise available through the BFD API
425 FILE *fp
= open_memstream(&buf
, &bufsize
);
426 bfd_print_symbol(ibfd
, fp
, sym
, bfd_print_symbol_all
);
430 unsigned long symsize
;
433 assert(sscanf(buf
, "%*[^\t]\t%lx %as%n", &symsize
, &symname
, &len
) >=
435 assert(buf
[len
] == '\0');
436 assert(strcmp(symname
, sym
->name
) == 0);
440 struct supersect
*ksize_ss
= make_section(ibfd
, &isyms
,
442 struct ksplice_size
*ksize
= sect_grow(ksize_ss
, 1,
443 struct ksplice_size
);
445 write_string(ibfd
, ksize_ss
, &ksize
->name
, "%s%s%s",
446 sym
->name
, addstr_all
, addstr_sect
);
447 ksize
->size
= symsize
;
448 write_reloc(ibfd
, ksize_ss
, &ksize
->thismod_addr
, symp
, 0);
449 write_system_map_array(ibfd
, ksize_ss
, &ksize
->sym_addrs
,
450 &ksize
->num_sym_addrs
, sym
);
453 void write_ksplice_patch(bfd
*ibfd
, char *symname
)
455 struct supersect
*kpatch_ss
= make_section(ibfd
, &isyms
,
457 struct ksplice_patch
*kpatch
= sect_grow(kpatch_ss
, 1,
458 struct ksplice_patch
);
461 for (symp
= isyms
.data
; symp
< isyms
.data
+ isyms
.size
; symp
++) {
462 if (strcmp((*symp
)->name
, symname
) == 0)
465 assert(symp
< isyms
.data
+ isyms
.size
);
467 write_string(ibfd
, kpatch_ss
, &kpatch
->oldstr
, "%s%s%s",
468 symname
, addstr_all
, addstr_sect_pre
);
470 write_reloc(ibfd
, kpatch_ss
, &kpatch
->repladdr
, symp
, 0);
473 void rm_from_special(bfd
*ibfd
, struct specsect
*s
)
475 asection
*isection
= bfd_get_section_by_name(ibfd
, s
->sectname
);
476 if (isection
== NULL
)
479 struct supersect
*ss
= fetch_supersect(ibfd
, isection
, &isyms
);
480 struct void_vec orig_contents
;
481 vec_move(&orig_contents
, &ss
->contents
);
482 size_t pad
= align(orig_contents
.size
, 1 << ss
->alignment
) -
484 memset(vec_grow(&orig_contents
, pad
), 0, pad
);
485 struct arelentp_vec orig_relocs
;
486 vec_move(&orig_relocs
, &ss
->relocs
);
488 int entry_size
= align(s
->entry_size
, 1 << ss
->alignment
);
489 int relocs_per_entry
= s
->odd_relocs
? 2 : 1;
490 assert((orig_contents
.size
/ entry_size
) * relocs_per_entry
==
495 for (orig_entry
= orig_contents
.data
, relocp
= orig_relocs
.data
;
496 orig_entry
< orig_contents
.data
+ orig_contents
.size
;
497 orig_entry
+= entry_size
, relocp
+= relocs_per_entry
) {
498 asymbol
*sym
= *(*relocp
)->sym_ptr_ptr
;
500 asymbol
*odd_sym
= *(*(relocp
+ 1))->sym_ptr_ptr
;
501 assert(strcmp(odd_sym
->name
, s
->odd_relocname
) == 0);
504 for (p
= ibfd
->sections
; p
!= NULL
; p
= p
->next
) {
505 if (strcmp(sym
->name
, p
->name
) == 0
506 && !is_special(p
) && !want_section(p
))
512 void *new_entry
= vec_grow(&ss
->contents
, entry_size
);
513 memcpy(new_entry
, orig_entry
, entry_size
);
514 int modifier
= (new_entry
- ss
->contents
.data
) -
515 (orig_entry
- orig_contents
.data
);
516 arelent
**new_relocp
= vec_grow(&ss
->relocs
, 1);
517 *new_relocp
= *relocp
;
518 (*new_relocp
)->address
+= modifier
;
520 new_relocp
= vec_grow(&ss
->relocs
, 1);
521 *new_relocp
= *(relocp
+ 1);
522 (*new_relocp
)->address
+= modifier
;
527 void mark_wanted_if_referenced(bfd
*abfd
, asection
*sect
, void *ignored
)
529 if (want_section(sect
))
531 if (!starts_with(sect
->name
, ".text")
532 && !starts_with(sect
->name
, ".rodata"))
535 bfd_map_over_sections(abfd
, check_for_ref_to_section
, sect
);
538 void check_for_ref_to_section(bfd
*abfd
, asection
*looking_at
,
541 if (!want_section(looking_at
))
544 struct supersect
*ss
= fetch_supersect(abfd
, looking_at
, &isyms
);
546 for (relocp
= ss
->relocs
.data
;
547 relocp
< ss
->relocs
.data
+ ss
->relocs
.size
; relocp
++) {
548 asymbol
*sym
= *(*relocp
)->sym_ptr_ptr
;
549 if (sym
->section
== (asection
*)looking_for
) {
550 struct wsect
*w
= malloc(sizeof(*w
));
551 w
->name
= strdup(((asection
*)looking_for
)->name
);
552 w
->next
= wanted_sections
;
558 /* Modified function from GNU Binutils objcopy.c */
559 bfd_boolean
copy_object(bfd
*ibfd
, bfd
*obfd
)
561 assert(bfd_set_format(obfd
, bfd_get_format(ibfd
)));
563 bfd_vma start
= bfd_get_start_address(ibfd
);
565 flagword flags
= bfd_get_file_flags(ibfd
);
566 flags
&= bfd_applicable_file_flags(obfd
);
568 assert(bfd_set_start_address(obfd
, start
)
569 && bfd_set_file_flags(obfd
, flags
));
571 enum bfd_architecture iarch
= bfd_get_arch(ibfd
);
572 unsigned int imach
= bfd_get_mach(ibfd
);
573 assert(bfd_set_arch_mach(obfd
, iarch
, imach
));
574 assert(bfd_set_format(obfd
, bfd_get_format(ibfd
)));
576 /* BFD mandates that all output sections be created and sizes set before
577 any output is done. Thus, we traverse all sections multiple times. */
578 bfd_map_over_sections(ibfd
, setup_section
, obfd
);
580 assert(bfd_count_sections(obfd
));
582 struct supersect
*ss
;
583 for (ss
= new_supersects
; ss
!= NULL
; ss
= ss
->next
)
584 setup_new_section(obfd
, ss
);
586 /* Mark symbols used in output relocations so that they
587 are kept, even if they are local labels or static symbols.
589 Note we iterate over the input sections examining their
590 relocations since the relocations for the output sections
591 haven't been set yet. mark_symbols_used_in_relocations will
592 ignore input sections which have no corresponding output
595 bfd_map_over_sections(ibfd
, mark_symbols_used_in_relocations
, &isyms
);
596 for (ss
= new_supersects
; ss
!= NULL
; ss
= ss
->next
)
597 ss_mark_symbols_used_in_relocations(ss
);
598 struct asymbolp_vec osyms
;
600 filter_symbols(ibfd
, obfd
, &osyms
, &isyms
);
602 bfd_set_symtab(obfd
, osyms
.data
, osyms
.size
);
604 /* This has to happen after the symbol table has been set. */
605 bfd_map_over_sections(obfd
, write_section
, NULL
);
607 /* Allow the BFD backend to copy any private data it understands
608 from the input BFD to the output BFD. This is done last to
609 permit the routine to look at the filtered symbol table, which is
610 important for the ECOFF code at least. */
611 assert(bfd_copy_private_bfd_data(ibfd
, obfd
));
616 /* Modified function from GNU Binutils objcopy.c */
617 void setup_section(bfd
*ibfd
, asection
*isection
, void *obfdarg
)
622 if (!want_section(isection
))
625 asection
*osection
= bfd_make_section_anyway(obfd
, isection
->name
);
626 assert(osection
!= NULL
);
628 struct supersect
*ss
= fetch_supersect(ibfd
, isection
, &isyms
);
629 osection
->userdata
= ss
;
630 bfd_set_section_flags(obfd
, osection
, ss
->flags
);
631 ss
->symbol
= osection
->symbol
;
632 assert(bfd_set_section_size(obfd
, osection
, ss
->contents
.size
));
634 vma
= bfd_section_vma(ibfd
, isection
);
635 assert(bfd_set_section_vma(obfd
, osection
, vma
));
637 osection
->lma
= isection
->lma
;
638 assert(bfd_set_section_alignment(obfd
, osection
, ss
->alignment
));
639 osection
->entsize
= isection
->entsize
;
640 osection
->output_section
= osection
;
641 osection
->output_offset
= 0;
642 isection
->output_section
= osection
;
643 isection
->output_offset
= 0;
647 void setup_new_section(bfd
*obfd
, struct supersect
*ss
)
649 asection
*osection
= bfd_make_section_anyway(obfd
, ss
->name
);
650 assert(osection
!= NULL
);
651 bfd_set_section_flags(obfd
, osection
, ss
->flags
);
653 osection
->userdata
= ss
;
654 ss
->symbol
= osection
->symbol
;
655 assert(bfd_set_section_size(obfd
, osection
, ss
->contents
.size
));
656 assert(bfd_set_section_vma(obfd
, osection
, 0));
659 assert(bfd_set_section_alignment(obfd
, osection
, ss
->alignment
));
660 osection
->entsize
= 0;
661 osection
->output_section
= osection
;
662 osection
->output_offset
= 0;
665 void write_section(bfd
*obfd
, asection
*osection
, void *arg
)
667 struct supersect
*ss
= osection
->userdata
;
669 if (!want_section(osection
) || (ss
->flags
& SEC_GROUP
) != 0 ||
670 ss
->contents
.size
== 0)
675 for (relocp
= ss
->new_relocs
.data
;
676 relocp
< ss
->new_relocs
.data
+ ss
->new_relocs
.size
; relocp
++) {
677 bfd_put(bfd_get_reloc_size((*relocp
)->howto
) * 8, obfd
, 0,
678 ss
->contents
.data
+ (*relocp
)->address
);
679 if (bfd_install_relocation(obfd
, *relocp
, ss
->contents
.data
,
680 0, osection
, &error_message
) !=
682 fprintf(stderr
, "ksplice: error installing reloc: %s",
687 memcpy(vec_grow(&ss
->relocs
, ss
->new_relocs
.size
), ss
->new_relocs
.data
,
688 ss
->new_relocs
.size
* sizeof(*ss
->new_relocs
.data
));
690 bfd_set_reloc(obfd
, osection
,
691 ss
->relocs
.size
== 0 ? NULL
: ss
->relocs
.data
,
694 if (ss
->flags
& SEC_HAS_CONTENTS
)
695 assert(bfd_set_section_contents
696 (obfd
, osection
, ss
->contents
.data
, 0,
700 /* Modified function from GNU Binutils objcopy.c
702 * Mark all the symbols which will be used in output relocations with
703 * the BSF_KEEP flag so that those symbols will not be stripped.
705 * Ignore relocations which will not appear in the output file.
707 void mark_symbols_used_in_relocations(bfd
*ibfd
, asection
*isection
,
710 if (isection
->output_section
== NULL
)
713 struct supersect
*ss
= fetch_supersect(ibfd
, isection
, &isyms
);
714 ss_mark_symbols_used_in_relocations(ss
);
717 void ss_mark_symbols_used_in_relocations(struct supersect
*ss
)
719 /* Examine each symbol used in a relocation. If it's not one of the
720 special bfd section symbols, then mark it with BSF_KEEP. */
722 for (relocp
= ss
->relocs
.data
;
723 relocp
< ss
->relocs
.data
+ ss
->relocs
.size
; relocp
++) {
724 asymbol
*sym
= *(*relocp
)->sym_ptr_ptr
;
725 if (!(bfd_is_const_section(sym
->section
) &&
726 sym
== sym
->section
->symbol
))
727 sym
->flags
|= BSF_KEEP
;
731 /* Modified function from GNU Binutils objcopy.c
733 * Choose which symbol entries to copy.
734 * We don't copy in place, because that confuses the relocs.
735 * Return the number of symbols to print.
737 void filter_symbols(bfd
*abfd
, bfd
*obfd
, struct asymbolp_vec
*osyms
,
738 struct asymbolp_vec
*isyms
)
741 for (symp
= isyms
->data
; symp
< isyms
->data
+ isyms
->size
; symp
++) {
742 asymbol
*sym
= *symp
;
746 if (mode("keep") && (sym
->flags
& BSF_GLOBAL
) != 0)
747 sym
->flags
= (sym
->flags
& ~BSF_GLOBAL
) | BSF_LOCAL
;
749 if ((sym
->flags
& BSF_KEEP
) != 0 /* Used in relocation. */
750 || ((sym
->flags
& BSF_SECTION_SYM
) != 0
751 && ((*(sym
->section
)->symbol_ptr_ptr
)->flags
754 else if ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0)
756 else if (bfd_decode_symclass(sym
) == 'I')
757 /* Global symbols in $idata sections need to be retained.
758 External users of the library containing the $idata
759 section may reference these symbols. */
761 else if ((sym
->flags
& BSF_GLOBAL
) != 0
762 || (sym
->flags
& BSF_WEAK
) != 0
763 || bfd_is_com_section(sym
->section
))
765 else if ((sym
->flags
& BSF_DEBUGGING
) != 0)
768 keep
= !bfd_is_local_label(abfd
, sym
);
770 if (!want_section(sym
->section
))
773 if (mode("rmsyms") && match_varargs(sym
->name
))
777 *vec_grow(osyms
, 1) = sym
;
781 int exists_sym_with_name(struct asymbolp_vec
*syms
, const char *desired
)
784 for (symp
= syms
->data
; symp
< syms
->data
+ syms
->size
; symp
++) {
785 if (strcmp(bfd_asymbol_name(*symp
), desired
) == 0)
791 int match_varargs(const char *str
)
794 for (i
= 0; i
< varargs_count
; i
++) {
795 if (strcmp(str
, varargs
[i
]) == 0)
801 int want_section(asection
*sect
)
803 static const char *static_want
[] = {
805 ".altinstr_replacement",
810 const char *name
= sect
->name
;
815 struct wsect
*w
= wanted_sections
;
816 for (; w
!= NULL
; w
= w
->next
) {
817 if (strcmp(w
->name
, name
) == 0)
821 if (starts_with(name
, ".ksplice"))
823 if (mode("keep-helper") && starts_with(name
, ".text"))
825 if (match_varargs(name
))
829 for (i
= 0; static_want
[i
] != NULL
; i
++) {
830 if (strcmp(name
, static_want
[i
]) == 0)
836 struct specsect
*is_special(asection
*sect
)
839 for (ss
= special_sections
; ss
!= end_special_sections
; ss
++) {
840 if (strcmp(ss
->sectname
, sect
->name
) == 0)