s/boolean/bfd_boolean/ s/true/TRUE/ s/false/FALSE/. Simplify

comparisons of bfd_boolean vars with TRUE/FALSE.  Formatting.

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