/* Renesas / SuperH SH specific support for 32-bit ELF
- Copyright (C) 1996-2021 Free Software Foundation, Inc.
+ Copyright (C) 1996-2022 Free Software Foundation, Inc.
Contributed by Ian Lance Taylor, Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
(bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
static bfd_reloc_status_type sh_elf_ignore_reloc
(bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
-static bfd_boolean sh_elf_relax_delete_bytes
+static bool sh_elf_relax_delete_bytes
(bfd *, asection *, bfd_vma, int);
-static bfd_boolean sh_elf_align_loads
- (bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_boolean *);
-static bfd_boolean sh_elf_swap_insns
+static bool sh_elf_align_loads
+ (bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bool *);
+static bool sh_elf_swap_insns
(bfd *, asection *, void *, bfd_byte *, bfd_vma);
static int sh_elf_optimized_tls_reloc
(struct bfd_link_info *, int, int);
(SYMBOL_REFERENCES_LOCAL (INFO, H) \
|| ! elf_hash_table (INFO)->dynamic_sections_created)
\f
-#define SH_PARTIAL32 TRUE
+#define SH_PARTIAL32 true
#define SH_SRC_MASK32 0xffffffff
#define SH_ELF_RELOC sh_elf_reloc
static reloc_howto_type sh_elf_howto_table[] =
#include "elf32-sh-relocs.h"
};
-#define SH_PARTIAL32 FALSE
+#define SH_PARTIAL32 false
#define SH_SRC_MASK32 0
#define SH_ELF_RELOC bfd_elf_generic_reloc
static reloc_howto_type sh_vxworks_howto_table[] =
\f
/* Return true if OUTPUT_BFD is a VxWorks object. */
-static bfd_boolean
+static bool
vxworks_object_p (bfd *abfd ATTRIBUTE_UNUSED)
{
#if !defined SH_TARGET_ALREADY_DEFINED
return (abfd->xvec == &sh_elf32_vxworks_le_vec
|| abfd->xvec == &sh_elf32_vxworks_vec);
#else
- return FALSE;
+ return false;
#endif
}
/* Return true if OUTPUT_BFD is an FDPIC object. */
-static bfd_boolean
+static bool
fdpic_object_p (bfd *abfd ATTRIBUTE_UNUSED)
{
#if !defined SH_TARGET_ALREADY_DEFINED
return (abfd->xvec == &sh_elf32_fdpic_le_vec
|| abfd->xvec == &sh_elf32_fdpic_be_vec);
#else
- return FALSE;
+ return false;
#endif
}
/* Given an ELF reloc, fill in the howto field of a relent. */
-static bfd_boolean
+static bool
sh_elf_info_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
{
unsigned int r;
r = ELF32_R_TYPE (dst->r_info);
- if (r >= R_SH_max
+ if (r >= R_SH_FIRST_INVALID_RELOC_6
|| (r >= R_SH_FIRST_INVALID_RELOC && r <= R_SH_LAST_INVALID_RELOC)
|| (r >= R_SH_FIRST_INVALID_RELOC_2 && r <= R_SH_LAST_INVALID_RELOC_2)
|| (r >= R_SH_FIRST_INVALID_RELOC_3 && r <= R_SH_LAST_INVALID_RELOC_3)
|| (r >= R_SH_FIRST_INVALID_RELOC_4 && r <= R_SH_LAST_INVALID_RELOC_4)
- || (r >= R_SH_FIRST_INVALID_RELOC_5 && r <= R_SH_LAST_INVALID_RELOC_5)
- || (r >= R_SH_FIRST_INVALID_RELOC_6 && r <= R_SH_LAST_INVALID_RELOC_6))
+ || (r >= R_SH_FIRST_INVALID_RELOC_5 && r <= R_SH_LAST_INVALID_RELOC_5))
{
/* xgettext:c-format */
_bfd_error_handler (_("%pB: unsupported relocation type %#x"),
abfd, r);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
cache_ptr->howto = get_howto_table (abfd) + r;
- return TRUE;
+ return true;
}
\f
/* This function handles relaxing for SH ELF. See the corresponding
values; in coff-sh.c they come from include/coff/sh.h, whereas here
they come from enum elf_sh_reloc_type in include/elf/sh.h. */
-static bfd_boolean
+static bool
sh_elf_relax_section (bfd *abfd, asection *sec,
- struct bfd_link_info *link_info, bfd_boolean *again)
+ struct bfd_link_info *link_info, bool *again)
{
Elf_Internal_Shdr *symtab_hdr;
Elf_Internal_Rela *internal_relocs;
- bfd_boolean have_code;
+ bool have_code;
Elf_Internal_Rela *irel, *irelend;
bfd_byte *contents = NULL;
Elf_Internal_Sym *isymbuf = NULL;
- *again = FALSE;
+ *again = false;
if (bfd_link_relocatable (link_info)
|| (sec->flags & SEC_RELOC) == 0
|| sec->reloc_count == 0)
- return TRUE;
+ return true;
symtab_hdr = &elf_symtab_hdr (abfd);
if (internal_relocs == NULL)
goto error_return;
- have_code = FALSE;
+ have_code = false;
irelend = internal_relocs + sec->reloc_count;
for (irel = internal_relocs; irel < irelend; irel++)
bfd_signed_vma foff;
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
- have_code = TRUE;
+ have_code = true;
if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
continue;
/* That will change things, so, just in case it permits some
other function call to come within range, we should relax
again. Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
/* Now check whether we got a COUNT reloc. */
if (irelcount >= irelend)
if ((elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK) != EF_SH4
&& have_code)
{
- bfd_boolean swapped;
+ bool swapped;
/* Get the section contents. */
if (contents == NULL)
if (elf_section_data (sec)->relocs != internal_relocs)
free (internal_relocs);
- return TRUE;
+ return true;
error_return:
if (symtab_hdr->contents != (unsigned char *) isymbuf)
if (elf_section_data (sec)->relocs != internal_relocs)
free (internal_relocs);
- return FALSE;
+ return false;
}
/* Delete some bytes from a section while relaxing. FIXME: There is a
lot of duplication between this function and sh_relax_delete_bytes
in coff-sh.c. */
-static bfd_boolean
+static bool
sh_elf_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr,
int count)
{
int insn = 0;
int off, adjust, oinsn;
bfd_signed_vma voff = 0;
- bfd_boolean overflow;
+ bool overflow;
/* Get the new reloc address. */
nraddr = irel->r_offset;
if (adjust != 0)
{
oinsn = insn;
- overflow = FALSE;
+ overflow = false;
switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
{
default:
case R_SH_DIR8WPZ:
insn += adjust / 2;
if ((oinsn & 0xff00) != (insn & 0xff00))
- overflow = TRUE;
+ overflow = true;
bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
break;
case R_SH_IND12W:
insn += adjust / 2;
if ((oinsn & 0xf000) != (insn & 0xf000))
- overflow = TRUE;
+ overflow = true;
bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
break;
++insn;
}
if ((oinsn & 0xff00) != (insn & 0xff00))
- overflow = TRUE;
+ overflow = true;
bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
break;
case R_SH_SWITCH8:
voff += adjust;
if (voff < 0 || voff >= 0xff)
- overflow = TRUE;
+ overflow = true;
bfd_put_8 (abfd, voff, contents + nraddr);
break;
case R_SH_SWITCH16:
voff += adjust;
if (voff < - 0x8000 || voff >= 0x8000)
- overflow = TRUE;
+ overflow = true;
bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
break;
(_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"),
abfd, (uint64_t) irel->r_offset);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
FALSE, we should free them, if we are permitted to, when we
leave sh_coff_relax_section. */
internal_relocs = (_bfd_elf_link_read_relocs
- (abfd, o, NULL, (Elf_Internal_Rela *) NULL, TRUE));
+ (abfd, o, NULL, (Elf_Internal_Rela *) NULL, true));
if (internal_relocs == NULL)
- return FALSE;
+ return false;
ocontents = NULL;
irelscanend = internal_relocs + o->reloc_count;
if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
{
free (ocontents);
- return FALSE;
+ return false;
}
elf_section_data (o)->this_hdr.contents = ocontents;
if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
{
free (ocontents);
- return FALSE;
+ return false;
}
elf_section_data (o)->this_hdr.contents = ocontents;
}
}
- return TRUE;
+ return true;
}
/* Look for loads and stores which we can align to four byte
boundaries. This is like sh_align_loads in coff-sh.c. */
-static bfd_boolean
+static bool
sh_elf_align_loads (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
Elf_Internal_Rela *internal_relocs,
bfd_byte *contents ATTRIBUTE_UNUSED,
- bfd_boolean *pswapped)
+ bool *pswapped)
{
Elf_Internal_Rela *irel, *irelend;
bfd_vma *labels = NULL;
bfd_vma *label, *label_end;
bfd_size_type amt;
- *pswapped = FALSE;
+ *pswapped = false;
irelend = internal_relocs + sec->reloc_count;
free (labels);
- return TRUE;
+ return true;
error_return:
free (labels);
- return FALSE;
+ return false;
}
/* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
-static bfd_boolean
+static bool
sh_elf_swap_insns (bfd *abfd, asection *sec, void *relocs,
bfd_byte *contents, bfd_vma addr)
{
{
bfd_byte *loc;
unsigned short insn, oinsn;
- bfd_boolean overflow;
+ bool overflow;
loc = contents + irel->r_offset;
- overflow = FALSE;
+ overflow = false;
switch (type)
{
default:
oinsn = insn;
insn += add / 2;
if ((oinsn & 0xff00) != (insn & 0xff00))
- overflow = TRUE;
+ overflow = true;
bfd_put_16 (abfd, (bfd_vma) insn, loc);
break;
oinsn = insn;
insn += add / 2;
if ((oinsn & 0xf000) != (insn & 0xf000))
- overflow = TRUE;
+ overflow = true;
bfd_put_16 (abfd, (bfd_vma) insn, loc);
break;
oinsn = insn;
insn += add / 2;
if ((oinsn & 0xff00) != (insn & 0xff00))
- overflow = TRUE;
+ overflow = true;
bfd_put_16 (abfd, (bfd_vma) insn, loc);
}
(_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"),
abfd, (uint64_t) irel->r_offset);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
}
- return TRUE;
+ return true;
}
\f
/* Describes one of the various PLT styles. */
bfd_vma got_entry; /* the address of the symbol's .got.plt entry */
bfd_vma plt; /* .plt (or a branch to .plt on VxWorks) */
bfd_vma reloc_offset; /* the offset of the symbol's JMP_SLOT reloc */
- bfd_boolean got20; /* TRUE if got_entry points to a movi20
- instruction (instead of a constant pool
- entry). */
+ bool got20; /* TRUE if got_entry points to a movi20 instruction
+ (instead of a constant pool entry). */
} symbol_fields;
/* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
{ MINUS_ONE, 24, 20 },
elf_sh_plt_entry_be,
ELF_PLT_ENTRY_SIZE,
- { 20, 16, 24, FALSE },
+ { 20, 16, 24, false },
8,
NULL
},
{ MINUS_ONE, 24, 20 },
elf_sh_plt_entry_le,
ELF_PLT_ENTRY_SIZE,
- { 20, 16, 24, FALSE },
+ { 20, 16, 24, false },
8,
NULL
},
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
elf_sh_pic_plt_entry_be,
ELF_PLT_ENTRY_SIZE,
- { 20, MINUS_ONE, 24, FALSE },
+ { 20, MINUS_ONE, 24, false },
8,
NULL
},
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
elf_sh_pic_plt_entry_le,
ELF_PLT_ENTRY_SIZE,
- { 20, MINUS_ONE, 24, FALSE },
+ { 20, MINUS_ONE, 24, false },
8,
NULL
},
{ MINUS_ONE, MINUS_ONE, 8 },
vxworks_sh_plt_entry_be,
VXWORKS_PLT_ENTRY_SIZE,
- { 8, 14, 20, FALSE },
+ { 8, 14, 20, false },
12,
NULL
},
{ MINUS_ONE, MINUS_ONE, 8 },
vxworks_sh_plt_entry_le,
VXWORKS_PLT_ENTRY_SIZE,
- { 8, 14, 20, FALSE },
+ { 8, 14, 20, false },
12,
NULL
},
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
vxworks_sh_pic_plt_entry_be,
VXWORKS_PLT_ENTRY_SIZE,
- { 8, MINUS_ONE, 20, FALSE },
+ { 8, MINUS_ONE, 20, false },
12,
NULL
},
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
vxworks_sh_pic_plt_entry_le,
VXWORKS_PLT_ENTRY_SIZE,
- { 8, MINUS_ONE, 20, FALSE },
+ { 8, MINUS_ONE, 20, false },
12,
NULL
},
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
fdpic_sh_plt_entry_be,
FDPIC_PLT_ENTRY_SIZE,
- { 12, MINUS_ONE, 16, FALSE },
+ { 12, MINUS_ONE, 16, false },
FDPIC_PLT_LAZY_OFFSET,
NULL
},
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
fdpic_sh_plt_entry_le,
FDPIC_PLT_ENTRY_SIZE,
- { 12, MINUS_ONE, 16, FALSE },
+ { 12, MINUS_ONE, 16, false },
FDPIC_PLT_LAZY_OFFSET,
NULL
},
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
fdpic_sh2a_plt_entry_be,
FDPIC_SH2A_PLT_ENTRY_SIZE,
- { 0, MINUS_ONE, 12, TRUE },
+ { 0, MINUS_ONE, 12, true },
FDPIC_SH2A_PLT_LAZY_OFFSET,
NULL
};
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
fdpic_sh2a_plt_entry_le,
FDPIC_SH2A_PLT_ENTRY_SIZE,
- { 0, MINUS_ONE, 12, TRUE },
+ { 0, MINUS_ONE, 12, true },
FDPIC_SH2A_PLT_LAZY_OFFSET,
NULL
};
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
fdpic_sh_plt_entry_be,
FDPIC_PLT_ENTRY_SIZE,
- { 12, MINUS_ONE, 16, FALSE },
+ { 12, MINUS_ONE, 16, false },
FDPIC_PLT_LAZY_OFFSET,
&fdpic_sh2a_short_plt_be
},
{ MINUS_ONE, MINUS_ONE, MINUS_ONE },
fdpic_sh_plt_entry_le,
FDPIC_PLT_ENTRY_SIZE,
- { 12, MINUS_ONE, 16, FALSE },
+ { 12, MINUS_ONE, 16, false },
FDPIC_PLT_LAZY_OFFSET,
&fdpic_sh2a_short_plt_le
},
the object is position-independent. */
static const struct elf_sh_plt_info *
-get_plt_info (bfd *abfd, bfd_boolean pic_p)
+get_plt_info (bfd *abfd, bool pic_p)
{
if (fdpic_object_p (abfd))
{
not data. */
inline static void
-install_plt_field (bfd *output_bfd, bfd_boolean code_p ATTRIBUTE_UNUSED,
+install_plt_field (bfd *output_bfd, bool code_p ATTRIBUTE_UNUSED,
unsigned long value, bfd_byte *addr)
{
bfd_put_32 (output_bfd, value, addr);
/* Override the generic function because we need to store sh_elf_obj_tdata
as the specific tdata. */
-static bfd_boolean
+static bool
sh_elf_mkobject (bfd *abfd)
{
return bfd_elf_allocate_object (abfd, sizeof (struct sh_elf_obj_tdata),
const struct elf_sh_plt_info *plt_info;
/* True if the target system uses FDPIC. */
- bfd_boolean fdpic_p;
+ bool fdpic_p;
};
/* Traverse an sh ELF linker hash table. */
#define sh_elf_link_hash_traverse(table, func, info) \
(elf_link_hash_traverse \
(&(table)->root, \
- (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
+ (bool (*) (struct elf_link_hash_entry *, void *)) (func), \
(info)))
/* Get the sh ELF linker hash table from a link_info structure. */
if (fdpic_object_p (abfd))
{
- ret->root.dt_pltgot_required = TRUE;
- ret->fdpic_p = TRUE;
+ ret->root.dt_pltgot_required = true;
+ ret->fdpic_p = true;
}
return &ret->root.root;
}
-static bfd_boolean
+static bool
sh_elf_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info, asection *p)
{
/* Non-FDPIC binaries do not need dynamic symbols for sections. */
if (!htab->fdpic_p)
- return TRUE;
+ return true;
/* We need dynamic symbols for every section, since segments can
relocate independently. */
/* If sh_type is yet undecided, assume it could be
SHT_PROGBITS/SHT_NOBITS. */
case SHT_NULL:
- return FALSE;
+ return false;
/* There shouldn't be section relative relocations
against any other section. */
default:
- return TRUE;
+ return true;
}
}
/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
shortcuts to them in our hash table. */
-static bfd_boolean
+static bool
create_got_section (bfd *dynobj, struct bfd_link_info *info)
{
struct elf_sh_link_hash_table *htab;
if (! _bfd_elf_create_got_section (dynobj, info))
- return FALSE;
+ return false;
htab = sh_elf_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
htab->sfuncdesc = bfd_make_section_anyway_with_flags (dynobj, ".got.funcdesc",
(SEC_ALLOC | SEC_LOAD
| SEC_LINKER_CREATED));
if (htab->sfuncdesc == NULL
|| !bfd_set_section_alignment (htab->sfuncdesc, 2))
- return FALSE;
+ return false;
htab->srelfuncdesc = bfd_make_section_anyway_with_flags (dynobj,
".rela.got.funcdesc",
| SEC_READONLY));
if (htab->srelfuncdesc == NULL
|| !bfd_set_section_alignment (htab->srelfuncdesc, 2))
- return FALSE;
+ return false;
/* Also create .rofixup. */
htab->srofixup = bfd_make_section_anyway_with_flags (dynobj, ".rofixup",
| SEC_READONLY));
if (htab->srofixup == NULL
|| !bfd_set_section_alignment (htab->srofixup, 2))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
/* Create dynamic sections when linking against a dynamic object. */
-static bfd_boolean
+static bool
sh_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
{
struct elf_sh_link_hash_table *htab;
default:
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
htab = sh_elf_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
if (htab->root.dynamic_sections_created)
- return TRUE;
+ return true;
/* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
.rel[a].bss sections. */
htab->root.splt = s;
if (s == NULL
|| !bfd_set_section_alignment (s, bed->plt_alignment))
- return FALSE;
+ return false;
if (bed->want_plt_sym)
{
if (! (_bfd_generic_link_add_one_symbol
(info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
- (bfd_vma) 0, (const char *) NULL, FALSE,
+ (bfd_vma) 0, (const char *) NULL, false,
get_elf_backend_data (abfd)->collect, &bh)))
- return FALSE;
+ return false;
h = (struct elf_link_hash_entry *) bh;
h->def_regular = 1;
if (bfd_link_pic (info)
&& ! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
+ return false;
}
s = bfd_make_section_anyway_with_flags (abfd,
htab->root.srelplt = s;
if (s == NULL
|| !bfd_set_section_alignment (s, ptralign))
- return FALSE;
+ return false;
if (htab->root.sgot == NULL
&& !create_got_section (abfd, info))
- return FALSE;
+ return false;
if (bed->want_dynbss)
{
SEC_ALLOC | SEC_LINKER_CREATED);
htab->root.sdynbss = s;
if (s == NULL)
- return FALSE;
+ return false;
/* The .rel[a].bss section holds copy relocs. This section is not
normally needed. We need to create it here, though, so that the
htab->root.srelbss = s;
if (s == NULL
|| !bfd_set_section_alignment (s, ptralign))
- return FALSE;
+ return false;
}
}
if (htab->root.target_os == is_vxworks)
{
if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
\f
/* Adjust a symbol defined by a dynamic object and referenced by a
change the definition to something the rest of the link can
understand. */
-static bfd_boolean
+static bool
sh_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
struct elf_link_hash_entry *h)
{
htab = sh_elf_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
/* Make sure we know what is going on here. */
BFD_ASSERT (htab->root.dynobj != NULL
h->needs_plt = 0;
}
- return TRUE;
+ return true;
}
else
h->plt.offset = (bfd_vma) -1;
h->root.u.def.value = def->root.u.def.value;
if (info->nocopyreloc)
h->non_got_ref = def->non_got_ref;
- return TRUE;
+ return true;
}
/* This is a reference to a symbol defined by a dynamic object which
For such cases we need not do anything here; the relocations will
be handled correctly by relocate_section. */
if (bfd_link_pic (info))
- return TRUE;
+ return true;
/* If there are no references to this symbol that do not use the
GOT, we don't need to generate a copy reloc. */
if (!h->non_got_ref)
- return TRUE;
+ return true;
/* If -z nocopyreloc was given, we won't generate them either. */
if (0 && info->nocopyreloc)
{
h->non_got_ref = 0;
- return TRUE;
+ return true;
}
/* If we don't find any dynamic relocs in read-only sections, then
if (0 && !_bfd_elf_readonly_dynrelocs (h))
{
h->non_got_ref = 0;
- return TRUE;
+ return true;
}
/* We must allocate the symbol in our .dynbss section, which will
/* Allocate space in .plt, .got and associated reloc sections for
dynamic relocs. */
-static bfd_boolean
+static bool
allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
{
struct bfd_link_info *info;
struct elf_dyn_relocs *p;
if (h->root.type == bfd_link_hash_indirect)
- return TRUE;
+ return true;
info = (struct bfd_link_info *) inf;
htab = sh_elf_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
eh = (struct elf_sh_link_hash_entry *) h;
if ((h->got.refcount > 0
&& !h->forced_local)
{
if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
+ return false;
}
if (bfd_link_pic (info)
if (h->got.refcount > 0)
{
asection *s;
- bfd_boolean dyn;
+ bool dyn;
enum got_type got_type = sh_elf_hash_entry (h)->got_type;
/* Make sure this symbol is output as a dynamic symbol.
&& !h->forced_local)
{
if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
+ return false;
}
s = htab->root.sgot;
}
if (h->dyn_relocs == NULL)
- return TRUE;
+ return true;
/* In the shared -Bsymbolic case, discard space allocated for
dynamic pc-relative relocs against symbols which turn out to be
&& !h->forced_local)
{
if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
+ return false;
}
}
}
&& !h->forced_local)
{
if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
+ return false;
}
/* If that succeeded, we know we'll be keeping all the
htab->srofixup->size -= 4 * (p->count - p->pc_count);
}
- 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.
It's a convenient place to determine the PLT style. */
-static bfd_boolean
+static bool
sh_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
{
sh_elf_hash_table (info)->plt_info = get_plt_info (output_bfd,
if (sh_elf_hash_table (info)->fdpic_p && !bfd_link_relocatable (info)
&& !bfd_elf_stack_segment_size (output_bfd, info,
"__stacksize", DEFAULT_STACK_SIZE))
- return FALSE;
- return TRUE;
+ return false;
+ return true;
}
/* Set the sizes of the dynamic sections. */
-static bfd_boolean
+static bool
sh_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info)
{
struct elf_sh_link_hash_table *htab;
bfd *dynobj;
asection *s;
- bfd_boolean relocs;
+ bool relocs;
bfd *ibfd;
htab = sh_elf_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
dynobj = htab->root.dynobj;
BFD_ASSERT (dynobj != NULL);
local_funcdesc = (union gotref *) bfd_zalloc (ibfd,
size);
if (local_funcdesc == NULL)
- return FALSE;
+ return false;
sh_elf_local_funcdesc (ibfd) = local_funcdesc;
local_funcdesc += (local_got
- elf_local_got_refcounts (ibfd));
/* We now have determined the sizes of the various dynamic sections.
Allocate memory for them. */
- relocs = FALSE;
+ relocs = false;
for (s = dynobj->sections; s != NULL; s = s->next)
{
if ((s->flags & SEC_LINKER_CREATED) == 0)
else if (startswith (bfd_section_name (s), ".rela"))
{
if (s->size != 0 && s != htab->root.srelplt && s != htab->srelplt2)
- relocs = TRUE;
+ relocs = true;
/* We use the reloc_count field as a counter if we need
to copy relocs into the output file. */
of garbage. */
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
if (s->contents == NULL)
- return FALSE;
+ return false;
}
return _bfd_elf_maybe_vxworks_add_dynamic_tags (output_bfd, info,
return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
}
-static bfd_boolean
+static bool
sh_elf_osec_readonly_p (bfd *output_bfd, asection *osec)
{
unsigned seg = sh_elf_osec_to_segment (output_bfd, osec);
/* Generate the initial contents of a local function descriptor, along
with any relocations or fixups required. */
-static bfd_boolean
+static bool
sh_elf_initialize_funcdesc (bfd *output_bfd,
struct bfd_link_info *info,
struct elf_link_hash_entry *h,
bfd_put_32 (output_bfd, addr, htab->sfuncdesc->contents + offset);
bfd_put_32 (output_bfd, seg, htab->sfuncdesc->contents + offset + 4);
- return TRUE;
+ return true;
}
/* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
asection *splt = NULL;
asection *sreloc = NULL;
asection *srelgot = NULL;
- bfd_boolean is_vxworks_tls;
+ bool is_vxworks_tls;
unsigned isec_segment, got_segment, plt_segment, check_segment[2];
- bfd_boolean fdpic_p = FALSE;
+ bool fdpic_p = false;
if (!is_sh_elf (input_bfd))
{
bfd_set_error (bfd_error_wrong_format);
- return FALSE;
+ return false;
}
htab = sh_elf_hash_table (info);
bfd_vma off;
enum got_type got_type;
const char *symname = NULL;
- bfd_boolean resolved_to_zero;
+ bool resolved_to_zero;
r_symndx = ELF32_R_SYM (rel->r_info);
&& r_type <= (int) R_SH_LAST_INVALID_RELOC_6))
{
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
howto = get_howto_table (output_bfd) + r_type;
if (! howto->partial_inplace)
addend = rel->r_addend;
- resolved_to_zero = FALSE;
+ resolved_to_zero = false;
h = NULL;
sym = NULL;
sec = NULL;
"%s relocation against SEC_MERGE section"),
input_bfd, input_section,
(uint64_t) rel->r_offset, howto->name);
- return FALSE;
+ return false;
}
addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
if (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
{
- bfd_boolean dyn;
+ bool dyn;
- dyn = htab ? htab->root.dynamic_sections_created : FALSE;
+ dyn = htab ? htab->root.dynamic_sections_created : false;
sec = h->root.u.def.section;
/* In these cases, we don't need the relocation value.
We check specially because in some obscure cases
(uint64_t) rel->r_offset,
howto->name,
h->root.root.string);
- return FALSE;
+ return false;
}
}
else if (h->root.type == bfd_link_hash_undefweak)
input_section->owner,
(uint64_t) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
relocation -= 4;
goto final_link_relocate;
default:
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
case R_SH_DIR16:
case R_SH_DIR8:
input_section->owner, (uint64_t) rel->r_offset,
howto->name, (uint64_t) relocation);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
goto final_link_relocate;
(uint64_t) rel->r_offset, howto->name,
(uint64_t) relocation);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
goto final_link_relocate;
(uint64_t) rel->r_offset,
(int64_t) relocation);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
goto final_link_relocate;
(uint64_t) rel->r_offset,
(int64_t) relocation);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
goto final_link_relocate;
{
Elf_Internal_Rela outrel;
bfd_byte *loc;
- bfd_boolean skip, relocate;
+ bool skip, relocate;
/* When generating a shared object, these relocations
are copied into the output file to be resolved at run
if (sreloc == NULL)
{
sreloc = _bfd_elf_get_dynamic_reloc_section
- (input_bfd, input_section, /*rela?*/ TRUE);
+ (input_bfd, input_section, /*rela?*/ true);
if (sreloc == NULL)
- return FALSE;
+ return false;
}
- skip = FALSE;
- relocate = FALSE;
+ skip = false;
+ relocate = false;
outrel.r_offset =
_bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset);
if (outrel.r_offset == (bfd_vma) -1)
- skip = TRUE;
+ skip = true;
else if (outrel.r_offset == (bfd_vma) -2)
- skip = TRUE, relocate = TRUE;
+ skip = true, relocate = true;
outrel.r_offset += (input_section->output_section->vma
+ input_section->output_offset);
input_section,
(uint64_t) rel->r_offset,
symname);
- return FALSE;
+ return false;
}
offset = _bfd_elf_section_offset (output_bfd, info,
if (h != NULL)
{
- bfd_boolean dyn;
+ bool dyn;
off = h->got.offset;
BFD_ASSERT (off != (bfd_vma) -1);
{
if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
offset, NULL, 0))
- return FALSE;
+ return false;
sh_elf_hash_entry (h)->funcdesc.offset |= 1;
}
}
if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
offset, sec,
sym->st_value))
- return FALSE;
+ return false;
local_funcdesc[r_symndx].offset |= 1;
}
}
input_section,
(uint64_t) rel->r_offset,
symname);
- return FALSE;
+ return false;
}
offset = _bfd_elf_section_offset (output_bfd, info,
(info,
_("cannot emit dynamic relocations in read-only section"),
symname, input_bfd, reloc_section, reloc_offset);
- return FALSE;
+ return false;
}
offset = _bfd_elf_section_offset (output_bfd, info,
"%s relocation against external symbol \"%s\""),
input_bfd, input_section, (uint64_t) rel->r_offset,
howto->name, h->root.root.string);
- return FALSE;
+ return false;
}
else
{
{
if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
offset, NULL, 0))
- return FALSE;
+ return false;
sh_elf_hash_entry (h)->funcdesc.offset |= 1;
}
}
if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
offset, sec,
sym->st_value))
- return FALSE;
+ return false;
local_funcdesc[r_symndx].offset |= 1;
}
}
/* xgettext:c-format */
(_("%pB(%pA): offset in relocation for GD->LE translation is too small: %#" PRIx64),
input_bfd, input_section, (uint64_t) offset);
- return FALSE;
+ return false;
}
/* Size of GD instructions is 16 or 18. */
/* xgettext:c-format */
(_("%pB(%pA): offset in relocation for IE->LE translation is too small: %#" PRIx64),
input_bfd, input_section, (uint64_t) offset);
- return FALSE;
+ return false;
}
/* Size of IE instructions is 10 or 12. */
/* xgettext:c-format */
(_("%pB(%pA): offset in relocation for GD->IE translation is too small: %#" PRIx64),
input_bfd, input_section, (uint64_t) offset);
- return FALSE;
+ return false;
}
/* Size of GD instructions is 16 or 18. */
/* xgettext:c-format */
(_("%pB(%pA): offset in relocation for LD->LE translation is too small: %#" PRIx64),
input_bfd, input_section, (uint64_t) offset);
- return FALSE;
+ return false;
}
/* Size of LD instructions is 16 or 18. */
if (sreloc == NULL)
{
sreloc = _bfd_elf_get_dynamic_reloc_section
- (input_bfd, input_section, /*rela?*/ TRUE);
+ (input_bfd, input_section, /*rela?*/ true);
if (sreloc == NULL)
- return FALSE;
+ return false;
}
if (h == NULL || h->dynindx == -1)
/* xgettext:c-format */
(_("%X%C: relocation to \"%s\" references a different segment\n"),
input_bfd, input_section, rel->r_offset, symname);
- return FALSE;
+ return false;
}
else
info->callbacks->einfo
name = (bfd_elf_string_from_elf_section
(input_bfd, symtab_hdr->sh_link, sym->st_name));
if (name == NULL)
- return FALSE;
+ return false;
if (*name == '\0')
name = bfd_section_name (sec);
}
}
}
- return TRUE;
+ return true;
}
/* This is a version of bfd_generic_get_relocated_section_contents
struct bfd_link_info *link_info,
struct bfd_link_order *link_order,
bfd_byte *data,
- bfd_boolean relocatable,
+ bool relocatable,
asymbol **symbols)
{
Elf_Internal_Shdr *symtab_hdr;
internal_relocs = (_bfd_elf_link_read_relocs
(input_bfd, input_section, NULL,
- (Elf_Internal_Rela *) NULL, FALSE));
+ (Elf_Internal_Rela *) NULL, false));
if (internal_relocs == NULL)
goto error_return;
Since we don't do .gots or .plts, we just need to consider the
virtual table relocs for gc. */
-static bfd_boolean
+static bool
sh_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
const Elf_Internal_Rela *relocs)
{
sreloc = NULL;
if (bfd_link_relocatable (info))
- return TRUE;
+ return true;
BFD_ASSERT (is_sh_elf (abfd));
htab = sh_elf_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
rel_end = relocs + sec->reloc_count;
for (rel = relocs; rel < rel_end; rel++)
if (htab->root.dynobj == NULL)
htab->root.dynobj = abfd;
if (!create_got_section (htab->root.dynobj, info))
- return FALSE;
+ return false;
break;
default:
Reconstruct it for later use during GC. */
case R_SH_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_SH_GNU_VTENTRY:
if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
- return FALSE;
+ return false;
break;
case R_SH_TLS_IE_32:
local_got_refcounts = ((bfd_signed_vma *)
bfd_zalloc (abfd, size));
if (local_got_refcounts == NULL)
- return FALSE;
+ return false;
elf_local_got_refcounts (abfd) = local_got_refcounts;
sh_elf_local_got_type (abfd)
= (char *) (local_got_refcounts + symtab_hdr->sh_info);
/* xgettext:c-format */
(_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd, h->root.root.string);
- return FALSE;
+ return false;
}
}
_bfd_error_handler
(_("%pB: Function descriptor relocation with non-zero addend"),
abfd);
- return FALSE;
+ return false;
}
if (h == NULL)
size = symtab_hdr->sh_info * sizeof (union gotref);
local_funcdesc = (union gotref *) bfd_zalloc (abfd, size);
if (local_funcdesc == NULL)
- return FALSE;
+ return false;
sh_elf_local_funcdesc (abfd) = local_funcdesc;
}
local_funcdesc[r_symndx].refcount += 1;
if (sreloc == NULL)
{
sreloc = _bfd_elf_make_dynamic_reloc_section
- (sec, htab->root.dynobj, 2, abfd, /*rela?*/ TRUE);
+ (sec, htab->root.dynobj, 2, abfd, /*rela?*/ true);
if (sreloc == NULL)
- return FALSE;
+ return false;
}
/* If this is a global symbol, we count the number of
isym = bfd_sym_from_r_symndx (&htab->root.sym_cache,
abfd, r_symndx);
if (isym == NULL)
- return FALSE;
+ return false;
s = bfd_section_from_elf_index (abfd, isym->st_shndx);
if (s == NULL)
size_t amt = sizeof (*p);
p = bfd_alloc (htab->root.dynobj, amt);
if (p == NULL)
- return FALSE;
+ return false;
p->next = *head;
*head = p;
p->sec = sec;
_bfd_error_handler
(_("%pB: TLS local exec code cannot be linked into shared objects"),
abfd);
- return FALSE;
+ return false;
}
break;
}
}
- return TRUE;
+ return true;
}
#ifndef sh_elf_set_mach_from_flags
static unsigned int sh_ef_bfd_table[] = { EF_SH_BFD_TABLE };
-static bfd_boolean
+static bool
sh_elf_set_mach_from_flags (bfd *abfd)
{
flagword flags = elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK;
if (flags >= ARRAY_SIZE (sh_ef_bfd_table))
- return FALSE;
+ return false;
if (sh_ef_bfd_table[flags] == 0)
- return FALSE;
+ return false;
bfd_default_set_arch_mach (abfd, bfd_arch_sh, sh_ef_bfd_table[flags]);
- return TRUE;
+ return true;
}
#ifndef sh_elf_copy_private_data
/* Copy backend specific data from one object module to another */
-static bfd_boolean
+static bool
sh_elf_copy_private_data (bfd * ibfd, bfd * obfd)
{
if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
- return TRUE;
+ return true;
if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
- return FALSE;
+ return false;
return sh_elf_set_mach_from_flags (obfd);
}
DSP while the other uses FPU - or there is no known architecture
that fits the requirements then an error is emitted. */
-static bfd_boolean
+static bool
sh_merge_bfd_arch (bfd *ibfd, struct bfd_link_info *info)
{
bfd *obfd = info->output_bfd;
unsigned int old_arch, new_arch, merged_arch;
if (! _bfd_generic_verify_endian_match (ibfd, info))
- return FALSE;
+ return false;
old_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd));
new_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd));
SH_ARCH_SET_HAS_DSP (new_arch) ? "dsp" : "floating point",
SH_ARCH_SET_HAS_DSP (new_arch) ? "floating point" : "dsp");
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
else if (!SH_VALID_ARCH_SET (merged_arch))
{
bfd_printable_name (obfd),
bfd_printable_name (ibfd));
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
bfd_default_set_arch_mach (obfd, bfd_arch_sh,
sh_get_bfd_mach_from_arch_set (merged_arch));
- return TRUE;
+ return true;
}
/* This routine initialises the elf flags when required and
calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
-static bfd_boolean
+static bool
sh_elf_merge_private_data (bfd *ibfd, struct bfd_link_info *info)
{
bfd *obfd = info->output_bfd;
/* FIXME: What should be checked when linking shared libraries? */
if ((ibfd->flags & DYNAMIC) != 0)
- return TRUE;
+ return true;
if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
- return TRUE;
+ return true;
if (! elf_flags_init (obfd))
{
/* This happens when ld starts out with a 'blank' output file. */
- elf_flags_init (obfd) = TRUE;
+ elf_flags_init (obfd) = true;
elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
sh_elf_set_mach_from_flags (obfd);
if (elf_elfheader (obfd)->e_flags & EF_SH_FDPIC)
"with instructions used in previous modules"),
ibfd);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
elf_elfheader (obfd)->e_flags &= ~EF_SH_MACH_MASK;
_bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"),
ibfd);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
#endif /* not sh_elf_merge_private_data */
as the specific tdata. We set also the machine architecture from flags
here. */
-static bfd_boolean
+static bool
sh_elf_object_p (bfd *abfd)
{
if (! sh_elf_set_mach_from_flags (abfd))
- return FALSE;
+ return false;
return (((elf_elfheader (abfd)->e_flags & EF_SH_FDPIC) != 0)
== fdpic_object_p (abfd));
/* Finish up dynamic symbol handling. We set the contents of various
dynamic sections here. */
-static bfd_boolean
+static bool
sh_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
struct elf_link_hash_entry *h,
Elf_Internal_Sym *sym)
htab = sh_elf_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
if (h->plt.offset != (bfd_vma) -1)
{
BFD_ASSERT (r == bfd_reloc_ok);
}
else
- install_plt_field (output_bfd, FALSE, got_offset,
+ install_plt_field (output_bfd, false, got_offset,
(splt->contents
+ h->plt.offset
+ plt_info->symbol_fields.got_entry));
{
BFD_ASSERT (!plt_info->symbol_fields.got20);
- install_plt_field (output_bfd, FALSE,
+ install_plt_field (output_bfd, false,
(sgotplt->output_section->vma
+ sgotplt->output_offset
+ got_offset),
+ plt_info->symbol_fields.plt));
}
else
- install_plt_field (output_bfd, TRUE,
+ install_plt_field (output_bfd, true,
splt->output_section->vma + splt->output_offset,
(splt->contents
+ h->plt.offset
got_offset = plt_index * 8;
if (plt_info->symbol_fields.reloc_offset != MINUS_ONE)
- install_plt_field (output_bfd, FALSE,
+ install_plt_field (output_bfd, false,
plt_index * sizeof (Elf32_External_Rela),
(splt->contents
+ h->plt.offset
|| (htab->root.target_os != is_vxworks && h == htab->root.hgot))
sym->st_shndx = SHN_ABS;
- return TRUE;
+ return true;
}
/* Finish up the dynamic sections. */
-static bfd_boolean
+static bool
sh_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
{
struct elf_sh_link_hash_table *htab;
htab = sh_elf_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
sgotplt = htab->root.sgotplt;
sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
htab->plt_info->plt0_entry_size);
for (i = 0; i < ARRAY_SIZE (htab->plt_info->plt0_got_fields); i++)
if (htab->plt_info->plt0_got_fields[i] != MINUS_ONE)
- install_plt_field (output_bfd, FALSE,
+ install_plt_field (output_bfd, false,
(sgotplt->output_section->vma
+ sgotplt->output_offset
+ (i * 4)),
BFD_ASSERT (htab->root.srelgot->reloc_count * sizeof (Elf32_External_Rela)
== htab->root.srelgot->size);
- return TRUE;
+ return true;
}
static enum elf_reloc_type_class
#if !defined SH_TARGET_ALREADY_DEFINED
/* Support for Linux core dump NOTE sections. */
-static bfd_boolean
+static bool
elf32_shlin_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
{
int offset;
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 168: /* Linux/SH */
/* pr_cursig */
size, note->descpos + offset);
}
-static bfd_boolean
+static bool
elf32_shlin_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
{
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 124: /* Linux/SH elf_prpsinfo */
elf_tdata (abfd)->core->program
command[n - 1] = '\0';
}
- return TRUE;
+ return true;
}
#endif /* not SH_TARGET_ALREADY_DEFINED */
/* Decide whether to attempt to turn absptr or lsda encodings in
shared libraries into pcrel within the given input section. */
-static bfd_boolean
+static bool
sh_elf_use_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info,
asection *eh_frame_section ATTRIBUTE_UNUSED)
/* We can't use PC-relative encodings in FDPIC binaries, in general. */
if (htab->fdpic_p)
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
/* Adjust the contents of an eh_frame_hdr section before they're output. */
#define elf_backend_got_header_size 12
#define elf_backend_dtrel_excludes_plt 1
-#define elf_backend_linux_prpsinfo32_ugid16 TRUE
+#define elf_backend_linux_prpsinfo32_ugid16 true
#if !defined SH_TARGET_ALREADY_DEFINED