summaryrefslogtreecommitdiff
path: root/bfd/sparclinux.c
diff options
context:
space:
mode:
Diffstat (limited to 'bfd/sparclinux.c')
-rw-r--r--bfd/sparclinux.c443
1 files changed, 221 insertions, 222 deletions
diff --git a/bfd/sparclinux.c b/bfd/sparclinux.c
index e55a4ffc2b2..4352727a206 100644
--- a/bfd/sparclinux.c
+++ b/bfd/sparclinux.c
@@ -19,12 +19,12 @@ along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
USA. */
-#define TARGET_PAGE_SIZE 4096
-#define ZMAGIC_DISK_BLOCK_SIZE 1024
-#define SEGMENT_SIZE TARGET_PAGE_SIZE
-#define TEXT_START_ADDR 0x0
-#define N_SHARED_LIB(x) 0
-#define BYTES_IN_WORD 4
+#define TARGET_PAGE_SIZE 4096
+#define ZMAGIC_DISK_BLOCK_SIZE 1024
+#define SEGMENT_SIZE TARGET_PAGE_SIZE
+#define TEXT_START_ADDR 0x0
+#define N_SHARED_LIB(x) 0
+#define BYTES_IN_WORD 4
#define MACHTYPE_OK(mtype) ((mtype) == M_SPARC || (mtype) == M_UNKNOWN)
@@ -52,10 +52,10 @@ extern const bfd_target MY(vec);
static void MY_final_link_callback
PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
-static boolean sparclinux_bfd_final_link
+static bfd_boolean sparclinux_bfd_final_link
PARAMS ((bfd *abfd, struct bfd_link_info *info));
-static boolean
+static bfd_boolean
sparclinux_bfd_final_link (abfd, info)
bfd *abfd;
struct bfd_link_info *info;
@@ -68,9 +68,9 @@ sparclinux_bfd_final_link (abfd, info)
/* Set the machine type correctly. */
-static boolean sparclinux_write_object_contents PARAMS ((bfd *abfd));
+static bfd_boolean sparclinux_write_object_contents PARAMS ((bfd *abfd));
-static boolean
+static bfd_boolean
sparclinux_write_object_contents (abfd)
bfd *abfd;
{
@@ -83,7 +83,7 @@ sparclinux_write_object_contents (abfd)
WRITE_HEADERS(abfd, execp);
- return true;
+ return TRUE;
}
#define MY_write_object_contents sparclinux_write_object_contents
@@ -92,7 +92,7 @@ sparclinux_write_object_contents (abfd)
/* See if a symbol name is a reference to the global offset table. */
#ifndef GOT_REF_PREFIX
-#define GOT_REF_PREFIX "__GOT_"
+#define GOT_REF_PREFIX "__GOT_"
#endif
#define IS_GOT_SYM(name) \
@@ -101,7 +101,7 @@ sparclinux_write_object_contents (abfd)
/* See if a symbol name is a reference to the procedure linkage table. */
#ifndef PLT_REF_PREFIX
-#define PLT_REF_PREFIX "__PLT_"
+#define PLT_REF_PREFIX "__PLT_"
#endif
#define IS_PLT_SYM(name) \
@@ -179,16 +179,16 @@ static struct bfd_link_hash_table *linux_link_hash_table_create
PARAMS ((bfd *));
static struct fixup *new_fixup
PARAMS ((struct bfd_link_info *, struct linux_link_hash_entry *,
- bfd_vma, int));
-static boolean linux_link_create_dynamic_sections
+ bfd_vma, int));
+static bfd_boolean linux_link_create_dynamic_sections
PARAMS ((bfd *, struct bfd_link_info *));
-static boolean linux_add_one_symbol
+static bfd_boolean linux_add_one_symbol
PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
- bfd_vma, const char *, boolean, boolean,
- struct bfd_link_hash_entry **));
-static boolean linux_tally_symbols
+ bfd_vma, const char *, bfd_boolean, bfd_boolean,
+ struct bfd_link_hash_entry **));
+static bfd_boolean linux_tally_symbols
PARAMS ((struct linux_link_hash_entry *, PTR));
-static boolean linux_finish_dynamic_link
+static bfd_boolean linux_finish_dynamic_link
PARAMS ((bfd *, struct bfd_link_info *));
/* Routine to create an entry in an Linux link hash table. */
@@ -205,14 +205,14 @@ linux_link_hash_newfunc (entry, table, string)
subclass. */
if (ret == (struct linux_link_hash_entry *) NULL)
ret = ((struct linux_link_hash_entry *)
- bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
+ bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
if (ret == NULL)
return (struct bfd_hash_entry *) ret;
/* Call the allocation method of the superclass. */
ret = ((struct linux_link_hash_entry *)
- NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
- table, string));
+ NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
+ table, string));
if (ret != NULL)
{
/* Set local fields; there aren't any. */
@@ -234,7 +234,7 @@ linux_link_hash_table_create (abfd)
if (ret == (struct linux_link_hash_table *) NULL)
return (struct bfd_link_hash_table *) NULL;
if (! NAME(aout,link_hash_table_init) (&ret->root, abfd,
- linux_link_hash_newfunc))
+ linux_link_hash_newfunc))
{
free (ret);
return (struct bfd_link_hash_table *) NULL;
@@ -253,14 +253,14 @@ linux_link_hash_table_create (abfd)
#define linux_link_hash_lookup(table, string, create, copy, follow) \
((struct linux_link_hash_entry *) \
aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
- (follow)))
+ (follow)))
/* Traverse a Linux link hash table. */
-#define linux_link_hash_traverse(table, func, info) \
- (aout_link_hash_traverse \
- (&(table)->root, \
- (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
+#define linux_link_hash_traverse(table, func, info) \
+ (aout_link_hash_traverse \
+ (&(table)->root, \
+ (bfd_boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
(info)))
/* Get the Linux link hash table from the info structure. This is
@@ -280,7 +280,7 @@ new_fixup (info, h, value, builtin)
struct fixup *f;
f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
- sizeof (struct fixup));
+ sizeof (struct fixup));
if (f == NULL)
return f;
f->next = linux_hash_table (info)->fixup_list;
@@ -300,7 +300,7 @@ new_fixup (info, h, value, builtin)
know the size of the section, but that's OK - we just need to
create it for now. */
-static boolean
+static bfd_boolean
linux_link_create_dynamic_sections (abfd, info)
bfd *abfd;
struct bfd_link_info *info ATTRIBUTE_UNUSED;
@@ -312,25 +312,25 @@ linux_link_create_dynamic_sections (abfd, info)
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
/* We choose to use the name ".linux-dynamic" for the fixup table.
- Why not? */
+ Why not? */
s = bfd_make_section (abfd, ".linux-dynamic");
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, flags)
|| ! bfd_set_section_alignment (abfd, s, 2))
- return false;
+ return FALSE;
s->_raw_size = 0;
s->contents = 0;
- return true;
+ return TRUE;
}
/* Function to add a single symbol to the linker hash table. This is
a wrapper around _bfd_generic_link_add_one_symbol which handles the
tweaking needed for dynamic linking support. */
-static boolean
+static bfd_boolean
linux_add_one_symbol (info, abfd, name, flags, section, value, string,
- copy, collect, hashp)
+ copy, collect, hashp)
struct bfd_link_info *info;
bfd *abfd;
const char *name;
@@ -338,12 +338,12 @@ linux_add_one_symbol (info, abfd, name, flags, section, value, string,
asection *section;
bfd_vma value;
const char *string;
- boolean copy;
- boolean collect;
+ bfd_boolean copy;
+ bfd_boolean collect;
struct bfd_link_hash_entry **hashp;
{
struct linux_link_hash_entry *h;
- boolean insert;
+ bfd_boolean insert;
/* Look up and see if we already have this symbol in the hash table.
If we do, and the defining entry is from a shared library, we
@@ -353,7 +353,7 @@ linux_add_one_symbol (info, abfd, name, flags, section, value, string,
be able to link Linux a.out and ELF objects together, but serious
confusion is possible. */
- insert = false;
+ insert = FALSE;
if (! info->relocateable
&& linux_hash_table (info)->dynobj == NULL
@@ -362,60 +362,60 @@ linux_add_one_symbol (info, abfd, name, flags, section, value, string,
&& abfd->xvec == info->hash->creator)
{
if (! linux_link_create_dynamic_sections (abfd, info))
- return false;
+ return FALSE;
linux_hash_table (info)->dynobj = abfd;
- insert = true;
+ insert = TRUE;
}
if (bfd_is_abs_section (section)
&& abfd->xvec == info->hash->creator)
{
- h = linux_link_hash_lookup (linux_hash_table (info), name, false,
- false, false);
+ h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE,
+ FALSE, FALSE);
if (h != NULL
- && (h->root.root.type == bfd_link_hash_defined
- || h->root.root.type == bfd_link_hash_defweak))
- {
- struct fixup *f;
+ && (h->root.root.type == bfd_link_hash_defined
+ || h->root.root.type == bfd_link_hash_defweak))
+ {
+ struct fixup *f;
- if (hashp != NULL)
- *hashp = (struct bfd_link_hash_entry *) h;
+ if (hashp != NULL)
+ *hashp = (struct bfd_link_hash_entry *) h;
- f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
- if (f == NULL)
- return false;
- f->jump = IS_PLT_SYM (name);
+ f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
+ if (f == NULL)
+ return FALSE;
+ f->jump = IS_PLT_SYM (name);
- return true;
- }
+ return TRUE;
+ }
}
/* Do the usual procedure for adding a symbol. */
if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
- value, string, copy, collect,
- hashp))
- return false;
+ value, string, copy, collect,
+ hashp))
+ return FALSE;
/* Insert a pointer to our table in the set vector. The dynamic
- linker requires this information */
+ linker requires this information. */
if (insert)
{
asection *s;
/* Here we do our special thing to add the pointer to the
- dynamic section in the SHARABLE_CONFLICTS set vector. */
+ dynamic section in the SHARABLE_CONFLICTS set vector. */
s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
- ".linux-dynamic");
+ ".linux-dynamic");
BFD_ASSERT (s != NULL);
if (! (_bfd_generic_link_add_one_symbol
- (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
- BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
- false, false, NULL)))
- return false;
+ (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
+ BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
+ FALSE, FALSE, NULL)))
+ return FALSE;
}
- return true;
+ return TRUE;
}
/* We will crawl the hash table and come here for every global symbol.
@@ -428,7 +428,7 @@ linux_add_one_symbol (info, abfd, name, flags, section, value, string,
This function is called via linux_link_hash_traverse. */
-static boolean
+static bfd_boolean
linux_tally_symbols (h, data)
struct linux_link_hash_entry *h;
PTR data;
@@ -437,14 +437,14 @@ linux_tally_symbols (h, data)
struct fixup *f, *f1;
int is_plt;
struct linux_link_hash_entry *h1, *h2;
- boolean exists;
+ bfd_boolean exists;
if (h->root.root.type == bfd_link_hash_warning)
h = (struct linux_link_hash_entry *) h->root.root.u.i.link;
if (h->root.root.type == bfd_link_hash_undefined
&& strncmp (h->root.root.root.string, NEEDS_SHRLIB,
- sizeof NEEDS_SHRLIB - 1) == 0)
+ sizeof NEEDS_SHRLIB - 1) == 0)
{
const char *name;
char *p;
@@ -453,21 +453,21 @@ linux_tally_symbols (h, data)
name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
p = strrchr (name, '_');
if (p != NULL)
- alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
+ alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
if (p == NULL || alloc == NULL)
- (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
- name);
+ (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
+ name);
else
- {
- strcpy (alloc, name);
- p = strrchr (alloc, '_');
- *p++ = '\0';
- (*_bfd_error_handler)
- (_("Output file requires shared library `%s.so.%s'\n"),
- alloc, p);
- free (alloc);
- }
+ {
+ strcpy (alloc, name);
+ p = strrchr (alloc, '_');
+ *p++ = '\0';
+ (*_bfd_error_handler)
+ (_("Output file requires shared library `%s.so.%s'\n"),
+ alloc, p);
+ free (alloc);
+ }
abort ();
}
@@ -479,75 +479,75 @@ linux_tally_symbols (h, data)
if (is_plt || IS_GOT_SYM (h->root.root.root.string))
{
/* Look up this symbol twice. Once just as a regular lookup,
- and then again following all of the indirect links until we
- reach a real symbol. */
+ and then again following all of the indirect links until we
+ reach a real symbol. */
h1 = linux_link_hash_lookup (linux_hash_table (info),
- (h->root.root.root.string
- + sizeof PLT_REF_PREFIX - 1),
- false, false, true);
+ (h->root.root.root.string
+ + sizeof PLT_REF_PREFIX - 1),
+ FALSE, FALSE, TRUE);
/* h2 does not follow indirect symbols. */
h2 = linux_link_hash_lookup (linux_hash_table (info),
- (h->root.root.root.string
- + sizeof PLT_REF_PREFIX - 1),
- false, false, false);
+ (h->root.root.root.string
+ + sizeof PLT_REF_PREFIX - 1),
+ FALSE, FALSE, FALSE);
/* The real symbol must exist but if it is also an ABS symbol,
- there is no need to have a fixup. This is because they both
- came from the same library. If on the other hand, we had to
- use an indirect symbol to get to the real symbol, we add the
- fixup anyway, since there are cases where these symbols come
- from different shared libraries */
+ there is no need to have a fixup. This is because they both
+ came from the same library. If on the other hand, we had to
+ use an indirect symbol to get to the real symbol, we add the
+ fixup anyway, since there are cases where these symbols come
+ from different shared libraries */
if (h1 != NULL
- && (((h1->root.root.type == bfd_link_hash_defined
- || h1->root.root.type == bfd_link_hash_defweak)
- && ! bfd_is_abs_section (h1->root.root.u.def.section))
- || h2->root.root.type == bfd_link_hash_indirect))
- {
- /* See if there is a "builtin" fixup already present
- involving this symbol. If so, convert it to a regular
- fixup. In the end, this relaxes some of the requirements
- about the order of performing fixups. */
- exists = false;
- for (f1 = linux_hash_table (info)->fixup_list;
- f1 != NULL;
- f1 = f1->next)
- {
- if ((f1->h != h && f1->h != h1)
- || (! f1->builtin && ! f1->jump))
- continue;
- if (f1->h == h1)
- exists = true;
- if (! exists
- && bfd_is_abs_section (h->root.root.u.def.section))
- {
- f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
- f->jump = is_plt;
- }
- f1->h = h1;
- f1->jump = is_plt;
- f1->builtin = 0;
- exists = true;
- }
- if (! exists
- && bfd_is_abs_section (h->root.root.u.def.section))
- {
- f = new_fixup (info, h1, h->root.root.u.def.value, 0);
- if (f == NULL)
- {
- /* FIXME: No way to return error. */
- abort ();
- }
- f->jump = is_plt;
- }
- }
+ && (((h1->root.root.type == bfd_link_hash_defined
+ || h1->root.root.type == bfd_link_hash_defweak)
+ && ! bfd_is_abs_section (h1->root.root.u.def.section))
+ || h2->root.root.type == bfd_link_hash_indirect))
+ {
+ /* See if there is a "builtin" fixup already present
+ involving this symbol. If so, convert it to a regular
+ fixup. In the end, this relaxes some of the requirements
+ about the order of performing fixups. */
+ exists = FALSE;
+ for (f1 = linux_hash_table (info)->fixup_list;
+ f1 != NULL;
+ f1 = f1->next)
+ {
+ if ((f1->h != h && f1->h != h1)
+ || (! f1->builtin && ! f1->jump))
+ continue;
+ if (f1->h == h1)
+ exists = TRUE;
+ if (! exists
+ && bfd_is_abs_section (h->root.root.u.def.section))
+ {
+ f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
+ f->jump = is_plt;
+ }
+ f1->h = h1;
+ f1->jump = is_plt;
+ f1->builtin = 0;
+ exists = TRUE;
+ }
+ if (! exists
+ && bfd_is_abs_section (h->root.root.u.def.section))
+ {
+ f = new_fixup (info, h1, h->root.root.u.def.value, 0);
+ if (f == NULL)
+ {
+ /* FIXME: No way to return error. */
+ abort ();
+ }
+ f->jump = is_plt;
+ }
+ }
/* Quick and dirty way of stripping these symbols from the
- symtab. */
+ symtab. */
if (bfd_is_abs_section (h->root.root.u.def.section))
- h->root.written = true;
+ h->root.written = TRUE;
}
- return true;
+ return TRUE;
}
/* This is called to set the size of the .linux-dynamic section is.
@@ -556,7 +556,7 @@ linux_tally_symbols (h, data)
we just scan the hash tables to find out how many additional fixups
are required. */
-boolean
+bfd_boolean
bfd_sparclinux_size_dynamic_sections (output_bfd, info)
bfd *output_bfd;
struct bfd_link_info *info;
@@ -565,12 +565,12 @@ bfd_sparclinux_size_dynamic_sections (output_bfd, info)
asection *s;
if (output_bfd->xvec != &MY(vec))
- return true;
+ return TRUE;
/* First find the fixups... */
linux_link_hash_traverse (linux_hash_table (info),
- linux_tally_symbols,
- (PTR) info);
+ linux_tally_symbols,
+ (PTR) info);
/* If there are builtin fixups, leave room for a marker. This is
used by the dynamic linker so that it knows that all that follow
@@ -578,40 +578,40 @@ bfd_sparclinux_size_dynamic_sections (output_bfd, info)
for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
{
if (f->builtin)
- {
- ++linux_hash_table (info)->fixup_count;
- ++linux_hash_table (info)->local_builtins;
- break;
- }
+ {
+ ++linux_hash_table (info)->fixup_count;
+ ++linux_hash_table (info)->local_builtins;
+ break;
+ }
}
if (linux_hash_table (info)->dynobj == NULL)
{
if (linux_hash_table (info)->fixup_count > 0)
- abort ();
- return true;
+ abort ();
+ return TRUE;
}
/* Allocate memory for our fixup table. We will fill it in later. */
s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
- ".linux-dynamic");
+ ".linux-dynamic");
if (s != NULL)
{
s->_raw_size = linux_hash_table (info)->fixup_count + 1;
s->_raw_size *= 8;
s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
if (s->contents == NULL)
- return false;
+ return FALSE;
}
- return true;
+ return TRUE;
}
/* We come here once we are ready to actually write the fixup table to
the output file. Scan the fixup tables and so forth and generate
the stuff we need. */
-static boolean
+static bfd_boolean
linux_finish_dynamic_link (output_bfd, info)
bfd *output_bfd;
struct bfd_link_info *info;
@@ -625,18 +625,18 @@ linux_finish_dynamic_link (output_bfd, info)
unsigned int fixups_written;
if (linux_hash_table (info)->dynobj == NULL)
- return true;
+ return TRUE;
s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
- ".linux-dynamic");
+ ".linux-dynamic");
BFD_ASSERT (s != NULL);
os = s->output_section;
fixups_written = 0;
#ifdef LINUX_LINK_DEBUG
printf ("Fixup table file offset: %x VMA: %x\n",
- os->filepos + s->output_offset,
- os->vma + s->output_offset);
+ os->filepos + s->output_offset,
+ os->vma + s->output_offset);
#endif
fixup_table = s->contents;
@@ -648,16 +648,16 @@ linux_finish_dynamic_link (output_bfd, info)
for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
{
if (f->builtin)
- continue;
+ continue;
if (f->h->root.root.type != bfd_link_hash_defined
- && f->h->root.root.type != bfd_link_hash_defweak)
- {
- (*_bfd_error_handler)
- (_("Symbol %s not defined for fixups\n"),
- f->h->root.root.root.string);
- continue;
- }
+ && f->h->root.root.type != bfd_link_hash_defweak)
+ {
+ (*_bfd_error_handler)
+ (_("Symbol %s not defined for fixups\n"),
+ f->h->root.root.root.string);
+ continue;
+ }
is = f->h->root.root.u.def.section;
section_offset = is->output_section->vma + is->output_offset;
@@ -665,25 +665,25 @@ linux_finish_dynamic_link (output_bfd, info)
#ifdef LINUX_LINK_DEBUG
printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
- new_addr, f->value);
+ new_addr, f->value);
#endif
if (f->jump)
- {
- /* Relative address */
- new_addr = new_addr - (f->value + 5);
- bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
- fixup_table += 4;
- bfd_put_32 (output_bfd, f->value + 1, fixup_table);
- fixup_table += 4;
- }
+ {
+ /* Relative address */
+ new_addr = new_addr - (f->value + 5);
+ bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
+ fixup_table += 4;
+ bfd_put_32 (output_bfd, f->value + 1, fixup_table);
+ fixup_table += 4;
+ }
else
- {
- bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
- fixup_table += 4;
- bfd_put_32 (output_bfd, f->value, fixup_table);
- fixup_table += 4;
- }
+ {
+ bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
+ fixup_table += 4;
+ bfd_put_32 (output_bfd, f->value, fixup_table);
+ fixup_table += 4;
+ }
++fixups_written;
}
@@ -696,56 +696,56 @@ linux_finish_dynamic_link (output_bfd, info)
fixup_table += 4;
++fixups_written;
for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
- {
- if (! f->builtin)
- continue;
-
- if (f->h->root.root.type != bfd_link_hash_defined
- && f->h->root.root.type != bfd_link_hash_defweak)
- {
- (*_bfd_error_handler)
- (_("Symbol %s not defined for fixups\n"),
- f->h->root.root.root.string);
- continue;
- }
-
- is = f->h->root.root.u.def.section;
- section_offset = is->output_section->vma + is->output_offset;
- new_addr = f->h->root.root.u.def.value + section_offset;
+ {
+ if (! f->builtin)
+ continue;
+
+ if (f->h->root.root.type != bfd_link_hash_defined
+ && f->h->root.root.type != bfd_link_hash_defweak)
+ {
+ (*_bfd_error_handler)
+ (_("Symbol %s not defined for fixups\n"),
+ f->h->root.root.root.string);
+ continue;
+ }
+
+ is = f->h->root.root.u.def.section;
+ section_offset = is->output_section->vma + is->output_offset;
+ new_addr = f->h->root.root.u.def.value + section_offset;
#ifdef LINUX_LINK_DEBUG
- printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
- new_addr, f->value);
+ printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
+ new_addr, f->value);
#endif
- bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
- fixup_table += 4;
- bfd_put_32 (output_bfd, f->value, fixup_table);
- fixup_table += 4;
- ++fixups_written;
- }
- }
+ bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
+ fixup_table += 4;
+ bfd_put_32 (output_bfd, f->value, fixup_table);
+ fixup_table += 4;
+ ++fixups_written;
+ }
+ }
if (linux_hash_table (info)->fixup_count != fixups_written)
{
(*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
while (linux_hash_table (info)->fixup_count > fixups_written)
- {
- bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
- fixup_table += 4;
- bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
- fixup_table += 4;
- ++fixups_written;
- }
+ {
+ bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
+ fixup_table += 4;
+ bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
+ fixup_table += 4;
+ ++fixups_written;
+ }
}
h = linux_link_hash_lookup (linux_hash_table (info),
- "__BUILTIN_FIXUPS__",
- false, false, false);
+ "__BUILTIN_FIXUPS__",
+ FALSE, FALSE, FALSE);
if (h != NULL
&& (h->root.root.type == bfd_link_hash_defined
- || h->root.root.type == bfd_link_hash_defweak))
+ || h->root.root.type == bfd_link_hash_defweak))
{
is = h->root.root.u.def.section;
section_offset = is->output_section->vma + is->output_offset;
@@ -762,13 +762,12 @@ linux_finish_dynamic_link (output_bfd, info)
if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
SEEK_SET) != 0)
- return false;
+ return FALSE;
- if (bfd_bwrite ((PTR) s->contents, s->_raw_size, output_bfd)
- != s->_raw_size)
- return false;
+ if (bfd_bwrite ((PTR) s->contents, s->_raw_size, output_bfd) != s->_raw_size)
+ return FALSE;
- return true;
+ return TRUE;
}
#define MY_bfd_link_hash_table_create linux_link_hash_table_create