Fix build failure on macOS

[deliverable/binutils-gdb.git] / binutils / wrstabs.c

diff --git a/binutils/wrstabs.c b/binutils/wrstabs.c
index 0feb4e25a86e919471c09cb68b8ae88efc6f7407..3e941dcefd5816fa3a54ce9fe4fb8544b06d0a6a 100644 (file)
--- a/binutils/wrstabs.c
+++ b/binutils/wrstabs.c
@@ -1,13 +1,12 @@
 /* wrstabs.c -- Output stabs debugging information
 /* wrstabs.c -- Output stabs debugging information

-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
-   Free Software Foundation, Inc.
+   Copyright (C) 1996-2019 Free Software Foundation, Inc.

    Written by Ian Lance Taylor <ian@cygnus.com>.
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    Written by Ian Lance Taylor <ian@cygnus.com>.
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -23,13 +22,13 @@
 /* This file contains code which writes out stabs debugging
    information.  */
 
 /* This file contains code which writes out stabs debugging
    information.  */
 

-#include <stdio.h>
+#include "sysdep.h"

 #include <assert.h>
 #include <assert.h>

-

 #include "bfd.h"
 #include "bfd.h"

-#include "bucomm.h"

 #include "libiberty.h"
 #include "libiberty.h"

+#include "filenames.h"

 #include "safe-ctype.h"
 #include "safe-ctype.h"

+#include "bucomm.h"

 #include "debug.h"
 #include "budbg.h"
 #include "aout/aout64.h"
 #include "debug.h"
 #include "budbg.h"
 #include "aout/aout64.h"


@@ -395,13 +394,13 @@ stab_write_symbol (struct stab_write_handle *info, int type, int desc,
 
 static bfd_boolean
 stab_push_string (struct stab_write_handle *info, const char *string,
 
 static bfd_boolean
 stab_push_string (struct stab_write_handle *info, const char *string,

-                 long index, bfd_boolean definition, unsigned int size)
+                 long tindex, bfd_boolean definition, unsigned int size)

 {
   struct stab_type_stack *s;
 
   s = (struct stab_type_stack *) xmalloc (sizeof *s);
   s->string = xstrdup (string);
 {
   struct stab_type_stack *s;
 
   s = (struct stab_type_stack *) xmalloc (sizeof *s);
   s->string = xstrdup (string);

-  s->index = index;
+  s->index = tindex;

   s->definition = definition;
   s->size = size;
 
   s->definition = definition;
   s->size = size;
 


@@ -419,13 +418,13 @@ stab_push_string (struct stab_write_handle *info, const char *string,
 /* Push a type index which has already been defined.  */
 
 static bfd_boolean
 /* Push a type index which has already been defined.  */
 
 static bfd_boolean

-stab_push_defined_type (struct stab_write_handle *info, long index,
+stab_push_defined_type (struct stab_write_handle *info, long tindex,

                        unsigned int size)
 {
   char buf[20];
 
                        unsigned int size)
 {
   char buf[20];
 

-  sprintf (buf, "%ld", index);
-  return stab_push_string (info, buf, index, FALSE, size);
+  sprintf (buf, "%ld", tindex);
+  return stab_push_string (info, buf, tindex, FALSE, size);

 }
 
 /* Pop a type off the type stack.  The caller is responsible for
 }
 
 /* Pop a type off the type stack.  The caller is responsible for


@@ -480,8 +479,10 @@ write_stabs_in_sections_debugging_info (bfd *abfd, void *dhandle,
   /* Reserve 1 byte for a null byte.  */
   info.strings_size = 1;
 
   /* Reserve 1 byte for a null byte.  */
   info.strings_size = 1;
 

-  if (! bfd_hash_table_init (&info.strhash.table, string_hash_newfunc)
-      || ! bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc))
+  if (!bfd_hash_table_init (&info.strhash.table, string_hash_newfunc,
+                           sizeof (struct string_hash_entry))
+      || !bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc,
+                              sizeof (struct string_hash_entry)))

     {
       non_fatal ("bfd_hash_table_init_failed: %s",
                 bfd_errmsg (bfd_get_error ()));
     {
       non_fatal ("bfd_hash_table_init_failed: %s",
                 bfd_errmsg (bfd_get_error ()));


@@ -585,15 +586,15 @@ stab_empty_type (void *p)
     return stab_push_defined_type (info, info->type_cache.void_type, 0);
   else
     {
     return stab_push_defined_type (info, info->type_cache.void_type, 0);
   else
     {

-      long index;
+      long tindex;

       char buf[40];
 
       char buf[40];
 

-      index = info->type_index;
+      tindex = info->type_index;

       ++info->type_index;
 
       ++info->type_index;
 

-      sprintf (buf, "%ld=%ld", index, index);
+      sprintf (buf, "%ld=%ld", tindex, tindex);

 
 

-      return stab_push_string (info, buf, index, FALSE, 0);
+      return stab_push_string (info, buf, tindex, FALSE, 0);

     }
 }
 
     }
 }
 


@@ -608,17 +609,17 @@ stab_void_type (void *p)
     return stab_push_defined_type (info, info->type_cache.void_type, 0);
   else
     {
     return stab_push_defined_type (info, info->type_cache.void_type, 0);
   else
     {

-      long index;
+      long tindex;

       char buf[40];
 
       char buf[40];
 

-      index = info->type_index;
+      tindex = info->type_index;

       ++info->type_index;
 
       ++info->type_index;
 

-      info->type_cache.void_type = index;
+      info->type_cache.void_type = tindex;

 
 

-      sprintf (buf, "%ld=%ld", index, index);
+      sprintf (buf, "%ld=%ld", tindex, tindex);

 
 

-      return stab_push_string (info, buf, index, TRUE, 0);
+      return stab_push_string (info, buf, tindex, TRUE, 0);

     }
 }
 
     }
 }
 


@@ -645,15 +646,15 @@ stab_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
     return stab_push_defined_type (info, cache[size - 1], size);
   else
     {
     return stab_push_defined_type (info, cache[size - 1], size);
   else
     {

-      long index;
+      long tindex;

       char buf[100];
 
       char buf[100];
 

-      index = info->type_index;
+      tindex = info->type_index;

       ++info->type_index;
 
       ++info->type_index;
 

-      cache[size - 1] = index;
+      cache[size - 1] = tindex;

 
 

-      sprintf (buf, "%ld=r%ld;", index, index);
+      sprintf (buf, "%ld=r%ld;", tindex, tindex);

       if (unsignedp)
        {
          strcat (buf, "0;");
       if (unsignedp)
        {
          strcat (buf, "0;");


@@ -678,7 +679,7 @@ stab_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
            abort ();
        }
 
            abort ();
        }
 

-      return stab_push_string (info, buf, index, TRUE, size);
+      return stab_push_string (info, buf, tindex, TRUE, size);

     }
 }
 
     }
 }
 


