/* .eh_frame section optimization.
- Copyright (C) 2001-2020 Free Software Foundation, Inc.
+ Copyright (C) 2001-2021 Free Software Foundation, Inc.
Written by Jakub Jelinek <jakub@redhat.com>.
This file is part of BFD, the Binary File Descriptor library.
/* If *ITER hasn't reached END yet, read the next byte into *RESULT and
move onto the next byte. Return true on success. */
-static inline bfd_boolean
+static inline bool
read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
{
if (*iter >= end)
- return FALSE;
+ return false;
*result = *((*iter)++);
- return TRUE;
+ return true;
}
/* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
Return true it was possible to move LENGTH bytes. */
-static inline bfd_boolean
+static inline bool
skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
{
if ((bfd_size_type) (end - *iter) < length)
{
*iter = end;
- return FALSE;
+ return false;
}
*iter += length;
- return TRUE;
+ return true;
}
/* Move *ITER over an leb128, stopping at END. Return true if the end
of the leb128 was found. */
-static bfd_boolean
+static bool
skip_leb128 (bfd_byte **iter, bfd_byte *end)
{
unsigned char byte;
do
if (!read_byte (iter, end, &byte))
- return FALSE;
+ return false;
while (byte & 0x80);
- return TRUE;
+ return true;
}
/* Like skip_leb128, but treat the leb128 as an unsigned value and
store it in *VALUE. */
-static bfd_boolean
+static bool
read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
{
bfd_byte *start, *p;
start = *iter;
if (!skip_leb128 (iter, end))
- return FALSE;
+ return false;
p = *iter;
*value = *--p;
while (p > start)
*value = (*value << 7) | (*--p & 0x7f);
- return TRUE;
+ return true;
}
/* Like read_uleb128, but for signed values. */
-static bfd_boolean
+static bool
read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
{
bfd_byte *start, *p;
start = *iter;
if (!skip_leb128 (iter, end))
- return FALSE;
+ return false;
p = *iter;
*value = ((*--p & 0x7f) ^ 0x40) - 0x40;
while (p > start)
*value = (*value << 7) | (*--p & 0x7f);
- return TRUE;
+ return true;
}
/* Return 0 if either encoding is variable width, or not yet known to bfd. */
Try to move *ITER past the first instruction and return true on
success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
-static bfd_boolean
+static bool
skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
{
bfd_byte op;
bfd_vma length;
if (!read_byte (iter, end, &op))
- return FALSE;
+ return false;
switch (op & 0xc0 ? op & 0xc0 : op)
{
case DW_CFA_restore_state:
case DW_CFA_GNU_window_save:
/* No arguments. */
- return TRUE;
+ return true;
case DW_CFA_offset:
case DW_CFA_restore_extended:
return skip_bytes (iter, end, 8);
default:
- return FALSE;
+ return false;
}
}
{
if (hdr_info->u.compact.allocated_entries == 0)
{
- hdr_info->frame_hdr_is_compact = TRUE;
+ hdr_info->frame_hdr_is_compact = true;
hdr_info->u.compact.allocated_entries = 2;
hdr_info->u.compact.entries =
bfd_malloc (hdr_info->u.compact.allocated_entries
/* Parse a .eh_frame_entry section. Figure out which text section it
references. */
-bfd_boolean
+bool
_bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info,
asection *sec, struct elf_reloc_cookie *cookie)
{
if (sec->size == 0
|| sec->sec_info_type != SEC_INFO_TYPE_NONE)
{
- return TRUE;
+ return true;
}
if (sec->output_section && bfd_is_abs_section (sec->output_section))
{
/* At least one of the sections is being discarded from the
link, so we should just ignore them. */
- return TRUE;
+ return true;
}
if (cookie->rel == cookie->relend)
- return FALSE;
+ return false;
/* The first relocation is the function start. */
r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
if (r_symndx == STN_UNDEF)
- return FALSE;
+ return false;
- text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, FALSE);
+ text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, false);
if (text_sec == NULL)
- return FALSE;
+ return false;
elf_section_eh_frame_entry (text_sec) = sec;
if (text_sec->output_section
sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY;
elf_section_data (sec)->sec_info = text_sec;
bfd_elf_record_eh_frame_entry (hdr_info, sec);
- return TRUE;
+ return true;
}
/* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
SKIP_RELOCS (buf - length);
if (!GET_RELOC (buf - length)
- && read_value (abfd, buf - length, length, FALSE) == 0)
+ && read_value (abfd, buf - length, length, false) == 0)
{
(*info->callbacks->minfo)
/* xgettext:c-format */
/* 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);
+ hdr_info->u.dwarf.table = false;
+ free (sec_info);
success:
- if (ehbuf)
- free (ehbuf);
- if (local_cies)
- free (local_cies);
+ free (ehbuf);
+ free (local_cies);
#undef REQUIRE
}
/* Finish a pass over all .eh_frame_entry sections. */
-bfd_boolean
+bool
_bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
{
struct eh_frame_hdr_info *hdr_info;
if (info->eh_frame_hdr_type != COMPACT_EH_HDR
|| hdr_info->array_count == 0)
- return FALSE;
+ return false;
bfd_elf_discard_eh_frame_entry (hdr_info);
/* Add a CANTUNWIND terminator after the last entry. */
add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL);
- return TRUE;
+ return true;
}
/* Mark all relocations against CIE or FDE ENT, which occurs in
.eh_frame section SEC. COOKIE describes the relocations in SEC;
its "rel" field can be changed freely. */
-static bfd_boolean
+static bool
mark_entry (struct bfd_link_info *info, asection *sec,
struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
struct elf_reloc_cookie *cookie)
&& cookie->rel->r_offset < ent->offset + ent->size;
cookie->rel++)
if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
/* Mark all the relocations against FDEs that relate to code in input
section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
relocations are described by COOKIE. */
-bfd_boolean
+bool
_bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
struct elf_reloc_cookie *cookie)
for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
{
if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
- return FALSE;
+ return false;
/* At this stage, all cie_inf fields point to local CIEs, so we
can use the same cookie to refer to them. */
{
cie->u.cie.gc_mark = 1;
if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
/* Input section SEC of ABFD is an .eh_frame section that contains the
if (cie->per_encoding != DW_EH_PE_omit)
{
- bfd_boolean per_binds_local;
+ bool per_binds_local;
/* Work out the address of personality routine, or at least
enough info that we could calculate the address had we made a
cie->local_personality = 1;
cie->personality.sym.bfd_id = abfd->id;
cie->personality.sym.index = r_symndx;
- per_binds_local = TRUE;
+ per_binds_local = true;
}
if (per_binds_local
when a CIE is merged with a previous CIE, since the symbol is
moved to the merged CIE. */
-bfd_boolean
+bool
_bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry *h,
void *arg ATTRIBUTE_UNUSED)
{
if (h->root.type != bfd_link_hash_defined
&& h->root.type != bfd_link_hash_defweak)
- return TRUE;
+ 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;
+ return true;
delta = offset_adjust (h->root.u.def.value, sym_sec);
h->root.u.def.value += delta;
- return TRUE;
+ return true;
}
/* The same for all local symbols defined in .eh_frame. Returns true
functions. The function returns TRUE iff any entries have been
deleted. */
-bfd_boolean
+bool
_bfd_elf_discard_section_eh_frame
(bfd *abfd, struct bfd_link_info *info, asection *sec,
- bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
+ bool (*reloc_symbol_deleted_p) (bfd_vma, void *),
struct elf_reloc_cookie *cookie)
{
struct eh_cie_fde *ent;
int changed;
if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
- return FALSE;
+ return false;
sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
if (sec_info == NULL)
- return FALSE;
+ return false;
ptr_size = (get_elf_backend_data (sec->owner)
->elf_backend_eh_frame_address_size (sec->owner, sec));
ent->removed = sec->map_head.s != NULL;
else if (!ent->cie && ent->u.fde.cie_inf != NULL)
{
- bfd_boolean keep;
+ bool keep;
if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
{
unsigned int width
which we cannot turn into PC relative,
don't create the binary search table,
since it is affected by runtime relocations. */
- hdr_info->u.dwarf.table = FALSE;
+ hdr_info->u.dwarf.table = false;
/* Only warn if --eh-frame-hdr was specified. */
if (info->eh_frame_hdr_type != 0)
{
}
}
- 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
_bfd_elf_discard_section_eh_frame has been called on all .eh_frame
input sections. It finalizes the size of .eh_frame_hdr section. */
-bfd_boolean
+bool
_bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
{
struct elf_link_hash_table *htab;
sec = hdr_info->hdr_sec;
if (sec == NULL)
- return FALSE;
+ return false;
if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
{
}
elf_eh_frame_hdr (abfd) = sec;
- return TRUE;
+ return true;
}
/* Return true if there is at least one non-empty .eh_frame section in
input files. Can only be called after ld has mapped input to
output sections, and before sections are stripped. */
-bfd_boolean
+bool
_bfd_elf_eh_frame_present (struct bfd_link_info *info)
{
asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
if (eh == NULL)
- return FALSE;
+ return false;
/* Count only sections which have at least a single CIE or FDE.
There cannot be any CIE or FDE <= 8 bytes. */
for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
if (eh->size > 8)
- return TRUE;
+ return true;
- return FALSE;
+ return false;
}
/* Return true if there is at least one .eh_frame_entry section in
input files. */
-bfd_boolean
+bool
_bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
{
asection *o;
if (strcmp (name, ".eh_frame_entry")
&& !bfd_is_abs_section (o->output_section))
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
/* This function is called from size_dynamic_sections.
because when the dynamic symbol table has been sized it is too late
to strip sections. */
-bfd_boolean
+bool
_bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
{
struct elf_link_hash_table *htab;
htab = elf_hash_table (info);
hdr_info = &htab->eh_info;
if (hdr_info->hdr_sec == NULL)
- return TRUE;
+ return true;
if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
|| info->eh_frame_hdr_type == 0
{
hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
hdr_info->hdr_sec = NULL;
- return TRUE;
+ return true;
}
/* Add a hidden symbol so that systems without access to PHDRs can
find the table. */
if (! (_bfd_generic_link_add_one_symbol
(info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
- hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
- return FALSE;
+ hdr_info->hdr_sec, 0, NULL, false, false, &bh)))
+ return false;
h = (struct elf_link_hash_entry *) bh;
h->def_regular = 1;
h->other = STV_HIDDEN;
get_elf_backend_data
- (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
+ (info->output_bfd)->elf_backend_hide_symbol (info, h, true);
if (!hdr_info->frame_hdr_is_compact)
- hdr_info->u.dwarf.table = TRUE;
- return TRUE;
+ hdr_info->u.dwarf.table = true;
+ return true;
}
/* Adjust an address in the .eh_frame section. Given OFFSET within
/* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed.
Also check that the contents look sane. */
-bfd_boolean
+bool
_bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
asection *sec, bfd_byte *contents)
{
excluded outside of the normal process. */
if (sec->flags & SEC_EXCLUDE
|| text_sec->flags & SEC_EXCLUDE)
- return TRUE;
+ return true;
if (!bfd_set_section_contents (abfd, sec->output_section, contents,
sec->output_offset, sec->rawsize))
- return FALSE;
+ return false;
last_addr = bfd_get_signed_32 (abfd, contents);
/* Check that all the entries are in order. */
{
/* xgettext:c-format */
_bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec);
- return FALSE;
+ return false;
}
last_addr = addr;
_bfd_error_handler (_("%pB: %pA invalid input section size"),
sec->owner, sec);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
if (last_addr >= addr + sec->rawsize)
{
_bfd_error_handler (_("%pB: %pA points past end of text section"),
sec->owner, sec);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
if (sec->size == sec->rawsize)
- return TRUE;
+ return true;
bed = get_elf_backend_data (abfd);
BFD_ASSERT (sec->size == sec->rawsize + 8);
/* Write out .eh_frame section. This is called with the relocated
contents. */
-bfd_boolean
+bool
_bfd_elf_write_section_eh_frame (bfd *abfd,
struct bfd_link_info *info,
asection *sec,
if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
{
- hdr_info->frame_hdr_is_compact = FALSE;
+ 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
* sizeof (*hdr_info->u.dwarf.array));
hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
= address;
hdr_info->u.dwarf.array[hdr_info->array_count].range
- = read_value (abfd, buf + width, width, FALSE);
+ = read_value (abfd, buf + width, width, false);
hdr_info->u.dwarf.array[hdr_info->array_count++].fde
= (sec->output_section->vma
+ sec->output_offset
invalid for a linker script to try to force a particular order of
.eh_frame_entry sections. */
-bfd_boolean
+bool
_bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
{
asection *sec = NULL;
if (hdr_info->hdr_sec == NULL
|| info->eh_frame_hdr_type != COMPACT_EH_HDR
|| hdr_info->array_count == 0)
- return TRUE;
+ return true;
/* Change section output offsets to be in text section order. */
offset = 8;
_bfd_error_handler
(_("invalid output section for .eh_frame_entry: %pA"),
sec->output_section);
- return FALSE;
+ return false;
}
sec->output_offset = offset;
offset += sec->size;
{
_bfd_error_handler
(_("invalid contents in %pA section"), osec);
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* The .eh_frame_hdr format for Compact EH frames:
uint32_t count (Number of entries in table)
[array from .eh_frame_entry sections] */
-static bfd_boolean
+static bool
write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
{
struct elf_link_hash_table *htab;
FDE initial_location field and FDE address,
sorted by increasing initial_loc). */
-static bfd_boolean
+static bool
write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
{
struct elf_link_hash_table *htab;
struct eh_frame_hdr_info *hdr_info;
asection *sec;
- bfd_boolean retval = TRUE;
+ bool retval = true;
htab = elf_hash_table (info);
hdr_info = &htab->eh_info;
size += 4 + hdr_info->u.dwarf.fde_count * 8;
contents = (bfd_byte *) bfd_malloc (size);
if (contents == NULL)
- return FALSE;
+ return false;
eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
if (eh_frame_sec == NULL)
{
free (contents);
- return FALSE;
+ return false;
}
memset (contents, 0, EH_FRAME_HDR_SIZE);
if (contents[2] != DW_EH_PE_omit)
{
unsigned int i;
- bfd_boolean overlap, overflow;
+ bool overlap, overflow;
bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
contents + EH_FRAME_HDR_SIZE);
qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
sizeof (*hdr_info->u.dwarf.array), vma_compare);
- overlap = FALSE;
- overflow = FALSE;
+ overlap = false;
+ overflow = false;
for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
{
bfd_vma val;
if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
&& (hdr_info->u.dwarf.array[i].initial_loc
!= sec->output_section->vma + val))
- overflow = TRUE;
+ overflow = true;
bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
&& (hdr_info->u.dwarf.array[i].fde
!= sec->output_section->vma + val))
- overflow = TRUE;
+ overflow = true;
bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
if (i != 0
&& (hdr_info->u.dwarf.array[i].initial_loc
< (hdr_info->u.dwarf.array[i - 1].initial_loc
+ hdr_info->u.dwarf.array[i - 1].range)))
- overlap = TRUE;
+ overlap = true;
}
if (overflow)
_bfd_error_handler (_(".eh_frame_hdr entry overflow"));
if (overflow || overlap)
{
bfd_set_error (bfd_error_bad_value);
- retval = FALSE;
+ retval = false;
}
}
if (!bfd_set_section_contents (abfd, sec->output_section, contents,
(file_ptr) sec->output_offset,
sec->size))
- retval = FALSE;
+ 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;
}
_bfd_elf_write_section_eh_frame has been called on all input
.eh_frame sections. */
-bfd_boolean
+bool
_bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
{
struct elf_link_hash_table *htab;
sec = hdr_info->hdr_sec;
if (info->eh_frame_hdr_type == 0 || sec == NULL)
- return TRUE;
+ return true;
if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
return write_compact_eh_frame_hdr (abfd, info);
/* Decide whether we can use a PC-relative encoding within the given
EH frame section. This is the default implementation. */
-bfd_boolean
+bool
_bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info ATTRIBUTE_UNUSED,
asection *eh_frame_section ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
/* Select an encoding for the given address. Preference is given to
projects / deliverable / binutils-gdb.git / blobdiff