diff options
Diffstat (limited to 'bfd/sparclinux.c')
| -rw-r--r-- | bfd/sparclinux.c | 443 |
1 files changed, 221 insertions, 222 deletions
diff --git a/bfd/sparclinux.c b/bfd/sparclinux.c index e55a4ff..4352727 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 |