@@ -698,7 +699,7 @@ stab_float_type (void *p, unsigned int size)
                                   size);
   else
     {
                                   size);
   else
     {

-      long index;
+      long tindex;

       char *int_type;
       char buf[50];
 
       char *int_type;
       char buf[50];
 


@@ -707,19 +708,19 @@ stab_float_type (void *p, unsigned int size)
        return FALSE;
       int_type = stab_pop_type (info);
 
        return FALSE;
       int_type = stab_pop_type (info);
 

-      index = info->type_index;
+      tindex = info->type_index;

       ++info->type_index;
 
       if (size > 0
          && size - 1 < (sizeof info->type_cache.float_types
                         / sizeof info->type_cache.float_types[0]))
       ++info->type_index;
 
       if (size > 0
          && size - 1 < (sizeof info->type_cache.float_types
                         / sizeof info->type_cache.float_types[0]))

-       info->type_cache.float_types[size - 1] = index;
+       info->type_cache.float_types[size - 1] = tindex;

 
 

-      sprintf (buf, "%ld=r%s;%u;0;", index, int_type, size);
+      sprintf (buf, "%ld=r%s;%u;0;", tindex, int_type, size);

 
       free (int_type);
 
 
       free (int_type);
 

-      return stab_push_string (info, buf, index, TRUE, size);
+      return stab_push_string (info, buf, tindex, TRUE, size);

     }
 }
 
     }
 }
 


@@ -730,14 +731,14 @@ stab_complex_type (void *p, unsigned int size)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
   char buf[50];
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
   char buf[50];

-  long index;
+  long tindex;

 
 

-  index = info->type_index;
+  tindex = info->type_index;

   ++info->type_index;
 
   ++info->type_index;
 

-  sprintf (buf, "%ld=r%ld;%u;0;", index, index, size);
+  sprintf (buf, "%ld=r%ld;%u;0;", tindex, tindex, size);

 
 

