X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Felf-eh-frame.c;h=7a129b00f8d78fecd8c450ef8aca564eea4a9485;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=02152fee02ab4b72dd72c30839d5b28a41101b81;hpb=4eca02287cf48e60ee89338ddd35f8d0d8257a51;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elf-eh-frame.c b/bfd/elf-eh-frame.c index 02152fee02..7a129b00f8 100644 --- a/bfd/elf-eh-frame.c +++ b/bfd/elf-eh-frame.c @@ -1,5 +1,5 @@ /* .eh_frame section optimization. - Copyright (C) 2001-2016 Free Software Foundation, Inc. + Copyright (C) 2001-2020 Free Software Foundation, Inc. Written by Jakub Jelinek . This file is part of BFD, the Binary File Descriptor library. @@ -309,11 +309,10 @@ extra_augmentation_data_bytes (struct eh_cie_fde *entry) return size; } -/* Return the size that ENTRY will have in the output. ALIGNMENT is the - required alignment of ENTRY in bytes. */ +/* Return the size that ENTRY will have in the output. */ static unsigned int -size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment) +size_of_output_cie_fde (struct eh_cie_fde *entry) { if (entry->removed) return 0; @@ -321,8 +320,22 @@ size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment) return 4; return (entry->size + extra_augmentation_string_bytes (entry) - + extra_augmentation_data_bytes (entry) - + alignment - 1) & -alignment; + + extra_augmentation_data_bytes (entry)); +} + +/* Return the offset of the FDE or CIE after ENT. */ + +static unsigned int +next_cie_fde_offset (const struct eh_cie_fde *ent, + const struct eh_cie_fde *last, + const asection *sec) +{ + while (++ent < last) + { + if (!ent->removed) + return ent->new_offset; + } + return sec->size; } /* Assume that the bytes between *ITER and END are CFA instructions. @@ -470,7 +483,7 @@ bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info) hdr_info->array_count--; hdr_info->u.compact.entries[hdr_info->array_count] = NULL; i--; - } + } } } @@ -606,15 +619,6 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf)); - if (sec->size >= 4 - && bfd_get_32 (abfd, ehbuf) == 0 - && cookie->rel == cookie->relend) - { - /* Empty .eh_frame section. */ - free (ehbuf); - return; - } - /* If .eh_frame section size doesn't fit into int, we cannot handle it (it would need to use 64-bit .eh_frame format anyway). */ REQUIRE (sec->size == (unsigned int) sec->size); @@ -652,12 +656,15 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, sec_info = (struct eh_frame_sec_info *) bfd_zmalloc (sizeof (struct eh_frame_sec_info) - + (num_entries - 1) * sizeof (struct eh_cie_fde)); + + (num_entries - 1) * sizeof (struct eh_cie_fde)); REQUIRE (sec_info); /* We need to have a "struct cie" for each CIE in this section. */ - local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies)); - REQUIRE (local_cies); + if (num_cies) + { + local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies)); + REQUIRE (local_cies); + } /* FIXME: octets_per_byte. */ #define ENSURE_NO_RELOCS(buf) \ @@ -711,7 +718,9 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, if (hdr_length == 0) { /* A zero-length CIE should only be found at the end of - the section. */ + the section, but allow multiple terminators. */ + while (skip_bytes (&buf, ehbuf + sec->size, 4)) + REQUIRE (bfd_get_32 (abfd, buf - 4) == 0); REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size); ENSURE_NO_RELOCS (buf); sec_info->count++; @@ -744,6 +753,7 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, strcpy (cie->augmentation, (char *) buf); buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1; + this_inf->u.cie.aug_str_len = buf - start - 1; ENSURE_NO_RELOCS (buf); if (buf[0] == 'e' && buf[1] == 'h') { @@ -781,12 +791,14 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, { aug++; REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size)); - ENSURE_NO_RELOCS (buf); + ENSURE_NO_RELOCS (buf); } while (*aug != '\0') switch (*aug++) { + case 'B': + break; case 'L': REQUIRE (read_byte (&buf, end, &cie->lsda_encoding)); ENSURE_NO_RELOCS (buf); @@ -811,6 +823,8 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, { length = -(buf - ehbuf) & (per_width - 1); REQUIRE (skip_bytes (&buf, end, length)); + if (per_width == 8) + this_inf->u.cie.per_encoding_aligned8 = 1; } this_inf->u.cie.personality_offset = buf - start; ENSURE_NO_RELOCS (buf); @@ -830,6 +844,8 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, goto free_no_table; } } + this_inf->u.cie.aug_data_len + = buf - start - 1 - this_inf->u.cie.aug_str_len; /* For shared libraries, try to get rid of as many RELATIVE relocs as possible. */ @@ -924,7 +940,8 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, && read_value (abfd, buf - length, length, FALSE) == 0) { (*info->callbacks->minfo) - (_("discarding zero address range FDE in %B(%A).\n"), + /* xgettext:c-format */ + (_("discarding zero address range FDE in %pB(%pA).\n"), abfd, sec); this_inf->u.fde.cie_inf = NULL; } @@ -995,7 +1012,7 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, bfd_byte *p; this_inf->set_loc = (unsigned int *) - bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int)); + bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int)); REQUIRE (this_inf->set_loc); this_inf->set_loc[0] = set_loc_count; p = insns; @@ -1027,17 +1044,15 @@ _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, goto success; free_no_table: - (*info->callbacks->einfo) - (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"), + _bfd_error_handler + /* xgettext:c-format */ + (_("error in %pB(%pA); no .eh_frame_hdr table will be created"), abfd, sec); hdr_info->u.dwarf.table = FALSE; - if (sec_info) - free (sec_info); + free (sec_info); success: - if (ehbuf) - free (ehbuf); - if (local_cies) - free (local_cies); + free (ehbuf); + free (local_cies); #undef REQUIRE } @@ -1091,7 +1106,7 @@ add_eh_frame_hdr_terminator (asection *sec, if (!sec->rawsize) sec->rawsize = sec->size; - bfd_set_section_size (sec->owner, sec, sec->size + 8); + bfd_set_section_size (sec, sec->size + 8); } /* Finish a pass over all .eh_frame_entry sections. */ @@ -1310,6 +1325,143 @@ find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec, return new_cie->cie_inf; } +/* For a given OFFSET in SEC, return the delta to the new location + after .eh_frame editing. */ + +static bfd_signed_vma +offset_adjust (bfd_vma offset, const asection *sec) +{ + struct eh_frame_sec_info *sec_info + = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; + unsigned int lo, hi, mid; + struct eh_cie_fde *ent = NULL; + bfd_signed_vma delta; + + lo = 0; + hi = sec_info->count; + if (hi == 0) + return 0; + + while (lo < hi) + { + mid = (lo + hi) / 2; + ent = &sec_info->entry[mid]; + if (offset < ent->offset) + hi = mid; + else if (mid + 1 >= hi) + break; + else if (offset >= ent[1].offset) + lo = mid + 1; + else + break; + } + + if (!ent->removed) + delta = (bfd_vma) ent->new_offset - (bfd_vma) ent->offset; + else if (ent->cie && ent->u.cie.merged) + { + struct eh_cie_fde *cie = ent->u.cie.u.merged_with; + delta = ((bfd_vma) cie->new_offset + cie->u.cie.u.sec->output_offset + - (bfd_vma) ent->offset - sec->output_offset); + } + else + { + /* Is putting the symbol on the next entry best for a deleted + CIE/FDE? */ + struct eh_cie_fde *last = sec_info->entry + sec_info->count; + delta = ((bfd_vma) next_cie_fde_offset (ent, last, sec) + - (bfd_vma) ent->offset); + return delta; + } + + /* Account for editing within this CIE/FDE. */ + offset -= ent->offset; + if (ent->cie) + { + unsigned int extra + = ent->add_augmentation_size + ent->u.cie.add_fde_encoding; + if (extra == 0 + || offset <= 9u + ent->u.cie.aug_str_len) + return delta; + delta += extra; + if (offset <= 9u + ent->u.cie.aug_str_len + ent->u.cie.aug_data_len) + return delta; + delta += extra; + } + else + { + unsigned int ptr_size, width, extra = ent->add_augmentation_size; + if (offset <= 12 || extra == 0) + return delta; + ptr_size = (get_elf_backend_data (sec->owner) + ->elf_backend_eh_frame_address_size (sec->owner, sec)); + width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); + if (offset <= 8 + 2 * width) + return delta; + delta += extra; + } + + return delta; +} + +/* Adjust a global symbol defined in .eh_frame, so that it stays + relative to its original CIE/FDE. It is assumed that a symbol + defined at the beginning of a CIE/FDE belongs to that CIE/FDE + rather than marking the end of the previous CIE/FDE. This matters + when a CIE is merged with a previous CIE, since the symbol is + moved to the merged CIE. */ + +bfd_boolean +_bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry *h, + void *arg ATTRIBUTE_UNUSED) +{ + asection *sym_sec; + bfd_signed_vma delta; + + if (h->root.type != bfd_link_hash_defined + && h->root.type != bfd_link_hash_defweak) + return TRUE; + + sym_sec = h->root.u.def.section; + if (sym_sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME + || elf_section_data (sym_sec)->sec_info == NULL) + return TRUE; + + delta = offset_adjust (h->root.u.def.value, sym_sec); + h->root.u.def.value += delta; + + return TRUE; +} + +/* The same for all local symbols defined in .eh_frame. Returns true + if any symbol was changed. */ + +static int +adjust_eh_frame_local_symbols (const asection *sec, + struct elf_reloc_cookie *cookie) +{ + unsigned int shndx; + Elf_Internal_Sym *sym; + Elf_Internal_Sym *end_sym; + int adjusted = 0; + + shndx = elf_section_data (sec)->this_idx; + end_sym = cookie->locsyms + cookie->locsymcount; + for (sym = cookie->locsyms + 1; sym < end_sym; ++sym) + if (sym->st_info <= ELF_ST_INFO (STB_LOCAL, STT_OBJECT) + && sym->st_shndx == shndx) + { + bfd_signed_vma delta = offset_adjust (sym->st_value, sec); + + if (delta != 0) + { + adjusted = 1; + sym->st_value += delta; + } + } + return adjusted; +} + /* This function is called for each input file before the .eh_frame section is relocated. It discards duplicate CIEs and FDEs for discarded functions. The function returns TRUE iff any entries have been @@ -1324,7 +1476,8 @@ _bfd_elf_discard_section_eh_frame struct eh_cie_fde *ent; struct eh_frame_sec_info *sec_info; struct eh_frame_hdr_info *hdr_info; - unsigned int ptr_size, offset; + unsigned int ptr_size, offset, eh_alignment; + int changed; if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) return FALSE; @@ -1376,18 +1529,23 @@ _bfd_elf_discard_section_eh_frame don't create the binary search table, since it is affected by runtime relocations. */ hdr_info->u.dwarf.table = FALSE; - if (num_warnings_issued < 10) - { - (*info->callbacks->einfo) - (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr" - " table being created.\n"), abfd, sec); - num_warnings_issued ++; - } - else if (num_warnings_issued == 10) + /* Only warn if --eh-frame-hdr was specified. */ + if (info->eh_frame_hdr_type != 0) { - (*info->callbacks->einfo) - (_("%P: Further warnings about FDE encoding preventing .eh_frame_hdr generation dropped.\n")); - num_warnings_issued ++; + if (num_warnings_issued < 10) + { + _bfd_error_handler + /* xgettext:c-format */ + (_("FDE encoding in %pB(%pA) prevents .eh_frame_hdr" + " table being created"), abfd, sec); + num_warnings_issued ++; + } + else if (num_warnings_issued == 10) + { + _bfd_error_handler + (_("further warnings about FDE encoding preventing .eh_frame_hdr generation dropped")); + num_warnings_issued ++; + } } } ent->removed = 0; @@ -1397,23 +1555,54 @@ _bfd_elf_discard_section_eh_frame } } - if (sec_info->cies) - { - free (sec_info->cies); - sec_info->cies = NULL; - } + free (sec_info->cies); + sec_info->cies = NULL; + /* It may be that some .eh_frame input section has greater alignment + than other .eh_frame sections. In that case we run the risk of + padding with zeros before that section, which would be seen as a + zero terminator. Alignment padding must be added *inside* the + last FDE instead. For other FDEs we align according to their + encoding, in order to align FDE address range entries naturally. */ offset = 0; + changed = 0; for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) if (!ent->removed) { + eh_alignment = 4; + if (ent->size == 4) + ; + else if (ent->cie) + { + if (ent->u.cie.per_encoding_aligned8) + eh_alignment = 8; + } + else + { + eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); + if (eh_alignment < 4) + eh_alignment = 4; + } + offset = (offset + eh_alignment - 1) & -eh_alignment; ent->new_offset = offset; - offset += size_of_output_cie_fde (ent, ptr_size); + if (ent->new_offset != ent->offset) + changed = 1; + offset += size_of_output_cie_fde (ent); } + eh_alignment = 4; + offset = (offset + eh_alignment - 1) & -eh_alignment; sec->rawsize = sec->size; sec->size = offset; - return offset != sec->rawsize; + if (sec->size != sec->rawsize) + changed = 1; + + if (changed && adjust_eh_frame_local_symbols (sec, cookie)) + { + Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + symtab_hdr->contents = (unsigned char *) cookie->locsyms; + } + return changed; } /* This function is called for .eh_frame_hdr section after @@ -1443,7 +1632,7 @@ _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) if (info->eh_frame_hdr_type == COMPACT_EH_HDR) { /* For compact frames we only add the header. The actual table comes - from the .eh_frame_entry sections. */ + from the .eh_frame_entry sections. */ sec->size = 8; } else @@ -1491,7 +1680,7 @@ _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info) { for (o = abfd->sections; o; o = o->next) { - const char *name = bfd_get_section_name (abfd, o); + const char *name = bfd_section_name (o); if (strcmp (name, ".eh_frame_entry") && !bfd_is_abs_section (o->output_section)) @@ -1673,7 +1862,8 @@ _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info, addr = bfd_get_signed_32 (abfd, contents + offset) + offset; if (addr <= last_addr) { - _bfd_error_handler (_("%B: %s not in order"), sec->owner, sec->name); + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec); return FALSE; } @@ -1686,15 +1876,17 @@ _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info, addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize); if (addr & 1) { - _bfd_error_handler (_("%B: %s invalid input section size"), - sec->owner, sec->name); + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: %pA invalid input section size"), + sec->owner, sec); bfd_set_error (bfd_error_bad_value); return FALSE; } if (last_addr >= addr + sec->rawsize) { - _bfd_error_handler (_("%B: %s points past end of text section"), - sec->owner, sec->name); + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: %pA points past end of text section"), + sec->owner, sec); bfd_set_error (bfd_error_bad_value); return FALSE; } @@ -1726,8 +1918,7 @@ _bfd_elf_write_section_eh_frame (bfd *abfd, struct elf_link_hash_table *htab; struct eh_frame_hdr_info *hdr_info; unsigned int ptr_size; - struct eh_cie_fde *ent; - bfd_size_type sec_size; + struct eh_cie_fde *ent, *last_ent; if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) /* FIXME: octets_per_byte. */ @@ -1746,7 +1937,7 @@ _bfd_elf_write_section_eh_frame (bfd *abfd, { hdr_info->frame_hdr_is_compact = FALSE; hdr_info->u.dwarf.array = (struct eh_frame_array_ent *) - bfd_malloc (hdr_info->u.dwarf.fde_count + bfd_malloc (hdr_info->u.dwarf.fde_count * sizeof (*hdr_info->u.dwarf.array)); } if (hdr_info->u.dwarf.array == NULL) @@ -1765,7 +1956,8 @@ _bfd_elf_write_section_eh_frame (bfd *abfd, if (!ent->removed && ent->new_offset < ent->offset) memmove (contents + ent->new_offset, contents + ent->offset, ent->size); - for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) + last_ent = sec_info->entry + sec_info->count; + for (ent = sec_info->entry; ent < last_ent; ++ent) { unsigned char *buf, *end; unsigned int new_size; @@ -1776,13 +1968,13 @@ _bfd_elf_write_section_eh_frame (bfd *abfd, if (ent->size == 4) { /* Any terminating FDE must be at the end of the section. */ - BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1); + BFD_ASSERT (ent == last_ent - 1); continue; } buf = contents + ent->new_offset; end = buf + ent->size; - new_size = size_of_output_cie_fde (ent, ptr_size); + new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset; /* Update the size. It may be shrinked. */ bfd_put_32 (abfd, new_size - 4, buf); @@ -1799,7 +1991,7 @@ _bfd_elf_write_section_eh_frame (bfd *abfd, || ent->u.cie.per_encoding_relative) { char *aug; - unsigned int action, extra_string, extra_data; + unsigned int version, action, extra_string, extra_data; unsigned int per_width, per_encoding; /* Need to find 'R' or 'L' augmentation's argument and modify @@ -1810,13 +2002,17 @@ _bfd_elf_write_section_eh_frame (bfd *abfd, extra_string = extra_augmentation_string_bytes (ent); extra_data = extra_augmentation_data_bytes (ent); - /* Skip length, id and version. */ - buf += 9; + /* Skip length, id. */ + buf += 8; + version = *buf++; aug = (char *) buf; buf += strlen (aug) + 1; skip_leb128 (&buf, end); skip_leb128 (&buf, end); - skip_leb128 (&buf, end); + if (version == 1) + skip_bytes (&buf, end, 1); + else + skip_leb128 (&buf, end); if (*aug == 'z') { /* The uleb128 will always be a single byte for the kind @@ -1941,12 +2137,13 @@ _bfd_elf_write_section_eh_frame (bfd *abfd, address += elf_gp (abfd); break; default: - (*info->callbacks->einfo) - (_("%P: DW_EH_PE_datarel unspecified" - " for this architecture.\n")); + _bfd_error_handler + (_("DW_EH_PE_datarel unspecified" + " for this architecture")); /* Fall thru */ case bfd_arch_frv: case bfd_arch_i386: + case bfd_arch_nios2: BFD_ASSERT (htab->hgot != NULL && ((htab->hgot->root.type == bfd_link_hash_defined) @@ -2053,18 +2250,6 @@ _bfd_elf_write_section_eh_frame (bfd *abfd, } } - /* We don't align the section to its section alignment since the - runtime library only expects all CIE/FDE records aligned at - the pointer size. _bfd_elf_discard_section_eh_frame should - have padded CIE/FDE records to multiple of pointer size with - size_of_output_cie_fde. */ - sec_size = sec->size; - if (sec_info->count != 0 - && sec_info->entry[sec_info->count - 1].size == 4) - sec_size -= 4; - if ((sec_size % ptr_size) != 0) - abort (); - /* FIXME: octets_per_byte. */ return bfd_set_section_contents (abfd, sec->output_section, contents, (file_ptr) sec->output_offset, @@ -2124,8 +2309,8 @@ _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info) if (sec->output_section != osec) { _bfd_error_handler - (_("Invalid output section for .eh_frame_entry: %s"), - sec->output_section->name); + (_("invalid output section for .eh_frame_entry: %pA"), + sec->output_section); return FALSE; } sec->output_offset = offset; @@ -2141,13 +2326,13 @@ _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info) p->offset = p->u.indirect.section->output_offset; if (p->next != NULL) - i--; + i--; } if (i != 0) { _bfd_error_handler - (_("Invalid contents in %s section"), osec->name); + (_("invalid contents in %pA section"), osec); return FALSE; } @@ -2196,7 +2381,7 @@ write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) /* The .eh_frame_hdr format for DWARF frames: ubyte version (currently 1) - ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of + ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of .eh_frame section) ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count number (or DW_EH_PE_omit if there is no @@ -2303,10 +2488,9 @@ write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) overlap = TRUE; } if (overflow) - (*info->callbacks->einfo) (_("%P: .eh_frame_hdr entry overflow.\n")); + _bfd_error_handler (_(".eh_frame_hdr entry overflow")); if (overlap) - (*info->callbacks->einfo) - (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n")); + _bfd_error_handler (_(".eh_frame_hdr refers to overlapping FDEs")); if (overflow || overlap) { bfd_set_error (bfd_error_bad_value); @@ -2321,8 +2505,7 @@ write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) retval = FALSE; free (contents); - if (hdr_info->u.dwarf.array != NULL) - free (hdr_info->u.dwarf.array); + free (hdr_info->u.dwarf.array); return retval; } @@ -2353,7 +2536,7 @@ _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) /* Return the width of FDE addresses. This is the default implementation. */ unsigned int -_bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED) +_bfd_elf_eh_frame_address_size (bfd *abfd, const asection *sec ATTRIBUTE_UNUSED) { return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4; }