Lines Matching defs:bed
41 const struct elf_backend_data *bed;
64 bed = get_elf_backend_data (abfd);
65 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
75 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
83 switch (bed->s->arch_size)
98 flags = bed->dynamic_sec_flags;
105 if (bed->want_got_plt)
113 if (bed->want_got_sym)
126 s->size += bed->got_header_size;
163 const struct elf_backend_data *bed;
175 bed = get_elf_backend_data (abfd);
177 flags = bed->dynamic_sec_flags;
194 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
206 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
212 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
222 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
238 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
240 elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
248 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
253 if (bed->s->arch_size == 64)
262 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
278 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
282 flags = bed->dynamic_sec_flags;
285 if (bed->plt_not_loaded)
292 if (bed->plt_readonly)
297 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
302 if (bed->want_plt_sym)
312 (bed->default_use_rela_p
316 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
322 if (bed->want_dynbss)
350 (bed->default_use_rela_p
354 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
501 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
510 (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
539 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
542 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
784 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
789 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
854 const struct elf_backend_data *bed;
880 bed = get_elf_backend_data (abfd);
884 if (!(*bed->relocs_compatible) (abfd->xvec, info->hash->creator))
986 && !(bed->is_function_type (ELF_ST_TYPE (sym->st_info))
987 && bed->is_function_type (h->type)))
1098 const struct elf_backend_data *bed
1103 (*bed->elf_backend_copy_indirect_symbol) (info, vh, h);
1119 (*bed->elf_backend_hide_symbol) (info, vh, TRUE);
1179 if (bed->is_function_type (ELF_ST_TYPE (sym->st_info))
1180 && bed->is_function_type (h->type))
1229 && !bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
1241 && !bed->is_function_type (h->type))
1248 if (bed->merge_symbol
1249 && !bed->merge_symbol (info, sym_hash, h, sym, psec, pvalue,
1302 || bed->is_function_type (ELF_ST_TYPE (sym->st_info))))))
1334 *psec = sec = bed->common_section (oldsec);
1357 || bed->is_function_type (h->type))))
1437 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1442 (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1475 const struct elf_backend_data *bed;
1508 bed = get_elf_backend_data (abfd);
1509 collect = bed->collect;
1599 (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1668 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1838 const struct elf_backend_data *bed;
1864 bed = get_elf_backend_data (sinfo->output_bfd);
1923 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2022 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2050 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2075 const struct elf_backend_data *bed;
2094 bed = get_elf_backend_data (abfd);
2097 if (shdr->sh_entsize == bed->s->sizeof_rel)
2098 swap_in = bed->s->swap_reloc_in;
2099 else if (shdr->sh_entsize == bed->s->sizeof_rela)
2100 swap_in = bed->s->swap_reloca_in;
2116 if (bed->s->arch_size == 64)
2128 irela += bed->s->int_rels_per_ext_rel;
2155 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2170 size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2201 * bed->s->int_rels_per_ext_rel))))
2291 const struct elf_backend_data *bed;
2319 bed = get_elf_backend_data (output_bfd);
2320 if (input_rel_hdr->sh_entsize == bed->s->sizeof_rel)
2321 swap_out = bed->s->swap_reloc_out;
2322 else if (input_rel_hdr->sh_entsize == bed->s->sizeof_rela)
2323 swap_out = bed->s->swap_reloca_out;
2331 * bed->s->int_rels_per_ext_rel);
2335 irela += bed->s->int_rels_per_ext_rel;
2371 const struct elf_backend_data *bed = NULL;
2434 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2435 if (bed->elf_backend_fixup_symbol
2436 && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2469 (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2477 const struct elf_backend_data *bed;
2478 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2479 (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2505 (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef,
2521 const struct elf_backend_data *bed;
2626 bed = get_elf_backend_data (dynobj);
2627 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2720 const struct elf_backend_data *bed;
2751 bed = get_elf_backend_data (hash_table->dynobj);
2756 if (!ignore_protected || !bed->is_function_type (h->type))
2783 const struct elf_backend_data *bed;
2826 bed = get_elf_backend_data (hash_table->dynobj);
2829 if (!bed->is_function_type (h->type))
2871 const struct elf_backend_data *bed;
2878 bed = get_elf_backend_data (abfd);
2880 if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2889 if (bed->common_definition (sym))
2998 const struct elf_backend_data *bed;
3008 bed = get_elf_backend_data (hash_table->dynobj);
3012 newsize = s->size + bed->s->sizeof_dyn;
3019 bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3053 const struct elf_backend_data *bed;
3056 bed = get_elf_backend_data (hash_table->dynobj);
3061 extdyn += bed->s->sizeof_dyn)
3065 bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3140 const struct elf_backend_data *bed;
3146 bed = get_elf_backend_data (dynobj);
3153 extdyn += bed->s->sizeof_dyn)
3157 bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3174 bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3308 const struct elf_backend_data *bed;
3326 bed = get_elf_backend_data (abfd);
3409 FALSE, bed->collect, NULL)))
3487 extdyn += bed->s->sizeof_dyn)
3491 bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3641 symcount = hdr->sh_size / bed->s->sizeof_sym;
3798 common = bed->common_definition (isym);
3876 else if (bed->elf_add_symbol_hook)
3878 if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3902 type_change_ok = bed->type_change_ok;
3934 || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4067 (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4081 && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4228 if (bed->elf_backend_merge_symbol_attribute)
4229 (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
4300 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4349 (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4404 if (bed->as_needed_cleanup)
4405 (*bed->as_needed_cleanup) (abfd, info);
4493 (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4496 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4549 && !bed->is_function_type (h->type))
4651 if (bed->check_directives)
4652 (*bed->check_directives) (abfd, info);
4673 && bed->check_relocs != NULL
4674 && (*bed->relocs_compatible) (abfd->xvec, htab->root.creator))
4695 ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4852 const struct elf_backend_data *bed;
4879 bed = get_elf_backend_data (abfd);
4880 archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
5075 const struct elf_backend_data *bed;
5112 if (! (*s->bed->elf_hash_symbol) (h))
5160 if (! (*s->bed->elf_hash_symbol) (h))
5236 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5292 max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5302 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5313 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5363 const struct elf_backend_data *bed;
5373 bed = get_elf_backend_data (output_bfd);
5400 else if (bed->default_execstack)
5421 if (bed->elf_backend_always_size_sections
5422 && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5710 bed->s->sizeof_sym))
5717 if (bed->elf_backend_size_dynamic_sections
5718 && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
6142 const struct elf_backend_data *bed;
6147 bed = get_elf_backend_data (output_bfd);
6148 (*bed->elf_backend_init_index_section) (output_bfd, info);
6191 s->size = dynsymcount * bed->s->sizeof_sym;
6202 memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6275 cinfo.bed = bed;
6298 s->size = 5 * 4 + bed->s->arch_size / 8;
6312 bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6315 contents + 16 + bed->s->arch_size / 8);
6329 if (bed->s->arch_size == 64)
6405 bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6407 contents += bed->s->arch_size / 8;
6850 const struct elf_backend_data * bed;
6865 bed = get_elf_backend_data (input_bfd);
6908 if (bed->s->arch_size == 64)
7082 const struct elf_backend_data * bed;
7097 bed = get_elf_backend_data (input_bfd);
7098 if (bed->s->arch_size == 64)
7214 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7221 if (rel_hdr->sh_entsize == bed->s->sizeof_rel)
7223 swap_in = bed->s->swap_reloc_in;
7224 swap_out = bed->s->swap_reloc_out;
7226 else if (rel_hdr->sh_entsize == bed->s->sizeof_rela)
7228 swap_in = bed->s->swap_reloca_in;
7229 swap_out = bed->s->swap_reloca_out;
7234 if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
7237 if (bed->s->arch_size == 32)
7260 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
7337 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7338 int i2e = bed->s->int_rels_per_ext_rel;
7364 if ((o->size % bed->s->sizeof_rela) == 0)
7366 if ((o->size % bed->s->sizeof_rel) == 0)
7387 else if ((o->size % bed->s->sizeof_rel) == 0)
7418 if ((o->size % bed->s->sizeof_rela) == 0)
7420 if ((o->size % bed->s->sizeof_rel) == 0)
7441 else if ((o->size % bed->s->sizeof_rel) == 0)
7481 ext_size = bed->s->sizeof_rela;
7482 swap_in = bed->s->swap_reloca_in;
7483 swap_out = bed->s->swap_reloca_out;
7488 ext_size = bed->s->sizeof_rel;
7489 swap_in = bed->s->swap_reloc_in;
7490 swap_out = bed->s->swap_reloc_out;
7514 if (bed->s->arch_size == 32)
7542 s->type = (*bed->elf_backend_reloc_type_class) (s->rela);
7598 const struct elf_backend_data *bed)
7608 amt = finfo->symbuf_count * bed->s->sizeof_sym;
7634 const struct elf_backend_data *bed;
7636 bed = get_elf_backend_data (finfo->output_bfd);
7637 output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
7658 if (! elf_link_flush_output_syms (finfo, bed))
7662 dest = finfo->symbuf + finfo->symbuf_count * bed->s->sizeof_sym;
7680 bed->s->swap_symbol_out (finfo->output_bfd, elfsym, dest, destshndx);
7713 const struct elf_backend_data *bed,
7773 symcount = hdr->sh_size / bed->s->sizeof_sym;
7868 const struct elf_backend_data *bed;
7889 bed = get_elf_backend_data (finfo->output_bfd);
7900 if (bed->elf_backend_ignore_undef_symbol)
7901 ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
7907 && ! elf_link_check_versioned_symbol (finfo->info, bed, h)
7928 && ! elf_link_check_versioned_symbol (finfo->info, bed, h))
8048 sym.st_shndx = bed->common_section_index (input_sec);
8074 if (! ((*bed->elf_backend_finish_dynamic_symbol)
8131 esym = finfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
8137 bed->s->swap_symbol_out (finfo->output_bfd, &sym, esym, 0);
8214 const struct elf_backend_data *bed;
8225 bed = get_elf_backend_data (sec->owner);
8226 if (bed->elf_backend_ignore_discarded_relocs != NULL
8227 && (*bed->elf_backend_ignore_discarded_relocs) (sec))
8321 const struct elf_backend_data *bed;
8325 bed = get_elf_backend_data (output_bfd);
8326 relocate_section = bed->elf_backend_relocate_section;
8337 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
8559 if (bed->s->arch_size == 32)
8578 unsigned int action = (*bed->action_discarded) (o);
8581 relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
8709 rela_normal = (bed->rela_normal
8711 == bed->s->sizeof_rela));
8716 irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
8730 if (next_erel == bed->s->int_rels_per_ext_rel)
8924 && !bed->elf_backend_emit_relocs (output_bfd, o,
8934 * bed->s->int_rels_per_ext_rel);
8936 if (!bed->elf_backend_emit_relocs (output_bfd, o,
8946 if (bed->elf_backend_write_section
8947 && (*bed->elf_backend_write_section) (output_bfd, finfo->info, o,
9006 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
9124 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
9130 if (bed->s->arch_size == 32)
9140 * bed->s->sizeof_rel);
9141 (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
9147 * bed->s->sizeof_rela);
9148 (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
9177 const struct elf_backend_data *bed
9179 if (bed->link_order_error_handler)
9180 bed->link_order_error_handler
9222 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9239 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
9324 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9455 else if (bed->elf_backend_count_relocs)
9466 = (*bed->elf_backend_count_relocs) (sec, relocs);
9487 / bed->s->sizeof_sym);
9529 BFD_ASSERT (entsize1 == bed->s->sizeof_rel
9530 || entsize1 == bed->s->sizeof_rela);
9531 same_size = !o->use_rela_p == (entsize1 == bed->s->sizeof_rel);
9543 && (entsize2 == bed->s->sizeof_rel
9544 || entsize2 == bed->s->sizeof_rela));
9552 BFD_ASSERT (bed->elf_backend_count_relocs == NULL);
9624 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
9628 symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
9644 amt *= bed->s->sizeof_sym;
9721 amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
9730 amt = max_sym_count * bed->s->sizeof_sym;
9820 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
9871 if (bed->elf_backend_output_arch_local_syms)
9877 if (! ((*bed->elf_backend_output_arch_local_syms)
9922 dest = dynsym + dynindx * bed->s->sizeof_sym;
9925 bed->s->swap_symbol_out (abfd, &sym, dest, 0);
9965 dest = dynsym + e->dynindx * bed->s->sizeof_sym;
9966 bed->s->swap_symbol_out (abfd, &sym, dest, 0);
9985 if (bed->elf_backend_output_arch_syms)
9991 if (! ((*bed->elf_backend_output_arch_syms)
9997 if (! elf_link_flush_output_syms (&finfo, bed))
10080 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
10086 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
10093 if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
10230 bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
10237 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
10251 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
10255 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
10468 const struct elf_backend_data *bed = get_elf_backend_data (input_bfd);
10478 nlocsyms = symtab_hdr->sh_size / bed->s->sizeof_sym;
10501 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
10503 if (bed->s->arch_size == 32)
10598 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10599 gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
10663 sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
10713 const struct elf_backend_data *bed;
10716 bed = get_elf_backend_data (h->root.u.def.section->owner);
10717 log_file_align = bed->s->log_file_align;
10738 const struct elf_backend_data *bed;
10759 bed = get_elf_backend_data (sec->owner);
10760 log_file_align = bed->s->log_file_align;
10762 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
10814 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10816 if (!bed->can_gc_sections
10842 bed->gc_mark_dynamic_ref,
10846 gc_mark_hook = bed->gc_mark_hook;
10861 if (bed->gc_mark_extra_sections)
10862 bed->gc_mark_extra_sections(info, gc_mark_hook);
10942 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10947 extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
11001 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11002 unsigned int log_file_align = bed->s->log_file_align;
11101 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11103 unsigned int got_elt_size = bed->s->arch_size / 8;
11111 if (bed->want_got_plt)
11114 gotoff = bed->got_header_size;
11132 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11244 const struct elf_backend_data *bed;
11258 bed = get_elf_backend_data (abfd);
11282 && bed->elf_backend_discard_info == NULL)
11291 cookie.locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11300 if (bed->s->arch_size == 32)
11329 cookie.relend += count * bed->s->int_rels_per_ext_rel;
11350 cookie.relend += count * bed->s->int_rels_per_ext_rel;
11362 if (bed->elf_backend_discard_info != NULL
11363 && (*bed->elf_backend_discard_info) (abfd, &cookie, info))