-  return stab_push_string (info, buf, index, TRUE, size * 2);
+  return stab_push_string (info, buf, tindex, TRUE, size * 2);

 }
 
 /* Push a bfd_boolean type.  We use an XCOFF predefined type, since gdb
 }
 
 /* Push a bfd_boolean type.  We use an XCOFF predefined type, since gdb


@@ -747,29 +748,29 @@ static bfd_boolean
 stab_bool_type (void *p, unsigned int size)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
 stab_bool_type (void *p, unsigned int size)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;

-  long index;
+  long tindex;

 
   switch (size)
     {
     case 1:
 
   switch (size)
     {
     case 1:

-      index = -21;
+      tindex = -21;

       break;
 
     case 2:
       break;
 
     case 2:

-      index = -22;
+      tindex = -22;

       break;
 
     default:
     case 4:
       break;
 
     default:
     case 4:

-      index = -16;
+      tindex = -16;

       break;
 
     case 8:
       break;
 
     case 8:

-      index = -33;
+      tindex = -33;

       break;
     }
 
       break;
     }
 

-  return stab_push_defined_type (info, index, size);
+  return stab_push_defined_type (info, tindex, size);

 }
 
 /* Push an enum type.  */
 }
 
 /* Push an enum type.  */


@@ -782,7 +783,7 @@ stab_enum_type (void *p, const char *tag, const char **names,
   size_t len;
   const char **pn;
   char *buf;
   size_t len;
   const char **pn;
   char *buf;

-  long index = 0;
+  long tindex = 0;

   bfd_signed_vma *pv;
 
   if (names == NULL)
   bfd_signed_vma *pv;
 
   if (names == NULL)


@@ -810,9 +811,9 @@ stab_enum_type (void *p, const char *tag, const char **names,
     strcpy (buf, "e");
   else
     {
     strcpy (buf, "e");
   else
     {

-      index = info->type_index;
+      tindex = info->type_index;

       ++info->type_index;
       ++info->type_index;

-      sprintf (buf, "%s:T%ld=e", tag, index);
+      sprintf (buf, "%s:T%ld=e", tag, tindex);

     }
 
   for (pn = names, pv = vals; *pn != NULL; pn++, pv++)
     }
 
   for (pn = names, pv = vals; *pn != NULL; pn++, pv++)


@@ -829,7 +830,7 @@ stab_enum_type (void *p, const char *tag, const char **names,
     {
       /* FIXME: The size is just a guess.  */
       if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)
     {
       /* FIXME: The size is just a guess.  */
       if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)

-         || ! stab_push_defined_type (info, index, 4))
+         || ! stab_push_defined_type (info, tindex, 4))

        return FALSE;
     }
 
        return FALSE;
     }
 


@@ -846,7 +847,7 @@ stab_modify_type (struct stab_write_handle *info, int mod,
                  unsigned int size, long **cache, size_t *cache_alloc)
 {
   long targindex;
                  unsigned int size, long **cache, size_t *cache_alloc)
 {
   long targindex;

-  long index;
+  long tindex;

   char *s, *buf;
 
   assert (info->type_stack != NULL);
   char *s, *buf;
 
   assert (info->type_stack != NULL);


@@ -886,8 +887,8 @@ stab_modify_type (struct stab_write_handle *info, int mod,
          *cache_alloc = alloc;
        }
 
          *cache_alloc = alloc;
        }
 

-      index = (*cache)[targindex];
-      if (index != 0 && ! info->type_stack->definition)
+      tindex = (*cache)[targindex];
+      if (tindex != 0 && ! info->type_stack->definition)

        {
          /* We have already defined a modification of this type, and
              the entry on the type stack is not a definition, so we
        {
          /* We have already defined a modification of this type, and
              the entry on the type stack is not a definition, so we


@@ -896,22 +897,22 @@ stab_modify_type (struct stab_write_handle *info, int mod,
              is a struct which we did not define at the time it was
              referenced).  */
          free (stab_pop_type (info));
              is a struct which we did not define at the time it was
              referenced).  */
          free (stab_pop_type (info));

