/* M32R-specific support for 32-bit ELF.
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
+ Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
static void m32r_info_to_howto_rel
- PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
-boolean _bfd_m32r_elf_section_from_bfd_section
+ PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
+bfd_boolean _bfd_m32r_elf_section_from_bfd_section
PARAMS ((bfd *, asection *, int *));
void _bfd_m32r_elf_symbol_processing
PARAMS ((bfd *, asymbol *));
-static boolean m32r_elf_add_symbol_hook
+static bfd_boolean m32r_elf_add_symbol_hook
PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
const char **, flagword *, asection **, bfd_vma *));
-static boolean m32r_elf_relocate_section
+static bfd_boolean m32r_elf_relocate_section
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
#if 0 /* not yet */
-static boolean m32r_elf_relax_delete_bytes
+static bfd_boolean m32r_elf_relax_delete_bytes
PARAMS ((bfd *, asection *, bfd_vma, int));
#endif
static bfd_reloc_status_type m32r_elf_final_sda_base
PARAMS ((bfd *, struct bfd_link_info *, const char **, bfd_vma *));
-static boolean m32r_elf_object_p
+static bfd_boolean m32r_elf_object_p
PARAMS ((bfd *));
static void m32r_elf_final_write_processing
- PARAMS ((bfd *, boolean));
-static boolean m32r_elf_set_private_flags
+ PARAMS ((bfd *, bfd_boolean));
+static bfd_boolean m32r_elf_set_private_flags
PARAMS ((bfd *, flagword));
-static boolean m32r_elf_merge_private_bfd_data
+static bfd_boolean m32r_elf_merge_private_bfd_data
PARAMS ((bfd *, bfd *));
-static boolean m32r_elf_print_private_bfd_data
+static bfd_boolean m32r_elf_print_private_bfd_data
PARAMS ((bfd *, PTR));
-static boolean m32r_elf_gc_sweep_hook
+static bfd_boolean m32r_elf_gc_sweep_hook
PARAMS ((bfd *, struct bfd_link_info *, asection *,
const Elf_Internal_Rela *));
-static boolean m32r_elf_check_relocs
+static bfd_boolean m32r_elf_check_relocs
PARAMS ((bfd *, struct bfd_link_info *, asection *,
const Elf_Internal_Rela *));
This only saves space in libraries and object files, but perhaps
relocs will be put in ROM? All in all though, REL relocs are a pain
to work with. */
-#define USE_REL
+#define USE_REL 1
+
+#ifndef USE_REL
+#define USE_REL 0
+#endif
static reloc_howto_type m32r_elf_howto_table[] =
{
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_M32R_NONE", /* name */
- false, /* partial_inplace */
+ FALSE, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
/* A 16 bit absolute relocation. */
HOWTO (R_M32R_16, /* type */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
m32r_elf_generic_reloc,/* special_function */
"R_M32R_16", /* name */
- true, /* partial_inplace */
+ TRUE, /* partial_inplace */
0xffff, /* src_mask */
0xffff, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
/* A 32 bit absolute relocation. */
HOWTO (R_M32R_32, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
m32r_elf_generic_reloc,/* special_function */
"R_M32R_32", /* name */
- true, /* partial_inplace */
+ TRUE, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
/* A 24 bit address. */
HOWTO (R_M32R_24, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
24, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_unsigned, /* complain_on_overflow */
m32r_elf_generic_reloc,/* special_function */
"R_M32R_24", /* name */
- true, /* partial_inplace */
+ TRUE, /* partial_inplace */
0xffffff, /* src_mask */
0xffffff, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
/* An PC Relative 10-bit relocation, shifted by 2.
This reloc is complicated because relocations are relative to pc & -4.
2, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
10, /* bitsize */
- true, /* pc_relative */
+ TRUE, /* pc_relative */
0, /* bitpos */
complain_overflow_signed, /* complain_on_overflow */
m32r_elf_10_pcrel_reloc, /* special_function */
"R_M32R_10_PCREL", /* name */
- false, /* partial_inplace */
+ FALSE, /* partial_inplace */
0xff, /* src_mask */
0xff, /* dst_mask */
- true), /* pcrel_offset */
+ TRUE), /* pcrel_offset */
/* A relative 18 bit relocation, right shifted by 2. */
HOWTO (R_M32R_18_PCREL, /* type */
2, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- true, /* pc_relative */
+ TRUE, /* pc_relative */
0, /* bitpos */
complain_overflow_signed, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_M32R_18_PCREL", /* name */
- false, /* partial_inplace */
+ FALSE, /* partial_inplace */
0xffff, /* src_mask */
0xffff, /* dst_mask */
- true), /* pcrel_offset */
+ TRUE), /* pcrel_offset */
/* A relative 26 bit relocation, right shifted by 2. */
/* ??? It's not clear whether this should have partial_inplace set or not.
2, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
26, /* bitsize */
- true, /* pc_relative */
+ TRUE, /* pc_relative */
0, /* bitpos */
complain_overflow_signed, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_M32R_26_PCREL", /* name */
- false, /* partial_inplace */
+ FALSE, /* partial_inplace */
0xffffff, /* src_mask */
0xffffff, /* dst_mask */
- true), /* pcrel_offset */
+ TRUE), /* pcrel_offset */
/* High 16 bits of address when lower 16 is or'd in. */
HOWTO (R_M32R_HI16_ULO, /* type */
16, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_dont, /* complain_on_overflow */
m32r_elf_hi16_reloc, /* special_function */
"R_M32R_HI16_ULO", /* name */
- true, /* partial_inplace */
+ TRUE, /* partial_inplace */
0x0000ffff, /* src_mask */
0x0000ffff, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
/* High 16 bits of address when lower 16 is added in. */
HOWTO (R_M32R_HI16_SLO, /* type */
16, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_dont, /* complain_on_overflow */
m32r_elf_hi16_reloc, /* special_function */
"R_M32R_HI16_SLO", /* name */
- true, /* partial_inplace */
+ TRUE, /* partial_inplace */
0x0000ffff, /* src_mask */
0x0000ffff, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
/* Lower 16 bits of address. */
HOWTO (R_M32R_LO16, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_dont, /* complain_on_overflow */
m32r_elf_lo16_reloc, /* special_function */
"R_M32R_LO16", /* name */
- true, /* partial_inplace */
+ TRUE, /* partial_inplace */
0x0000ffff, /* src_mask */
0x0000ffff, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
/* Small data area 16 bits offset. */
HOWTO (R_M32R_SDA16, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_signed, /* complain_on_overflow */
m32r_elf_sda16_reloc, /* special_function */
"R_M32R_SDA16", /* name */
- true, /* partial_inplace */ /* FIXME: correct? */
+ TRUE, /* partial_inplace */ /* FIXME: correct? */
0x0000ffff, /* src_mask */
0x0000ffff, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
/* GNU extension to record C++ vtable hierarchy */
HOWTO (R_M32R_GNU_VTINHERIT, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
0, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_dont, /* complain_on_overflow */
NULL, /* special_function */
"R_M32R_GNU_VTINHERIT", /* name */
- false, /* partial_inplace */
+ FALSE, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
/* GNU extension to record C++ vtable member usage */
HOWTO (R_M32R_GNU_VTENTRY, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
0, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_dont, /* complain_on_overflow */
_bfd_elf_rel_vtable_reloc_fn, /* special_function */
"R_M32R_GNU_VTENTRY", /* name */
- false, /* partial_inplace */
+ FALSE, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- false), /* pcrel_offset */
+ FALSE), /* pcrel_offset */
};
\f
/* Now do the LO16 reloc in the usual way.
??? It would be nice to call bfd_elf_generic_reloc here,
- but we have partial_inplace == TRUE. bfd_elf_generic_reloc will
+ but we have partial_inplace set. bfd_elf_generic_reloc will
pass the handling back to bfd_install_relocation which will install
a section relative addend which is wrong. */
return m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
/* Now do the reloc in the usual way.
??? It would be nice to call bfd_elf_generic_reloc here,
- but we have partial_inplace == TRUE. bfd_elf_generic_reloc will
+ but we have partial_inplace set. bfd_elf_generic_reloc will
pass the handling back to bfd_install_relocation which will install
a section relative addend which is wrong. */
m32r_info_to_howto_rel (abfd, cache_ptr, dst)
bfd *abfd ATTRIBUTE_UNUSED;
arelent *cache_ptr;
- Elf32_Internal_Rel *dst;
+ Elf_Internal_Rela *dst;
{
unsigned int r_type;
/* Given a BFD section, try to locate the corresponding ELF section
index. */
-boolean
+bfd_boolean
_bfd_m32r_elf_section_from_bfd_section (abfd, sec, retval)
bfd *abfd ATTRIBUTE_UNUSED;
asection *sec;
if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
{
*retval = SHN_M32R_SCOMMON;
- return true;
+ return TRUE;
}
- return false;
+ return FALSE;
}
/* M32R ELF uses two common sections. One is the usual one, and the other
We also keep watching for whether we need to create the sdata special
linker sections. */
-static boolean
+static bfd_boolean
m32r_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
bfd *abfd;
struct bfd_link_info *info;
section already exists a new one is created that follows it which
screws of _SDA_BASE_ address calcs because output_offset != 0. */
struct elf_link_hash_entry *h;
+ struct bfd_link_hash_entry *bh;
asection *s = bfd_get_section_by_name (abfd, ".sdata");
/* The following code was cobbled from elf32-ppc.c and elflink.c. */
s = bfd_make_section_anyway (abfd, ".sdata");
if (s == NULL)
- return false;
+ return FALSE;
bfd_set_section_flags (abfd, s, flags);
bfd_set_section_alignment (abfd, s, 2);
}
- h = (struct elf_link_hash_entry *)
- bfd_link_hash_lookup (info->hash, "_SDA_BASE_", false, false, false);
+ bh = bfd_link_hash_lookup (info->hash, "_SDA_BASE_",
+ FALSE, FALSE, FALSE);
- if ((h == NULL || h->root.type == bfd_link_hash_undefined)
+ if ((bh == NULL || bh->type == bfd_link_hash_undefined)
&& !(_bfd_generic_link_add_one_symbol (info,
abfd,
"_SDA_BASE_",
s,
(bfd_vma) 32768,
(const char *) NULL,
- false,
+ FALSE,
get_elf_backend_data (abfd)->collect,
- (struct bfd_link_hash_entry **) &h)))
- return false;
+ &bh)))
+ return FALSE;
+ h = (struct elf_link_hash_entry *) bh;
h->type = STT_OBJECT;
}
break;
}
- return true;
+ return TRUE;
}
/* We have to figure out the SDA_BASE value, so that we can adjust the
{
struct bfd_link_hash_entry *h;
- h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", false, false, true);
+ h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
if (h != (struct bfd_link_hash_entry *) NULL
&& h->type == bfd_link_hash_defined)
elf_gp (output_bfd) = (h->u.def.value
\f
/* Relocate an M32R/D ELF section.
There is some attempt to make this function usable for many architectures,
- both USE_REL and USE_RELA ['twould be nice if such a critter existed],
- if only to serve as a learning tool.
+ both for RELA and REL type relocs, if only to serve as a learning tool.
The RELOCATE_SECTION function is called by the new ELF backend linker
to handle the relocations for a section.
section, which means that the addend must be adjusted
accordingly. */
-static boolean
+static bfd_boolean
m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
contents, relocs, local_syms, local_sections)
bfd *output_bfd ATTRIBUTE_UNUSED;
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
Elf_Internal_Rela *rel, *relend;
/* Assume success. */
- boolean ret = true;
+ bfd_boolean ret = TRUE;
-#ifndef USE_REL
+#if !USE_REL
if (info->relocateable)
- return true;
+ return TRUE;
#endif
rel = relocs;
bfd_archive_filename (input_bfd),
(int) r_type);
bfd_set_error (bfd_error_bad_value);
- ret = false;
+ ret = FALSE;
continue;
}
howto = m32r_elf_howto_table + r_type;
r_symndx = ELF32_R_SYM (rel->r_info);
-#ifdef USE_REL
+#if USE_REL
if (info->relocateable)
{
/* This is a relocateable link. We don't have to change
sym = local_syms + r_symndx;
sec = local_sections[r_symndx];
sym_name = "<local symbol>";
-#ifndef USE_REL
+#if !USE_REL
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
addend = rel->r_addend;
#else
{
if (! ((*info->callbacks->undefined_symbol)
(info, h->root.root.string, input_bfd,
- input_section, offset, true)))
- return false;
+ input_section, offset, TRUE)))
+ return FALSE;
relocation = 0;
}
}
&sda_base);
if (r != bfd_reloc_ok)
{
- ret = false;
+ ret = FALSE;
goto check_reloc;
}
m32r_elf_howto_table[(int) r_type].name,
bfd_get_section_name (abfd, sec));
/*bfd_set_error (bfd_error_bad_value); ??? why? */
- ret = false;
+ ret = FALSE;
continue;
}
}
if (! ((*info->callbacks->reloc_overflow)
(info, name, howto->name, (bfd_vma) 0,
input_bfd, input_section, offset)))
- return false;
+ return FALSE;
break;
case bfd_reloc_undefined:
if (! ((*info->callbacks->undefined_symbol)
(info, name, input_bfd, input_section,
- offset, true)))
- return false;
+ offset, TRUE)))
+ return FALSE;
break;
case bfd_reloc_outofrange:
if (!((*info->callbacks->warning)
(info, errmsg, name, input_bfd, input_section,
offset)))
- return false;
+ return FALSE;
break;
}
}
When the chip supports parallel 16 bit insns, things may change.
*/
-static boolean
+static bfd_boolean
m32r_elf_relax_section (abfd, sec, link_info, again)
bfd *abfd;
asection *sec;
struct bfd_link_info *link_info;
- boolean *again;
+ bfd_boolean *again;
{
Elf_Internal_Shdr *symtab_hdr;
/* The Rela structures are used here because that's what
- _bfd_elf32_link_read_relocs uses [for convenience - it sets the addend
+ _bfd_elf_link_read_relocs uses [for convenience - it sets the addend
field to 0]. */
Elf_Internal_Rela *internal_relocs = NULL;
Elf_Internal_Rela *irel, *irelend;
Elf_Internal_Sym *isymbuf = NULL;
/* Assume nothing changes. */
- *again = false;
+ *again = FALSE;
/* We don't have to do anything for a relocateable link, if
this section does not have relocs, or if this is not a
|| sec->reloc_count == 0
|| (sec->flags & SEC_CODE) == 0
|| 0 /* FIXME: check SHF_M32R_CAN_RELAX */)
- return true;
+ return TRUE;
/* If this is the first time we have been called for this section,
initialize the cooked size. */
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
/* Get a copy of the native relocations. */
- internal_relocs = (_bfd_elf32_link_read_relocs
+ internal_relocs = (_bfd_elf_link_read_relocs
(abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
link_info->keep_memory));
if (internal_relocs == NULL)
will be at least 4 bytes closer if we can relax. It'll actually
be 4 or 8 bytes closer, but we don't know which just yet and
the difference isn't significant enough to worry about. */
-#ifndef USE_REL /* put in for learning purposes */
+#if !USE_REL /* put in for learning purposes */
pcrel_value += irel->r_addend;
#else
addend = bfd_get_signed_16 (abfd, contents + irel->r_offset + 2);
We OR in CODE just in case it's not a nop (technically,
CODE currently must be a nop, but for cleanness we
allow it to be anything). */
-#ifndef USE_REL /* put in for learning purposes */
+#if !USE_REL /* put in for learning purposes */
code = 0x7e000000 | MAKE_PARALLEL (code);
#else
code = (0x7e000000 + (((addend >> 2) & 0xff) << 16)) | MAKE_PARALLEL (code);
else
{
/* Change the seth rN,foo to a bl24 foo. */
-#ifndef USE_REL /* put in for learning purposes */
+#if !USE_REL /* put in for learning purposes */
code = 0xfe000000;
#else
code = 0xfe000000 + ((addend >> 2) & 0xffffff);
/* That will change things, so we should relax again.
Note that this is not required, and it may be slow. */
- *again = true;
+ *again = TRUE;
continue;
}
&& elf_section_data (sec)->relocs != internal_relocs)
free (internal_relocs);
- return true;
+ return TRUE;
error_return:
if (isymbuf != NULL
&& elf_section_data (sec)->relocs != internal_relocs)
free (internal_relocs);
- return false;
+ return FALSE;
}
/* Delete some bytes from a section while relaxing. */
-static boolean
+static bfd_boolean
m32r_elf_relax_delete_bytes (abfd, sec, addr, count)
bfd *abfd;
asection *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;
- boolean relocateable;
+ bfd_boolean relocateable;
asymbol **symbols;
{
Elf_Internal_Shdr *symtab_hdr;
asection **secpp;
Elf32_External_Sym *esym, *esymend;
- internal_relocs = (_bfd_elf32_link_read_relocs
+ internal_relocs = (_bfd_elf_link_read_relocs
(input_bfd, input_section, (PTR) NULL,
- (Elf_Internal_Rela *) NULL, false));
+ (Elf_Internal_Rela *) NULL, FALSE));
if (internal_relocs == NULL)
goto error_return;
#endif /* #if 0 */
\f
/* Set the right machine number. */
-static boolean
+static bfd_boolean
m32r_elf_object_p (abfd)
bfd *abfd;
{
case E_M32R_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r); break;
case E_M32RX_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
}
- return true;
+ return TRUE;
}
/* Store the machine number in the flags field. */
static void
m32r_elf_final_write_processing (abfd, linker)
- bfd * abfd;
- boolean linker ATTRIBUTE_UNUSED;
+ bfd *abfd;
+ bfd_boolean linker ATTRIBUTE_UNUSED;
{
unsigned long val;
}
/* Function to keep M32R specific file flags. */
-static boolean
+static bfd_boolean
m32r_elf_set_private_flags (abfd, flags)
- bfd * abfd;
+ bfd *abfd;
flagword flags;
{
BFD_ASSERT (!elf_flags_init (abfd)
|| elf_elfheader (abfd)->e_flags == flags);
elf_elfheader (abfd)->e_flags = flags;
- elf_flags_init (abfd) = true;
- return true;
+ elf_flags_init (abfd) = TRUE;
+ return TRUE;
}
/* Merge backend specific data from an object file to the output
object file when linking. */
-static boolean
+static bfd_boolean
m32r_elf_merge_private_bfd_data (ibfd, obfd)
- bfd * ibfd;
- bfd * obfd;
+ bfd *ibfd;
+ bfd *obfd;
{
flagword out_flags;
flagword in_flags;
if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return true;
+ return TRUE;
in_flags = elf_elfheader (ibfd)->e_flags;
out_flags = elf_elfheader (obfd)->e_flags;
unitialised values, which surprise surprise, correspond
to the default values. */
if (bfd_get_arch_info (ibfd)->the_default)
- return true;
+ return TRUE;
- elf_flags_init (obfd) = true;
+ elf_flags_init (obfd) = TRUE;
elf_elfheader (obfd)->e_flags = in_flags;
if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
}
- return true;
+ return TRUE;
}
/* Check flag compatibility. */
if (in_flags == out_flags)
- return true;
+ return TRUE;
if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
{
bfd_archive_filename (ibfd));
bfd_set_error (bfd_error_bad_value);
- return false;
+ return FALSE;
}
}
- return true;
+ return TRUE;
}
/* Display the flags field */
-static boolean
+static bfd_boolean
m32r_elf_print_private_bfd_data (abfd, ptr)
- bfd * abfd;
- PTR ptr;
+ bfd *abfd;
+ PTR ptr;
{
FILE * file = (FILE *) ptr;
fputc ('\n', file);
- return true;
+ return TRUE;
}
asection *
return NULL;
}
-static boolean
+static bfd_boolean
m32r_elf_gc_sweep_hook (abfd, info, sec, relocs)
bfd *abfd ATTRIBUTE_UNUSED;
struct bfd_link_info *info ATTRIBUTE_UNUSED;
const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
{
/* we don't use got and plt entries for m32r */
- return true;
+ return TRUE;
}
/* Look through the relocs for a section during the first phase.
Since we don't do .gots or .plts, we just need to consider the
virtual table relocs for gc. */
-static boolean
+static bfd_boolean
m32r_elf_check_relocs (abfd, info, sec, relocs)
bfd *abfd;
struct bfd_link_info *info;
const Elf_Internal_Rela *rel_end;
if (info->relocateable)
- return true;
+ return TRUE;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (abfd);
Reconstruct it for later use during GC. */
case R_M32R_GNU_VTINHERIT:
if (!_bfd_elf32_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_M32R_GNU_VTENTRY:
if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
- return false;
+ return FALSE;
break;
}
}
- return true;
+ return TRUE;
}
\f
#define ELF_ARCH bfd_arch_m32r
#define elf_backend_check_relocs m32r_elf_check_relocs
#define elf_backend_can_gc_sections 1
-#ifndef USE_REL
+#if !USE_REL
#define elf_backend_rela_normal 1
#endif
#if 0 /* not yet */