X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Felf32-score7.c;h=2d146ccfb1c82a8ef36b8ce36b2554baf0d7535d;hb=e330d4c033eab2e0e7206a29d6c11a9a59fd205b;hp=ef42d7bdacb28bc4fb0a2695e3a580472479dc45;hpb=871b3ab29e87cf0de15f7e49ad19acc4f7f6f84c;p=binutils-gdb.git diff --git a/bfd/elf32-score7.c b/bfd/elf32-score7.c index ef42d7bdacb..2d146ccfb1c 100644 --- a/bfd/elf32-score7.c +++ b/bfd/elf32-score7.c @@ -1,5 +1,5 @@ /* 32-bit ELF support for S+core. - Copyright (C) 2009-2018 Free Software Foundation, Inc. + Copyright (C) 2009-2022 Free Software Foundation, Inc. Contributed by Brain.lin (brain.lin@sunplusct.com) Mei Ligang (ligang@sunnorth.com.cn) @@ -44,22 +44,22 @@ struct score_elf_link_hash_entry unsigned int possibly_dynamic_relocs; /* If the R_SCORE_ABS32, R_SCORE_REL32 reloc is against a readonly section. */ - bfd_boolean readonly_reloc; + bool readonly_reloc; /* We must not create a stub for a symbol that has relocations related to taking the function's address, i.e. any but R_SCORE_CALL15 ones. */ - bfd_boolean no_fn_stub; + bool no_fn_stub; /* Are we forced local? This will only be set if we have converted the initial global GOT entry to a local GOT entry. */ - bfd_boolean forced_local; + bool forced_local; }; /* Traverse a score ELF linker hash table. */ #define score_elf_link_hash_traverse(table, func, info) \ - (elf_link_hash_traverse \ - ((table), \ - (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \ + (elf_link_hash_traverse \ + ((table), \ + (bool (*) (struct elf_link_hash_entry *, void *)) (func), \ (info))) /* This structure is used to hold .got entries while estimating got sizes. */ @@ -197,9 +197,12 @@ static bfd *reldyn_sorting_bfd; together, and then referenced via the gp pointer, which yields faster assembler code. This is what we use for the small common section. This approach is copied from ecoff.c. */ -static asection score_elf_scom_section; -static asymbol score_elf_scom_symbol; -static asymbol * score_elf_scom_symbol_ptr; +static asection score_elf_scom_section; +static const asymbol score_elf_scom_symbol = + GLOBAL_SYM_INIT (".scommon", &score_elf_scom_section); +static asection score_elf_scom_section = + BFD_FAKE_SECTION (score_elf_scom_section, &score_elf_scom_symbol, + ".scommon", 0, SEC_IS_COMMON | SEC_SMALL_DATA); static bfd_reloc_status_type score_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, @@ -247,7 +250,7 @@ score_elf_lo16_reloc (bfd *abfd, /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a dangerous relocation. */ -static bfd_boolean +static bool score_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp) { unsigned int count; @@ -257,7 +260,7 @@ score_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp) /* If we've already figured out what GP will be, just return it. */ *pgp = _bfd_get_gp_value (output_bfd); if (*pgp) - return TRUE; + return true; count = bfd_get_symcount (output_bfd); sym = bfd_get_outsymbols (output_bfd); @@ -287,10 +290,10 @@ score_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp) /* Only get the error once. */ *pgp = 4; _bfd_set_gp_value (output_bfd, *pgp); - return FALSE; + return false; } - return TRUE; + return true; } /* We have to figure out the gp value, so that we can adjust the @@ -302,7 +305,7 @@ score_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp) static bfd_reloc_status_type score_elf_final_gp (bfd *output_bfd, asymbol *symbol, - bfd_boolean relocatable, + bool relocatable, char **error_message, bfd_vma *pgp) { @@ -337,23 +340,14 @@ score_elf_final_gp (bfd *output_bfd, static bfd_reloc_status_type score_elf_gprel15_with_gp (bfd *abfd, - asymbol *symbol, arelent *reloc_entry, asection *input_section, - bfd_boolean relocateable, + bool relocateable, void * data, bfd_vma gp ATTRIBUTE_UNUSED) { - bfd_vma relocation; unsigned long insn; - if (bfd_is_com_section (symbol->section)) - relocation = 0; - else - relocation = symbol->value; - - relocation += symbol->section->output_section->vma; - relocation += symbol->section->output_offset; if (reloc_entry->address > input_section->size) return bfd_reloc_outofrange; @@ -372,7 +366,7 @@ score_elf_gprel15_with_gp (bfd *abfd, static bfd_reloc_status_type gprel32_with_gp (bfd *abfd, asymbol *symbol, arelent *reloc_entry, - asection *input_section, bfd_boolean relocatable, + asection *input_section, bool relocatable, void *data, bfd_vma gp) { bfd_vma relocation; @@ -422,7 +416,7 @@ score_elf_gprel15_reloc (bfd *abfd, bfd *output_bfd, char **error_message) { - bfd_boolean relocateable; + bool relocateable; bfd_reloc_status_type ret; bfd_vma gp; @@ -433,19 +427,21 @@ score_elf_gprel15_reloc (bfd *abfd, return bfd_reloc_ok; } if (output_bfd != NULL) - relocateable = TRUE; + relocateable = true; else { - relocateable = FALSE; + relocateable = false; output_bfd = symbol->section->output_section->owner; + if (output_bfd == NULL) + return bfd_reloc_undefined; } ret = score_elf_final_gp (output_bfd, symbol, relocateable, error_message, &gp); if (ret != bfd_reloc_ok) return ret; - return score_elf_gprel15_with_gp (abfd, symbol, reloc_entry, - input_section, relocateable, data, gp); + return score_elf_gprel15_with_gp (abfd, reloc_entry, + input_section, relocateable, data, gp); } /* Do a R_SCORE_GPREL32 relocation. This is a 32 bit value which must @@ -456,7 +452,7 @@ score_elf_gprel32_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, void *data, asection *input_section, bfd *output_bfd, char **error_message) { - bfd_boolean relocatable; + bool relocatable; bfd_reloc_status_type ret; bfd_vma gp; @@ -471,10 +467,10 @@ score_elf_gprel32_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, } if (output_bfd != NULL) - relocatable = TRUE; + relocatable = true; else { - relocatable = FALSE; + relocatable = false; output_bfd = symbol->section->output_section->owner; } @@ -497,8 +493,8 @@ score_elf_got15_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, bfd *output_bfd, char **error_message) { if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0 - || bfd_is_und_section (bfd_get_section (symbol)) - || bfd_is_com_section (bfd_get_section (symbol))) + || bfd_is_und_section (bfd_asymbol_section (symbol)) + || bfd_is_com_section (bfd_asymbol_section (symbol))) /* The relocation is against a global symbol. */ return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd, @@ -548,299 +544,299 @@ static reloc_howto_type elf32_score_howto_table[] = 0, /* rightshift */ 3, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE_NONE", /* name */ - FALSE, /* partial_inplace */ + false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* R_SCORE_HI16 */ HOWTO (R_SCORE_HI16, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 1, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ score_elf_hi16_reloc, /* special_function */ "R_SCORE_HI16", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0x37fff, /* src_mask */ 0x37fff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* R_SCORE_LO16 */ HOWTO (R_SCORE_LO16, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 1, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ score_elf_lo16_reloc, /* special_function */ "R_SCORE_LO16", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0x37fff, /* src_mask */ 0x37fff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* R_SCORE_BCMP */ HOWTO (R_SCORE_BCMP, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 1, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE_BCMP", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0x0000ffff, /* src_mask */ 0x0000ffff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ HOWTO (R_SCORE_24, /* type */ 1, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 24, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 1, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE_24", /* name */ - FALSE, /* partial_inplace */ + false, /* partial_inplace */ 0x3ff7fff, /* src_mask */ 0x3ff7fff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /*R_SCORE_PC19 */ HOWTO (R_SCORE_PC19, /* type */ 1, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 19, /* bitsize */ - TRUE, /* pc_relative */ + true, /* pc_relative */ 1, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE_PC19", /* name */ - FALSE, /* partial_inplace */ + false, /* partial_inplace */ 0x3ff03fe, /* src_mask */ 0x3ff03fe, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /*R_SCORE16_11 */ HOWTO (R_SCORE16_11, /* type */ 1, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 11, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 1, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE16_11", /* name */ - FALSE, /* partial_inplace */ + false, /* partial_inplace */ 0x000000ffe, /* src_mask */ 0x000000ffe, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* R_SCORE16_PC8 */ HOWTO (R_SCORE16_PC8, /* type */ 1, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 8, /* bitsize */ - TRUE, /* pc_relative */ + true, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE16_PC8", /* name */ - FALSE, /* partial_inplace */ + false, /* partial_inplace */ 0x000000ff, /* src_mask */ 0x000000ff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* 32 bit absolute */ HOWTO (R_SCORE_ABS32, /* type 8 */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE_ABS32", /* name */ - FALSE, /* partial_inplace */ + false, /* partial_inplace */ 0xffffffff, /* src_mask */ 0xffffffff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* 16 bit absolute */ HOWTO (R_SCORE_ABS16, /* type 11 */ 0, /* rightshift */ 1, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_bitfield, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE_ABS16", /* name */ - FALSE, /* partial_inplace */ + false, /* partial_inplace */ 0x0000ffff, /* src_mask */ 0x0000ffff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* R_SCORE_DUMMY2 */ HOWTO (R_SCORE_DUMMY2, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE_DUMMY2", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0x00007fff, /* src_mask */ 0x00007fff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* R_SCORE_GP15 */ HOWTO (R_SCORE_GP15, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ score_elf_gprel15_reloc,/* special_function */ "R_SCORE_GP15", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0x00007fff, /* src_mask */ 0x00007fff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* GNU extension to record C++ vtable hierarchy. */ HOWTO (R_SCORE_GNU_VTINHERIT, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ NULL, /* special_function */ "R_SCORE_GNU_VTINHERIT", /* name */ - FALSE, /* partial_inplace */ + false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* GNU extension to record C++ vtable member usage */ HOWTO (R_SCORE_GNU_VTENTRY, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 0, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ _bfd_elf_rel_vtable_reloc_fn, /* special_function */ "R_SCORE_GNU_VTENTRY", /* name */ - FALSE, /* partial_inplace */ + false, /* partial_inplace */ 0, /* src_mask */ 0, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* Reference to global offset table. */ HOWTO (R_SCORE_GOT15, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ score_elf_got15_reloc, /* special_function */ "R_SCORE_GOT15", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0x00007fff, /* src_mask */ 0x00007fff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* Low 16 bits of displacement in global offset table. */ HOWTO (R_SCORE_GOT_LO16, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 1, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ score_elf_got_lo16_reloc, /* special_function */ "R_SCORE_GOT_LO16", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0x37ffe, /* src_mask */ 0x37ffe, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* 15 bit call through global offset table. */ HOWTO (R_SCORE_CALL15, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_signed, /* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE_CALL15", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0x00007fff, /* src_mask */ 0x00007fff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* 32 bit GP relative reference. */ HOWTO (R_SCORE_GPREL32, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ score_elf_gprel32_reloc, /* special_function */ "R_SCORE_GPREL32", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0xffffffff, /* src_mask */ 0xffffffff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* 32 bit symbol relative relocation. */ HOWTO (R_SCORE_REL32, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 32, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 0, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ bfd_elf_generic_reloc, /* special_function */ "R_SCORE_REL32", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0xffffffff, /* src_mask */ 0xffffffff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ /* R_SCORE_DUMMY_HI16 */ HOWTO (R_SCORE_DUMMY_HI16, /* type */ 0, /* rightshift */ 2, /* size (0 = byte, 1 = short, 2 = long) */ 16, /* bitsize */ - FALSE, /* pc_relative */ + false, /* pc_relative */ 1, /* bitpos */ complain_overflow_dont,/* complain_on_overflow */ score_elf_hi16_reloc, /* special_function */ "R_SCORE_DUMMY_HI16", /* name */ - TRUE, /* partial_inplace */ + true, /* partial_inplace */ 0x37fff, /* src_mask */ 0x37fff, /* dst_mask */ - FALSE), /* pcrel_offset */ + false), /* pcrel_offset */ }; struct score_reloc_map @@ -873,7 +869,7 @@ static const struct score_reloc_map elf32_score_reloc_map[] = {BFD_RELOC_SCORE_DUMMY_HI16, R_SCORE_DUMMY_HI16}, }; -static INLINE hashval_t +static inline hashval_t score_elf_hash_bfd_vma (bfd_vma addr) { #ifdef BFD64 @@ -915,14 +911,14 @@ score_elf_got_entry_eq (const void *entry1, const void *entry2) index. Otherwise, assign it the lowest available dynamic index. */ -static bfd_boolean +static bool score_elf_sort_hash_table_f (struct score_elf_link_hash_entry *h, void *data) { struct score_elf_hash_sort_data *hsd = data; /* Symbols without dynamic symbol table entries aren't interesting at all. */ if (h->root.dynindx == -1) - return TRUE; + return true; /* Global symbols that need GOT entries that are not explicitly referenced are marked with got offset 2. Those that are @@ -942,11 +938,11 @@ score_elf_sort_hash_table_f (struct score_elf_link_hash_entry *h, void *data) hsd->low = (struct elf_link_hash_entry *) h; } - return TRUE; + return true; } static asection * -score_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded) +score_elf_got_section (bfd *abfd, bool maybe_excluded) { asection *sgot = bfd_get_linker_section (abfd, ".got"); @@ -964,7 +960,7 @@ score_elf_got_info (bfd *abfd, asection **sgotp) asection *sgot; struct score_got_info *g; - sgot = score_elf_got_section (abfd, TRUE); + sgot = score_elf_got_section (abfd, true); BFD_ASSERT (sgot != NULL); BFD_ASSERT (elf_section_data (sgot) != NULL); g = score_elf_section_data (sgot)->u.got_info; @@ -982,7 +978,7 @@ score_elf_got_info (bfd *abfd, asection **sgotp) s7_bfd_score_elf_size_dynamic_sections, this value is 1. Afterward, the section symbols are added and the count is higher. */ -static bfd_boolean +static bool score_elf_sort_hash_table (struct bfd_link_info *info, unsigned long max_local) { @@ -1020,7 +1016,7 @@ score_elf_sort_hash_table (struct bfd_link_info *info, table index in the GOT. */ g->global_gotsym = hsd.low; - return TRUE; + return true; } /* Returns the first relocation of type r_type found, beginning with @@ -1059,11 +1055,11 @@ score_elf_sort_dynamic_relocs (const void *arg1, const void *arg2) } /* Return whether a relocation is against a local symbol. */ -static bfd_boolean +static bool score_elf_local_relocation_p (bfd *input_bfd, const Elf_Internal_Rela *relocation, asection **local_sections, - bfd_boolean check_forced) + bool check_forced) { unsigned long r_symndx; Elf_Internal_Shdr *symtab_hdr; @@ -1075,9 +1071,9 @@ score_elf_local_relocation_p (bfd *input_bfd, extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info; if (r_symndx < extsymoff) - return TRUE; + return true; if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL) - return TRUE; + return true; if (check_forced) { @@ -1089,16 +1085,16 @@ score_elf_local_relocation_p (bfd *input_bfd, || h->root.root.type == bfd_link_hash_warning) h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link; if (h->root.forced_local) - return TRUE; + return true; } - return FALSE; + return false; } /* Returns the dynamic relocation section for DYNOBJ. */ static asection * -score_elf_rel_dyn_section (bfd *dynobj, bfd_boolean create_p) +score_elf_rel_dyn_section (bfd *dynobj, bool create_p) { static const char dname[] = ".rel.dyn"; asection *sreloc; @@ -1114,8 +1110,8 @@ score_elf_rel_dyn_section (bfd *dynobj, bfd_boolean create_p) | SEC_LINKER_CREATED | SEC_READONLY)); if (sreloc == NULL - || ! bfd_set_section_alignment (dynobj, sreloc, - SCORE_ELF_LOG_FILE_ALIGN (dynobj))) + || !bfd_set_section_alignment (sreloc, + SCORE_ELF_LOG_FILE_ALIGN (dynobj))) return NULL; } return sreloc; @@ -1126,7 +1122,7 @@ score_elf_allocate_dynamic_relocations (bfd *abfd, unsigned int n) { asection *s; - s = score_elf_rel_dyn_section (abfd, FALSE); + s = score_elf_rel_dyn_section (abfd, false); BFD_ASSERT (s != NULL); if (s->size == 0) @@ -1143,7 +1139,7 @@ score_elf_allocate_dynamic_relocations (bfd *abfd, unsigned int n) dynamic relocation. The ADDENDP is adjusted if necessary; the caller should store the result in place of the original addend. */ -static bfd_boolean +static bool score_elf_create_dynamic_relocation (bfd *output_bfd, struct bfd_link_info *info, const Elf_Internal_Rela *rel, @@ -1156,11 +1152,11 @@ score_elf_create_dynamic_relocation (bfd *output_bfd, bfd *dynobj; int r_type; long indx; - bfd_boolean defined_p; + bool defined_p; r_type = ELF32_R_TYPE (rel->r_info); dynobj = elf_hash_table (info)->dynobj; - sreloc = score_elf_rel_dyn_section (dynobj, FALSE); + sreloc = score_elf_rel_dyn_section (dynobj, false); BFD_ASSERT (sreloc != NULL); BFD_ASSERT (sreloc->contents != NULL); BFD_ASSERT (sreloc->reloc_count * SCORE_ELF_REL_SIZE (output_bfd) < sreloc->size); @@ -1174,7 +1170,7 @@ score_elf_create_dynamic_relocation (bfd *output_bfd, if (outrel[0].r_offset == MINUS_ONE) /* The relocation field has been deleted. */ - return TRUE; + return true; if (outrel[0].r_offset == MINUS_TWO) { @@ -1182,7 +1178,7 @@ score_elf_create_dynamic_relocation (bfd *output_bfd, some sort. Functions like _bfd_elf_write_section_eh_frame expect the field to be fully relocated, so add in the symbol's value. */ *addendp += symbol; - return TRUE; + return true; } /* We must now calculate the dynamic symbol table index to use @@ -1198,12 +1194,12 @@ score_elf_create_dynamic_relocation (bfd *output_bfd, relocation field. It therefore treats relocs against defined symbols in the same way as relocs against undefined symbols. */ - defined_p = FALSE; + defined_p = false; } else { indx = 0; - defined_p = TRUE; + defined_p = true; } /* If the relocation was previously an absolute relocation and @@ -1255,28 +1251,28 @@ score_elf_create_dynamic_relocation (bfd *output_bfd, will be writing to it. */ elf_section_data (input_section->output_section)->this_hdr.sh_flags |= SHF_WRITE; - return TRUE; + return true; } -static bfd_boolean +static bool score_elf_create_got_section (bfd *abfd, struct bfd_link_info *info, - bfd_boolean maybe_exclude) + bool maybe_exclude) { flagword flags; asection *s; struct elf_link_hash_entry *h; struct bfd_link_hash_entry *bh; struct score_got_info *g; - bfd_size_type amt; + size_t amt; /* This function may be called more than once. */ - s = score_elf_got_section (abfd, TRUE); + s = score_elf_got_section (abfd, true); if (s) { if (! maybe_exclude) s->flags &= ~SEC_EXCLUDE; - return TRUE; + return true; } flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED); @@ -1289,8 +1285,8 @@ score_elf_create_got_section (bfd *abfd, s = bfd_make_section_anyway_with_flags (abfd, ".got", flags); elf_hash_table (info)->sgot = s; if (s == NULL - || ! bfd_set_section_alignment (abfd, s, 4)) - return FALSE; + || !bfd_set_section_alignment (s, 4)) + return false; /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the linker script because we don't want to define the symbol if we @@ -1298,8 +1294,8 @@ score_elf_create_got_section (bfd *abfd, bh = NULL; if (! (_bfd_generic_link_add_one_symbol (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s, - 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) - return FALSE; + 0, NULL, false, get_elf_backend_data (abfd)->collect, &bh))) + return false; h = (struct elf_link_hash_entry *) bh; h->non_elf = 0; @@ -1309,12 +1305,12 @@ score_elf_create_got_section (bfd *abfd, if (bfd_link_pic (info) && ! bfd_elf_link_record_dynamic_symbol (info, h)) - return FALSE; + return false; amt = sizeof (struct score_got_info); g = bfd_alloc (abfd, amt); if (g == NULL) - return FALSE; + return false; g->global_gotsym = NULL; g->global_gotno = 0; @@ -1326,11 +1322,11 @@ score_elf_create_got_section (bfd *abfd, g->got_entries = htab_try_create (1, score_elf_got_entry_hash, score_elf_got_entry_eq, NULL); if (g->got_entries == NULL) - return FALSE; + return false; score_elf_section_data (s)->u.got_info = g; score_elf_section_data (s)->elf.this_hdr.sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL; - return TRUE; + return true; } /* Calculate the %high function. */ @@ -1394,7 +1390,7 @@ score_elf_create_local_got_entry (bfd *abfd, static bfd_vma score_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, - bfd_vma value, bfd_boolean external) + bfd_vma value, bool external) { asection *sgot; struct score_got_info *g; @@ -1422,7 +1418,7 @@ score_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, void s7_bfd_score_elf_hide_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *entry, - bfd_boolean force_local) + bool force_local) { bfd *dynobj; asection *got; @@ -1432,12 +1428,12 @@ s7_bfd_score_elf_hide_symbol (struct bfd_link_info *info, h = (struct score_elf_link_hash_entry *) entry; if (h->forced_local) return; - h->forced_local = TRUE; + h->forced_local = true; dynobj = elf_hash_table (info)->dynobj; if (dynobj != NULL && force_local) { - got = score_elf_got_section (dynobj, FALSE); + got = score_elf_got_section (dynobj, false); if (got == NULL) return; g = score_elf_section_data (got)->u.got_info; @@ -1497,7 +1493,7 @@ s7_bfd_score_elf_hide_symbol (struct bfd_link_info *info, symbol table index lower than any we've seen to date, record it for posterity. */ -static bfd_boolean +static bool score_elf_record_global_got_symbol (struct elf_link_hash_entry *h, bfd *abfd, struct bfd_link_info *info, @@ -1512,11 +1508,11 @@ score_elf_record_global_got_symbol (struct elf_link_hash_entry *h, { case STV_INTERNAL: case STV_HIDDEN: - s7_bfd_score_elf_hide_symbol (info, h, TRUE); + s7_bfd_score_elf_hide_symbol (info, h, true); break; } if (!bfd_elf_link_record_dynamic_symbol (info, h)) - return FALSE; + return false; } entry.abfd = abfd; @@ -1528,31 +1524,31 @@ score_elf_record_global_got_symbol (struct elf_link_hash_entry *h, /* If we've already marked this entry as needing GOT space, we don't need to do it again. */ if (*loc) - return TRUE; + return true; *loc = bfd_alloc (abfd, sizeof entry); if (! *loc) - return FALSE; + return false; entry.gotidx = -1; memcpy (*loc, &entry, sizeof (entry)); if (h->got.offset != MINUS_ONE) - return TRUE; + return true; /* By setting this to a value other than -1, we are indicating that there needs to be a GOT entry for H. Avoid using zero, as the generic ELF copy_indirect_symbol tests for <= 0. */ h->got.offset = 1; - return TRUE; + return true; } /* Reserve space in G for a GOT entry containing the value of symbol SYMNDX in input bfd ABDF, plus ADDEND. */ -static bfd_boolean +static bool score_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend, @@ -1566,17 +1562,17 @@ score_elf_record_local_got_symbol (bfd *abfd, loc = (struct score_got_entry **) htab_find_slot (g->got_entries, &entry, INSERT); if (*loc) - return TRUE; + return true; entry.gotidx = g->local_gotno++; *loc = bfd_alloc (abfd, sizeof(entry)); if (! *loc) - return FALSE; + return false; memcpy (*loc, &entry, sizeof (entry)); - return TRUE; + return true; } /* Returns the GOT offset at which the indicated address can be found. @@ -1818,7 +1814,7 @@ score_elf_final_link_relocate (reloc_howto_type *howto, struct score_elf_link_hash_entry *h, Elf_Internal_Sym *local_syms, asection **local_sections, - bfd_boolean gp_disp_p) + bool gp_disp_p) { unsigned long r_type; unsigned long r_symndx; @@ -1835,14 +1831,14 @@ score_elf_final_link_relocate (reloc_howto_type *howto, symbol, adjusted by the addend, resides during execution. */ bfd_vma g = MINUS_ONE; /* TRUE if the symbol referred to by this relocation is a local symbol. */ - bfd_boolean local_p; + bool local_p; /* The eventual value we will relocate. */ bfd_vma value = symbol; unsigned long hi16_addend, hi16_offset, hi16_value, uvalue, offset, abs_value = 0; Elf_Internal_Sym *sym = 0; asection *sec = NULL; - bfd_boolean merge_p = 0; + bool merge_p = 0; if (elf_gp (output_bfd) == 0) @@ -1883,7 +1879,7 @@ score_elf_final_link_relocate (reloc_howto_type *howto, rel_addr = (input_section->output_section->vma + input_section->output_offset + rel->r_offset); /* For hidden symbol. */ - local_p = score_elf_local_relocation_p (input_bfd, rel, local_sections, FALSE); + local_p = score_elf_local_relocation_p (input_bfd, rel, local_sections, false); if (local_p) { sym = local_syms + r_symndx; @@ -1954,7 +1950,7 @@ score_elf_final_link_relocate (reloc_howto_type *howto, } } - local_p = score_elf_local_relocation_p (input_bfd, rel, local_sections, TRUE); + local_p = score_elf_local_relocation_p (input_bfd, rel, local_sections, true); /* If we haven't already determined the GOT offset, or the GP value, and we're going to need it, get it now. */ @@ -1975,7 +1971,7 @@ score_elf_final_link_relocate (reloc_howto_type *howto, symbol is defined locally, or was forced to be local. We must initialize this entry in the GOT. */ bfd *tmpbfd = elf_hash_table (info)->dynobj; - asection *sgot = score_elf_got_section (tmpbfd, FALSE); + asection *sgot = score_elf_got_section (tmpbfd, false); bfd_put_32 (tmpbfd, value, sgot->contents + g); } } @@ -2157,12 +2153,12 @@ score_elf_final_link_relocate (reloc_howto_type *howto, case R_SCORE_CALL15: if (local_p) { - bfd_boolean forced; + bool forced; /* The special case is when the symbol is forced to be local. We need the full address in the GOT since no R_SCORE_GOT_LO16 relocation follows. */ forced = ! score_elf_local_relocation_p (input_bfd, rel, - local_sections, FALSE); + local_sections, false); value = score_elf_got16_entry (output_bfd, input_bfd, info, symbol + addend, forced); if (value == MINUS_ONE) @@ -2214,8 +2210,8 @@ score_elf_final_link_relocate (reloc_howto_type *howto, /* Score backend functions. */ -void -s7_bfd_score_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, +bool +s7_bfd_score_info_to_howto (bfd *abfd, arelent *bfd_reloc, Elf_Internal_Rela *elf_reloc) { @@ -2223,14 +2219,21 @@ s7_bfd_score_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, r_type = ELF32_R_TYPE (elf_reloc->r_info); if (r_type >= ARRAY_SIZE (elf32_score_howto_table)) - bfd_reloc->howto = NULL; - else - bfd_reloc->howto = &elf32_score_howto_table[r_type]; + { + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: unsupported relocation type %#x"), + abfd, r_type); + bfd_set_error (bfd_error_bad_value); + return false; + } + + bfd_reloc->howto = &elf32_score_howto_table[r_type]; + return true; } /* Relocate an score ELF section. */ -bfd_boolean +int s7_bfd_score_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd, @@ -2247,7 +2250,7 @@ s7_bfd_score_elf_relocate_section (bfd *output_bfd, unsigned long offset; unsigned long hi16_addend, hi16_offset, hi16_value, uvalue; size_t extsymoff; - bfd_boolean gp_disp_p = FALSE; + bool gp_disp_p = false; /* Sort dynsym. */ if (elf_hash_table (info)->dynamic_sections_created) @@ -2266,7 +2269,7 @@ s7_bfd_score_elf_relocate_section (bfd *output_bfd, } if (!score_elf_sort_hash_table (info, dynsecsymcount + 1)) - return FALSE; + return false; } symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; @@ -2288,7 +2291,8 @@ s7_bfd_score_elf_relocate_section (bfd *output_bfd, r_symndx = ELF32_R_SYM (rel->r_info); r_type = ELF32_R_TYPE (rel->r_info); - s7_bfd_score_info_to_howto (input_bfd, &bfd_reloc, (Elf_Internal_Rela *) rel); + if (! s7_bfd_score_info_to_howto (input_bfd, &bfd_reloc, (Elf_Internal_Rela *) rel)) + continue; howto = bfd_reloc.howto; h = NULL; @@ -2401,7 +2405,7 @@ s7_bfd_score_elf_relocate_section (bfd *output_bfd, if (r_type != R_SCORE_HI16 && r_type != R_SCORE_LO16) return bfd_reloc_notsupported; - gp_disp_p = TRUE; + gp_disp_p = true; } /* If this symbol is defined, calculate its address. Note that @@ -2441,12 +2445,13 @@ s7_bfd_score_elf_relocate_section (bfd *output_bfd, } else if (!bfd_link_relocatable (info)) { - (*info->callbacks->undefined_symbol) - (info, h->root.root.root.string, input_bfd, - input_section, rel->r_offset, - (info->unresolved_syms_in_objects == RM_GENERATE_ERROR) + info->callbacks->undefined_symbol + (info, h->root.root.root.string, input_bfd, input_section, + rel->r_offset, + (info->unresolved_syms_in_objects == RM_DIAGNOSE + && !info->warn_unresolved_syms) || ELF_ST_VISIBILITY (h->root.other)); - relocation = 0; + relocation = 0; } } @@ -2533,7 +2538,7 @@ s7_bfd_score_elf_relocate_section (bfd *output_bfd, break; case bfd_reloc_undefined: (*info->callbacks->undefined_symbol) - (info, name, input_bfd, input_section, rel->r_offset, TRUE); + (info, name, input_bfd, input_section, rel->r_offset, true); break; case bfd_reloc_outofrange: @@ -2560,13 +2565,13 @@ s7_bfd_score_elf_relocate_section (bfd *output_bfd, } } - return TRUE; + return true; } /* Look through the relocs for a section during the first phase, and allocate space in the global offset table. */ -bfd_boolean +bool s7_bfd_score_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec, @@ -2583,7 +2588,7 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, asection *sreloc; if (bfd_link_relocatable (info)) - return TRUE; + return true; dynobj = elf_hash_table (info)->dynobj; symtab_hdr = &elf_tdata (abfd)->symtab_hdr; @@ -2597,7 +2602,7 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, } else { - sgot = score_elf_got_section (dynobj, FALSE); + sgot = score_elf_got_section (dynobj, false); if (sgot == NULL) g = NULL; else @@ -2627,9 +2632,9 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, { _bfd_error_handler /* xgettext:c-format */ - (_("%pB: Malformed reloc detected for section %pA"), abfd, sec); + (_("%pB: malformed reloc detected for section %pA"), abfd, sec); bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } else { @@ -2652,8 +2657,8 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, case R_SCORE_CALL15: if (dynobj == NULL) elf_hash_table (info)->dynobj = dynobj = abfd; - if (!score_elf_create_got_section (dynobj, info, FALSE)) - return FALSE; + if (!score_elf_create_got_section (dynobj, info, false)) + return false; g = score_elf_got_info (dynobj, &sgot); break; case R_SCORE_ABS32: @@ -2671,7 +2676,7 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, if (!h && (r_type == R_SCORE_GOT_LO16)) { if (! score_elf_record_local_got_symbol (abfd, r_symndx, rel->r_addend, g)) - return FALSE; + return false; } switch (r_type) @@ -2681,16 +2686,16 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, { _bfd_error_handler /* xgettext:c-format */ - (_("%pB: CALL15 reloc at %#Lx not against global symbol"), - abfd, rel->r_offset); + (_("%pB: CALL15 reloc at %#" PRIx64 " not against global symbol"), + abfd, (uint64_t) rel->r_offset); bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } else { /* This symbol requires a global offset table entry. */ if (! score_elf_record_global_got_symbol (h, abfd, info, g)) - return FALSE; + return false; /* We need a stub, not a plt entry for the undefined function. But we record it as if it needs plt. See _bfd_elf_adjust_dynamic_symbol. */ @@ -2700,7 +2705,7 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, break; case R_SCORE_GOT15: if (h && ! score_elf_record_global_got_symbol (h, abfd, info, g)) - return FALSE; + return false; break; case R_SCORE_ABS32: case R_SCORE_REL32: @@ -2709,9 +2714,9 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, { if (sreloc == NULL) { - sreloc = score_elf_rel_dyn_section (dynobj, TRUE); + sreloc = score_elf_rel_dyn_section (dynobj, true); if (sreloc == NULL) - return FALSE; + return false; } #define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY) if (bfd_link_pic (info)) @@ -2738,7 +2743,7 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, == SCORE_READONLY_SECTION) /* We need it to tell the dynamic linker if there are relocations against the text segment. */ - hscore->readonly_reloc = TRUE; + hscore->readonly_reloc = true; } /* Even though we don't directly need a GOT entry for this symbol, @@ -2748,11 +2753,11 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, { if (dynobj == NULL) elf_hash_table (info)->dynobj = dynobj = abfd; - if (! score_elf_create_got_section (dynobj, info, TRUE)) - return FALSE; + if (! score_elf_create_got_section (dynobj, info, true)) + return false; g = score_elf_got_info (dynobj, &sgot); if (! score_elf_record_global_got_symbol (h, abfd, info, g)) - return FALSE; + return false; } } break; @@ -2761,14 +2766,14 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, Reconstruct it for later use during GC. */ case R_SCORE_GNU_VTINHERIT: if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) - return FALSE; + return false; break; /* This relocation describes which C++ vtable entries are actually used. Record for later use during GC. */ case R_SCORE_GNU_VTENTRY: if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) - return FALSE; + return false; break; default: break; @@ -2784,7 +2789,7 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, struct score_elf_link_hash_entry *sh; sh = (struct score_elf_link_hash_entry *) h; - sh->no_fn_stub = TRUE; + sh->no_fn_stub = true; } break; case R_SCORE_CALL15: @@ -2792,10 +2797,10 @@ s7_bfd_score_elf_check_relocs (bfd *abfd, } } - return TRUE; + return true; } -bfd_boolean +bool s7_bfd_score_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym, @@ -2812,12 +2817,12 @@ s7_bfd_score_elf_add_symbol_hook (bfd *abfd, /* Fall through. */ case SHN_SCORE_SCOMMON: *secp = bfd_make_section_old_way (abfd, ".scommon"); - (*secp)->flags |= SEC_IS_COMMON; + (*secp)->flags |= SEC_IS_COMMON | SEC_SMALL_DATA; *valp = sym->st_size; break; } - return TRUE; + return true; } void @@ -2833,19 +2838,6 @@ s7_bfd_score_elf_symbol_processing (bfd *abfd, asymbol *asym) break; /* Fall through. */ case SHN_SCORE_SCOMMON: - if (score_elf_scom_section.name == NULL) - { - /* Initialize the small common section. */ - score_elf_scom_section.name = ".scommon"; - score_elf_scom_section.flags = SEC_IS_COMMON; - score_elf_scom_section.output_section = &score_elf_scom_section; - score_elf_scom_section.symbol = &score_elf_scom_symbol; - score_elf_scom_section.symbol_ptr_ptr = &score_elf_scom_symbol_ptr; - score_elf_scom_symbol.name = ".scommon"; - score_elf_scom_symbol.flags = BSF_SECTION_SYM; - score_elf_scom_symbol.section = &score_elf_scom_section; - score_elf_scom_symbol_ptr = &score_elf_scom_symbol; - } asym->section = &score_elf_scom_section; asym->value = elfsym->internal_elf_sym.st_size; break; @@ -2868,18 +2860,18 @@ s7_bfd_score_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_U return 1; } -bfd_boolean +bool s7_bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, int *retval) { - if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0) + if (strcmp (bfd_section_name (sec), ".scommon") == 0) { *retval = SHN_SCORE_SCOMMON; - return TRUE; + return true; } - return FALSE; + return false; } /* Adjust a symbol defined by a dynamic object and referenced by a @@ -2887,7 +2879,7 @@ s7_bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, dynamic object, but we're not including those sections. We have to change the definition to something the rest of the link can understand. */ -bfd_boolean +bool s7_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h) { @@ -2922,7 +2914,7 @@ s7_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info, if (!hscore->no_fn_stub && h->needs_plt) { if (!elf_hash_table (info)->dynamic_sections_created) - return TRUE; + return true; /* If this symbol is not defined in a regular file, then set the symbol to the stub location. This is required to make @@ -2945,7 +2937,7 @@ s7_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info, /* The last half word of the stub will be filled with the index of this symbol in .dynsym section. */ - return TRUE; + return true; } } else if ((h->type == STT_FUNC) && !h->needs_plt) @@ -2953,7 +2945,7 @@ s7_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info, /* This will set the entry for this symbol in the GOT to 0, and the dynamic linker will take care of this. */ h->root.u.def.value = 0; - return TRUE; + return true; } /* If this is a weak symbol, and there is a real definition, the @@ -2965,18 +2957,18 @@ s7_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info, BFD_ASSERT (def->root.type == bfd_link_hash_defined); h->root.u.def.section = def->root.u.def.section; h->root.u.def.value = def->root.u.def.value; - return TRUE; + return true; } /* This is a reference to a symbol defined by a dynamic object which is not a function. */ - return TRUE; + return true; } /* This function is called after all the input files have been read, and the input sections have been assigned to output sections. */ -bfd_boolean +bool s7_bfd_score_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info) { @@ -2991,11 +2983,11 @@ s7_bfd_score_elf_always_size_sections (bfd *output_bfd, dynobj = elf_hash_table (info)->dynobj; if (dynobj == NULL) /* Relocatable links don't have it. */ - return TRUE; + return true; g = score_elf_got_info (dynobj, &s); if (s == NULL) - return TRUE; + return true; /* Calculate the total loadable size of the output. That will give us the maximum number of GOT_PAGE entries required. */ @@ -3020,7 +3012,7 @@ s7_bfd_score_elf_always_size_sections (bfd *output_bfd, that need GOT entries at the end of the symbol table. We do that here. */ if (! score_elf_sort_hash_table (info, 1)) - return FALSE; + return false; if (g->global_gotsym != NULL) i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx; @@ -3049,17 +3041,17 @@ s7_bfd_score_elf_always_size_sections (bfd *output_bfd, /* Fixme. Error message or Warning message should be issued here. */ } - return TRUE; + return true; } /* Set the sizes of the dynamic sections. */ -bfd_boolean +bool s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) { bfd *dynobj; asection *s; - bfd_boolean reltext; + bool reltext; dynobj = elf_hash_table (info)->dynobj; BFD_ASSERT (dynobj != NULL); @@ -3079,7 +3071,7 @@ s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i /* The check_relocs and adjust_dynamic_symbol entry points have determined the sizes of the various dynamic sections. Allocate memory for them. */ - reltext = FALSE; + reltext = false; for (s = dynobj->sections; s != NULL; s = s->next) { const char *name; @@ -3089,9 +3081,9 @@ s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i /* It's OK to base decisions on the section name, because none of the dynobj section names depend upon the input files. */ - name = bfd_get_section_name (dynobj, s); + name = bfd_section_name (s); - if (CONST_STRNEQ (name, ".rel")) + if (startswith (name, ".rel")) { if (s->size == 0) { @@ -3102,8 +3094,7 @@ s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i the linker now does not create empty output sections. */ if (s->output_section != NULL && strcmp (name, - bfd_get_section_name (s->output_section->owner, - s->output_section)) == 0) + bfd_section_name (s->output_section)) == 0) s->flags |= SEC_EXCLUDE; } else @@ -3117,12 +3108,12 @@ s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i assert a DT_TEXTREL entry rather than testing whether there exists a relocation to a read only section or not. */ - outname = bfd_get_section_name (output_bfd, s->output_section); + outname = bfd_section_name (s->output_section); target = bfd_get_section_by_name (output_bfd, outname + 4); if ((target != NULL && (target->flags & SEC_READONLY) != 0 && (target->flags & SEC_ALLOC) != 0) || strcmp (outname, ".rel.dyn") == 0) - reltext = TRUE; + reltext = true; /* We use the reloc_count field as a counter if we need to copy relocs into the output file. */ @@ -3130,7 +3121,7 @@ s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i s->reloc_count = 0; } } - else if (CONST_STRNEQ (name, ".got")) + else if (startswith (name, ".got")) { /* s7_bfd_score_elf_always_size_sections() has already done most of the work, but some symbols may have been mapped @@ -3143,7 +3134,7 @@ s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i of .text section. So put a dummy. XXX */ s->size += SCORE_FUNCTION_STUB_SIZE; } - else if (! CONST_STRNEQ (name, ".init")) + else if (! startswith (name, ".init")) { /* It's not one of our sections, so don't allocate space. */ continue; @@ -3154,7 +3145,7 @@ s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i if (s->contents == NULL && s->size != 0) { bfd_set_error (bfd_error_no_memory); - return FALSE; + return false; } } @@ -3167,7 +3158,7 @@ s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i dynamic linker and used by the debugger. */ if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0)) - return FALSE; + return false; if (reltext) info->flags |= DF_TEXTREL; @@ -3175,47 +3166,47 @@ s7_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *i if ((info->flags & DF_TEXTREL) != 0) { if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0)) - return FALSE; + return false; } if (! SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0)) - return FALSE; + return false; - if (score_elf_rel_dyn_section (dynobj, FALSE)) + if (score_elf_rel_dyn_section (dynobj, false)) { if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0)) - return FALSE; + return false; if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0)) - return FALSE; + return false; if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0)) - return FALSE; + return false; } if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_BASE_ADDRESS, 0)) - return FALSE; + return false; if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_LOCAL_GOTNO, 0)) - return FALSE; + return false; if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_SYMTABNO, 0)) - return FALSE; + return false; if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_UNREFEXTNO, 0)) - return FALSE; + return false; if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_GOTSYM, 0)) - return FALSE; + return false; if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_HIPAGENO, 0)) - return FALSE; + return false; } - return TRUE; + return true; } -bfd_boolean +bool s7_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) { struct elf_link_hash_entry *h; @@ -3230,16 +3221,16 @@ s7_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) s = bfd_get_linker_section (abfd, ".dynamic"); if (s != NULL) { - if (!bfd_set_section_flags (abfd, s, flags)) - return FALSE; + if (!bfd_set_section_flags (s, flags)) + return false; } /* We need to create .got section. */ - if (!score_elf_create_got_section (abfd, info, FALSE)) - return FALSE; + if (!score_elf_create_got_section (abfd, info, false)) + return false; - if (!score_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE)) - return FALSE; + if (!score_elf_rel_dyn_section (elf_hash_table (info)->dynobj, true)) + return false; /* Create .stub section. */ if (bfd_get_linker_section (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL) @@ -3247,9 +3238,9 @@ s7_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) s = bfd_make_section_anyway_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME, flags | SEC_CODE); if (s == NULL - || !bfd_set_section_alignment (abfd, s, 2)) + || !bfd_set_section_alignment (s, 2)) - return FALSE; + return false; } if (!bfd_link_pic (info)) @@ -3260,8 +3251,8 @@ s7_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) bh = NULL; if (!(_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, - (bfd_vma) 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) - return FALSE; + (bfd_vma) 0, NULL, false, get_elf_backend_data (abfd)->collect, &bh))) + return false; h = (struct elf_link_hash_entry *) bh; h->non_elf = 0; @@ -3269,17 +3260,17 @@ s7_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) h->type = STT_SECTION; if (!bfd_elf_link_record_dynamic_symbol (info, h)) - return FALSE; + return false; } - return TRUE; + return true; } /* Finish up dynamic symbol handling. We set the contents of various dynamic sections here. */ -bfd_boolean +bool s7_bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info, struct elf_link_hash_entry *h, @@ -3305,7 +3296,7 @@ s7_bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd, /* FIXME: Can h->dynindex be more than 64K? */ if (h->dynindx & 0xffff0000) - return FALSE; + return false; /* Fill the stub. */ bfd_put_32 (output_bfd, STUB_LW, stub); @@ -3328,7 +3319,7 @@ s7_bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd, BFD_ASSERT (h->dynindx != -1 || h->forced_local); - sgot = score_elf_got_section (dynobj, FALSE); + sgot = score_elf_got_section (dynobj, false); BFD_ASSERT (sgot != NULL); BFD_ASSERT (score_elf_section_data (sgot) != NULL); g = score_elf_section_data (sgot)->u.got_info; @@ -3364,12 +3355,12 @@ s7_bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd, sym->st_value = elf_gp (output_bfd); } - return TRUE; + return true; } /* Finish up the dynamic sections. */ -bfd_boolean +bool s7_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) { @@ -3383,7 +3374,7 @@ s7_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, sdyn = bfd_get_linker_section (dynobj, ".dynamic"); - sgot = score_elf_got_section (dynobj, FALSE); + sgot = score_elf_got_section (dynobj, false); if (sgot == NULL) g = NULL; else @@ -3407,13 +3398,13 @@ s7_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, Elf_Internal_Dyn dyn; const char *name; size_t elemsize; - bfd_boolean swap_out_p; + bool swap_out_p; /* Read in the current dynamic entry. */ (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn); /* Assume that we're going to modify it and write it out. */ - swap_out_p = TRUE; + swap_out_p = true; switch (dyn.d_tag) { @@ -3472,7 +3463,7 @@ s7_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, break; default: - swap_out_p = FALSE; + swap_out_p = false; break; } @@ -3496,7 +3487,7 @@ s7_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, /* We need to sort the entries of the dynamic relocation section. */ - s = score_elf_rel_dyn_section (dynobj, FALSE); + s = score_elf_rel_dyn_section (dynobj, false); if (s != NULL && s->size > (bfd_vma)2 * SCORE_ELF_REL_SIZE (output_bfd)) { @@ -3505,20 +3496,20 @@ s7_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, sizeof (Elf32_External_Rel), score_elf_sort_dynamic_relocs); } - return TRUE; + return true; } /* This function set up the ELF section header for a BFD section in preparation for writing it out. This is where the flags and type fields are set for unusual sections. */ -bfd_boolean +bool s7_bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr, asection *sec) { const char *name; - name = bfd_get_section_name (abfd, sec); + name = bfd_section_name (sec); if (strcmp (name, ".got") == 0 || strcmp (name, ".srdata") == 0 @@ -3526,7 +3517,7 @@ s7_bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, || strcmp (name, ".sbss") == 0) hdr->sh_flags |= SHF_SCORE_GPREL; - return TRUE; + return true; } /* This function do additional processing on the ELF section header before writing @@ -3537,12 +3528,12 @@ s7_bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, assign_file_positions_except_relocs(); backend_section_processing after it. so, we modify section flag there, but not backend_fake_section. */ -bfd_boolean +bool s7_bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr) { if (hdr->bfd_section != NULL) { - const char *name = bfd_get_section_name (abfd, hdr->bfd_section); + const char *name = bfd_section_name (hdr->bfd_section); if (strcmp (name, ".sdata") == 0) { @@ -3561,20 +3552,20 @@ s7_bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Sh } } - return TRUE; + return true; } -bfd_boolean +bool s7_bfd_score_elf_write_section (bfd *output_bfd, asection *sec, bfd_byte *contents) { bfd_byte *to, *from, *end; int i; if (strcmp (sec->name, ".pdr") != 0) - return FALSE; + return false; if (score_elf_section_data (sec)->u.tdata == NULL) - return FALSE; + return false; to = contents; end = contents + sec->size; @@ -3591,7 +3582,7 @@ s7_bfd_score_elf_write_section (bfd *output_bfd, asection *sec, bfd_byte *conten bfd_set_section_contents (output_bfd, sec->output_section, contents, (file_ptr) sec->output_offset, sec->size); - return TRUE; + return true; } /* Copy data from a SCORE ELF indirect symbol to its direct symbol, hiding the old @@ -3614,38 +3605,38 @@ s7_bfd_score_elf_copy_indirect_symbol (struct bfd_link_info *info, dirscore->possibly_dynamic_relocs += indscore->possibly_dynamic_relocs; if (indscore->readonly_reloc) - dirscore->readonly_reloc = TRUE; + dirscore->readonly_reloc = true; if (indscore->no_fn_stub) - dirscore->no_fn_stub = TRUE; + dirscore->no_fn_stub = true; } /* Remove information about discarded functions from other sections which mention them. */ -bfd_boolean +bool s7_bfd_score_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie, struct bfd_link_info *info) { asection *o; - bfd_boolean ret = FALSE; + bool ret = false; unsigned char *tdata; size_t i, skip; o = bfd_get_section_by_name (abfd, ".pdr"); if ((!o) || (o->size == 0) || (o->size % PDR_SIZE != 0) || (o->output_section != NULL && bfd_is_abs_section (o->output_section))) - return FALSE; + return false; tdata = bfd_zmalloc (o->size / PDR_SIZE); if (!tdata) - return FALSE; + return false; cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, info->keep_memory); if (!cookie->rels) { free (tdata); - return FALSE; + return false; } cookie->rel = cookie->rels; @@ -3664,7 +3655,7 @@ s7_bfd_score_elf_discard_info (bfd *abfd, { score_elf_section_data (o)->u.tdata = tdata; o->size -= skip * PDR_SIZE; - ret = TRUE; + ret = true; } else free (tdata); @@ -3677,12 +3668,12 @@ s7_bfd_score_elf_discard_info (bfd *abfd, /* Signal that discard_info() has removed the discarded relocations for this section. */ -bfd_boolean +bool s7_bfd_score_elf_ignore_discarded_relocs (asection *sec) { if (strcmp (sec->name, ".pdr") == 0) - return TRUE; - return FALSE; + return true; + return false; } /* Return the section that should be marked against GC for a given @@ -3708,7 +3699,7 @@ s7_bfd_score_elf_gc_mark_hook (asection *sec, /* Support for core dump NOTE sections. */ -bfd_boolean +bool s7_bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) { int offset; @@ -3717,7 +3708,7 @@ s7_bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) switch (note->descsz) { default: - return FALSE; + return false; case 272: /* Linux/Score elf_prstatus */ /* pr_cursig */ @@ -3740,13 +3731,13 @@ s7_bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) note->descpos + offset); } -bfd_boolean +bool s7_bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) { switch (note->descsz) { default: - return FALSE; + return false; case 128: /* Linux/Score elf_prpsinfo. */ /* pr_fname */ @@ -3771,7 +3762,7 @@ s7_bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) command[n - 1] = '\0'; } - return TRUE; + return true; } @@ -3789,7 +3780,7 @@ s7_elf32_score_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_rea return NULL; } -bfd_boolean +bool s7_elf32_score_print_private_bfd_data (bfd *abfd, void * ptr) { FILE *file = (FILE *) ptr; @@ -3811,10 +3802,10 @@ s7_elf32_score_print_private_bfd_data (bfd *abfd, void * ptr) } fputc ('\n', file); - return TRUE; + return true; } -bfd_boolean +bool s7_elf32_score_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) { bfd *obfd = info->output_bfd; @@ -3822,21 +3813,25 @@ s7_elf32_score_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) flagword out_flags; if (!_bfd_generic_verify_endian_match (ibfd, info)) - return FALSE; + return false; + + /* FIXME: What should be checked when linking shared libraries? */ + if ((ibfd->flags & DYNAMIC) != 0) + return true; in_flags = elf_elfheader (ibfd)->e_flags; out_flags = elf_elfheader (obfd)->e_flags; if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour || bfd_get_flavour (obfd) != bfd_target_elf_flavour) - return TRUE; + return true; in_flags = elf_elfheader (ibfd)->e_flags; out_flags = elf_elfheader (obfd)->e_flags; if (! elf_flags_init (obfd)) { - elf_flags_init (obfd) = TRUE; + elf_flags_init (obfd) = true; elf_elfheader (obfd)->e_flags = in_flags; if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) @@ -3845,7 +3840,7 @@ s7_elf32_score_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd)); } - return TRUE; + return true; } if (((in_flags & EF_SCORE_PIC) != 0) != ((out_flags & EF_SCORE_PIC) != 0)) @@ -3854,18 +3849,18 @@ s7_elf32_score_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) } /* Maybe dependency fix compatibility should be checked here. */ - return TRUE; + return true; } -bfd_boolean +bool s7_elf32_score_new_section_hook (bfd *abfd, asection *sec) { struct _score_elf_section_data *sdata; - bfd_size_type amt = sizeof (*sdata); + size_t amt = sizeof (*sdata); sdata = bfd_zalloc (abfd, amt); if (sdata == NULL) - return FALSE; + return false; sec->used_by_bfd = sdata; return _bfd_elf_new_section_hook (abfd, sec);