-         if (! stab_push_defined_type (info, index, size))
+         if (! stab_push_defined_type (info, tindex, size))

            return FALSE;
        }
       else
        {
            return FALSE;
        }
       else
        {

-         index = info->type_index;
+         tindex = info->type_index;

          ++info->type_index;
 
          s = stab_pop_type (info);
          buf = (char *) xmalloc (strlen (s) + 20);
          ++info->type_index;
 
          s = stab_pop_type (info);
          buf = (char *) xmalloc (strlen (s) + 20);

-         sprintf (buf, "%ld=%c%s", index, mod, s);
+         sprintf (buf, "%ld=%c%s", tindex, mod, s);

          free (s);
 
          free (s);
 

-         (*cache)[targindex] = index;
+         (*cache)[targindex] = tindex;

 
 

-         if (! stab_push_string (info, buf, index, TRUE, size))
+         if (! stab_push_string (info, buf, tindex, TRUE, size))

            return FALSE;
 
          free (buf);
            return FALSE;
 
          free (buf);


@@ -1018,7 +1019,7 @@ stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
   bfd_boolean definition;
   unsigned int element_size;
   char *range, *element, *buf;
   bfd_boolean definition;
   unsigned int element_size;
   char *range, *element, *buf;

-  long index;
+  long tindex;

   unsigned int size;
 
   definition = info->type_stack->definition;
   unsigned int size;
 
   definition = info->type_stack->definition;


@@ -1032,17 +1033,17 @@ stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
 
   if (! stringp)
     {
 
   if (! stringp)
     {

-      index = 0;
+      tindex = 0;

       *buf = '\0';
     }
   else
     {
       /* We need to define a type in order to include the string
          attribute.  */
       *buf = '\0';
     }
   else
     {
       /* We need to define a type in order to include the string
          attribute.  */

-      index = info->type_index;
+      tindex = info->type_index;

       ++info->type_index;
       definition = TRUE;
       ++info->type_index;
       definition = TRUE;

-      sprintf (buf, "%ld=@S;", index);
+      sprintf (buf, "%ld=@S;", tindex);

     }
 
   sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s",
     }
 
   sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s",


@@ -1054,7 +1055,7 @@ stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
     size = 0;
   else
     size = element_size * ((high - low) + 1);
     size = 0;
   else
     size = element_size * ((high - low) + 1);

-  if (! stab_push_string (info, buf, index, definition, size))
+  if (! stab_push_string (info, buf, tindex, definition, size))

     return FALSE;
 
   free (buf);
     return FALSE;
 
   free (buf);


@@ -1070,7 +1071,7 @@ stab_set_type (void *p, bfd_boolean bitstringp)
   struct stab_write_handle *info = (struct stab_write_handle *) p;
   bfd_boolean definition;
   char *s, *buf;
   struct stab_write_handle *info = (struct stab_write_handle *) p;
   bfd_boolean definition;
   char *s, *buf;

-  long index;
+  long tindex;

 
   definition = info->type_stack->definition;
 
 
   definition = info->type_stack->definition;
 


@@ -1080,22 +1081,22 @@ stab_set_type (void *p, bfd_boolean bitstringp)
   if (! bitstringp)
     {
       *buf = '\0';
   if (! bitstringp)
     {
       *buf = '\0';

-      index = 0;
+      tindex = 0;

     }
   else
     {
       /* We need to define a type in order to include the string
          attribute.  */
     }
   else
     {
       /* We need to define a type in order to include the string
          attribute.  */

-      index = info->type_index;
+      tindex = info->type_index;

       ++info->type_index;
       definition = TRUE;
       ++info->type_index;
       definition = TRUE;

-      sprintf (buf, "%ld=@S;", index);
+      sprintf (buf, "%ld=@S;", tindex);

     }
 
   sprintf (buf + strlen (buf), "S%s", s);
   free (s);
 
     }
 
   sprintf (buf + strlen (buf), "S%s", s);
   free (s);
 

-  if (! stab_push_string (info, buf, index, definition, 0))
+  if (! stab_push_string (info, buf, tindex, definition, 0))

     return FALSE;
 
   free (buf);
     return FALSE;
 
   free (buf);


@@ -1308,25 +1309,23 @@ stab_start_struct_type (void *p, const char *tag, unsigned int id,
                        bfd_boolean structp, unsigned int size)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
                        bfd_boolean structp, unsigned int size)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;

-  long index;
+  long tindex;

   bfd_boolean definition;
   bfd_boolean definition;

-  char *buf;
-
-  buf = (char *) xmalloc (40);
+  char buf[40];

 
   if (id == 0)
     {
 
   if (id == 0)
     {

-      index = 0;
+      tindex = 0;

       *buf = '\0';
       definition = FALSE;
     }
   else
     {
       *buf = '\0';
       definition = FALSE;
     }
   else
     {

-      index = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL,
+      tindex = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL,

                                     &size);
                                     &size);

-      if (index < 0)
+      if (tindex < 0)

        return FALSE;
        return FALSE;

-      sprintf (buf, "%ld=", index);
+      sprintf (buf, "%ld=", tindex);

       definition = TRUE;
     }
 
       definition = TRUE;
     }
 


@@ -1334,7 +1333,7 @@ stab_start_struct_type (void *p, const char *tag, unsigned int id,
           structp ? 's' : 'u',
           size);
 
           structp ? 's' : 'u',
           size);
 

-  if (! stab_push_string (info, buf, index, definition, size))
+  if (! stab_push_string (info, buf, tindex, definition, size))

     return FALSE;
 
   info->type_stack->fields = (char *) xmalloc (1);
     return FALSE;
 
   info->type_stack->fields = (char *) xmalloc (1);


@@ -1413,14 +1412,14 @@ stab_end_struct_type (void *p)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
   bfd_boolean definition;
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
   bfd_boolean definition;

-  long index;
+  long tindex;

   unsigned int size;
   char *fields, *first, *buf;
 
   assert (info->type_stack != NULL && info->type_stack->fields != NULL);
 
   definition = info->type_stack->definition;
   unsigned int size;
   char *fields, *first, *buf;
 
   assert (info->type_stack != NULL && info->type_stack->fields != NULL);
 
   definition = info->type_stack->definition;

-  index = info->type_stack->index;
+  tindex = info->type_stack->index;

   size = info->type_stack->size;
   fields = info->type_stack->fields;
   first = stab_pop_type (info);
   size = info->type_stack->size;
   fields = info->type_stack->fields;
   first = stab_pop_type (info);


@@ -1430,7 +1429,7 @@ stab_end_struct_type (void *p)
   free (first);
   free (fields);
 
   free (first);
   free (fields);
 

-  if (! stab_push_string (info, buf, index, definition, size))
+  if (! stab_push_string (info, buf, tindex, definition, size))

     return FALSE;
 
   free (buf);
     return FALSE;
 
   free (buf);


@@ -1441,18 +1440,15 @@ stab_end_struct_type (void *p)
 /* Start outputting a class.  */
 
 static bfd_boolean
 /* Start outputting a class.  */
 
 static bfd_boolean

-stab_start_class_type (void *p, const char *tag, unsigned int id, bfd_boolean structp, unsigned int size, bfd_boolean vptr, bfd_boolean ownvptr)
+stab_start_class_type (void *p, const char *tag, unsigned int id,
+                      bfd_boolean structp, unsigned int size,
+                      bfd_boolean vptr, bfd_boolean ownvptr)

 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;

-  bfd_boolean definition;
-  char *vstring;
+  bfd_boolean definition = FALSE;
+  char *vstring = NULL;

 
 

-  if (! vptr || ownvptr)
-    {
-      definition = FALSE;
-      vstring = NULL;
-    }
-  else
+  if (vptr && !ownvptr)

     {
       definition = info->type_stack->definition;
       vstring = stab_pop_type (info);
     {
       definition = info->type_stack->definition;
       vstring = stab_pop_type (info);


@@ -1473,17 +1469,16 @@ stab_start_class_type (void *p, const char *tag, unsigned int id, bfd_boolean st
        }
       else
        {
        }
       else
        {

+         assert (vstring);

          vtable = (char *) xmalloc (strlen (vstring) + 3);
          sprintf (vtable, "~%%%s", vstring);
          free (vstring);
          vtable = (char *) xmalloc (strlen (vstring) + 3);
          sprintf (vtable, "~%%%s", vstring);
          free (vstring);

+         if (definition)
+           info->type_stack->definition = TRUE;

        }
        }

-

       info->type_stack->vtable = vtable;
     }
 
       info->type_stack->vtable = vtable;
     }
 

-  if (definition)
-    info->type_stack->definition = TRUE;
-

   return TRUE;
 }
 
   return TRUE;
 }
 


@@ -1544,7 +1539,7 @@ stab_class_static_member (void *p, const char *name, const char *physname,
 /* Add a base class to the class on the type stack.  */
 
 static bfd_boolean
 /* Add a base class to the class on the type stack.  */
 
 static bfd_boolean

-stab_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual,
+stab_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,

                      enum debug_visibility visibility)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
                      enum debug_visibility visibility)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;


@@ -1560,7 +1555,7 @@ stab_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual,
   /* Build the base class specifier.  */
 
   buf = (char *) xmalloc (strlen (s) + 25);
   /* Build the base class specifier.  */
 
   buf = (char *) xmalloc (strlen (s) + 25);

-  buf[0] = virtual ? '1' : '0';
+  buf[0] = is_virtual ? '1' : '0';

   switch (visibility)
     {
     default:
   switch (visibility)
     {
     default:


@@ -1866,14 +1861,14 @@ stab_tag_type (void *p, const char *name, unsigned int id,
               enum debug_type_kind kind)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
               enum debug_type_kind kind)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;

-  long index;
-  unsigned int size;
+  long tindex;
+  unsigned int size = 0;

 
 

-  index = stab_get_struct_index (info, name, id, kind, &size);
-  if (index < 0)
+  tindex = stab_get_struct_index (info, name, id, kind, &size);
+  if (tindex < 0)

     return FALSE;
 
     return FALSE;
 

-  return stab_push_defined_type (info, index, size);
+  return stab_push_defined_type (info, tindex, size);

 }
 
 /* Define a typedef.  */
 }
 
 /* Define a typedef.  */


@@ -1882,24 +1877,24 @@ static bfd_boolean
 stab_typdef (void *p, const char *name)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;
 stab_typdef (void *p, const char *name)
 {
   struct stab_write_handle *info = (struct stab_write_handle *) p;

-  long index;
+  long tindex;

   unsigned int size;
   char *s, *buf;
   struct string_hash_entry *h;
 
   unsigned int size;
   char *s, *buf;
   struct string_hash_entry *h;
 

-  index = info->type_stack->index;
+  tindex = info->type_stack->index;

   size = info->type_stack->size;
   s = stab_pop_type (info);
 
   buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);
 
   size = info->type_stack->size;
   s = stab_pop_type (info);
 
   buf = (char *) xmalloc (strlen (name) + strlen (s) + 20);
 

-  if (index > 0)
+  if (tindex > 0)

     sprintf (buf, "%s:t%s", name, s);
   else
     {
     sprintf (buf, "%s:t%s", name, s);
   else
     {

-      index = info->type_index;
+      tindex = info->type_index;

       ++info->type_index;
       ++info->type_index;

-      sprintf (buf, "%s:t%ld=%s", name, index, s);
+      sprintf (buf, "%s:t%ld=%s", name, tindex, s);

     }
 
   free (s);
     }
 
   free (s);


@@ -1919,7 +1914,7 @@ stab_typdef (void *p, const char *name)
 
   /* I don't think we care about redefinitions.  */
 
 
   /* I don't think we care about redefinitions.  */
 

-  h->index = index;
+  h->index = tindex;

   h->size = size;
 
   return TRUE;
   h->size = size;
 
   return TRUE;


@@ -2049,12 +2044,12 @@ stab_variable (void *p, const char *name, enum debug_var_kind kind,
       if (! ISDIGIT (*s))
        {
          char *n;
       if (! ISDIGIT (*s))
        {
          char *n;

-         long index;
+         long tindex;

 
 

-         index = info->type_index;
+         tindex = info->type_index;

          ++info->type_index;
          n = (char *) xmalloc (strlen (s) + 20);
          ++info->type_index;
          n = (char *) xmalloc (strlen (s) + 20);

-         sprintf (n, "%ld=%s", index, s);
+         sprintf (n, "%ld=%s", tindex, s);

          free (s);
          s = n;
        }
          free (s);
          s = n;
        }


@@ -2260,7 +2255,7 @@ stab_lineno (void *p, const char *file, unsigned long lineno, bfd_vma addr)
   if (addr > info->last_text_address)
     info->last_text_address = addr;
 
   if (addr > info->last_text_address)
     info->last_text_address = addr;
 

-  if (strcmp (file, info->lineno_filename) != 0)
+  if (filename_cmp (file, info->lineno_filename) != 0)

     {
       if (! stab_write_symbol (info, N_SOL, 0, addr, file))
        return FALSE;
     {
       if (! stab_write_symbol (info, N_SOL, 0, addr, file))
        return FALSE;