* dbxread.c, buildsym.c, symtab.c, stabsread.c: Add support for

	reading stabs extensions for live range information.
	* stabsread.h, partial-stab.h: Add prototypes for new functions.
	* symtab.h: Add structure for storing live range information.

8 files changed, 746 insertions, 197 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 6789a1437b7..0729c388155 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,10 @@
+Sun Sep  7 17:26:30 1997  Dawn Perchik  <dawn@cygnus.com>
+
+	* dbxread.c, buildsym.c, symtab.c, stabsread.c: Add support for 
+	reading stabs extensions for live range information.
+	* stabsread.h, partial-stab.h: Add prototypes for new functions.
+	* symtab.h: Add structure for storing live range information.
+
 Wed Sep  3 16:39:39 1997  Andrew Cagney  <cagney@b1.cygnus.com>
 
 	* top.c (set_arch): New function, update target_architecture.
diff --git a/gdb/buildsym.c b/gdb/buildsym.c
index 6c944072e03..806d700ec80 100644
--- a/gdb/buildsym.c
+++ b/gdb/buildsym.c
@@ -95,6 +95,11 @@ add_symbol_to_list (symbol, listhead)
      struct pending **listhead;
 {
   register struct pending *link;
+
+  /* If this is a reference to/live alias for another symbol, don't add it.
+     We don't want to be able to look up the live references directly. */
+  if (symbol->ginfo.name && symbol->ginfo.name[0] == '#')
+    return;
       
   /* We keep PENDINGSIZE symbols in each link of the list.
      If we don't have a link with room in it, add a new link.  */
diff --git a/gdb/dbxread.c b/gdb/dbxread.c
index 41323ce5a1d..6463f27209f 100644
--- a/gdb/dbxread.c
+++ b/gdb/dbxread.c
@@ -182,6 +182,9 @@ struct complaint lbrac_mismatch_complaint =
 
 struct complaint repeated_header_complaint =
   {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
+
+struct complaint unclaimed_bincl_complaint =
+  {"N_BINCL %s not in entries for any file, at symtab pos %d", 0, 0};
 
 /* During initial symbol readin, we need to have a structure to keep
    track of which psymtabs have which bincls in them.  This structure
@@ -770,6 +773,7 @@ struct cont_elem
     int sym_idx;
     int sym_end;
     int symnum;
+    int (*func) (struct objfile *, struct symbol *, char *);
     /* other state dependancies include:
        (assumption is that these will not change since process_now FIXME!!)
         stringtab_global
@@ -777,25 +781,37 @@ struct cont_elem
         objfile
         symfile_bfd */
 };
-static struct cont_elem cont_list[100];
+
+static struct cont_elem *cont_list = 0;
+static int cont_limit = 0;
 static int cont_count = 0;
 
 void 
-process_later(sym,p)
+process_later (sym, p, f)
   struct symbol * sym;
   char * p;
+  int (*f) (struct objfile *, struct symbol *, char *);
 {
+  if (cont_count >= cont_limit - 1)
+    {
+      cont_limit += 32;	/* chunk size */
+      cont_list = (struct cont_elem *) realloc (cont_list, 
+					cont_limit * sizeof (struct cont_elem));
+      if (!cont_list)
+        error ("Virtual memory exhausted\n");
+    }
   /* save state so we can process these stabs later */
   cont_list[cont_count].sym_idx = symbuf_idx;
   cont_list[cont_count].sym_end = symbuf_end;
   cont_list[cont_count].symnum = symnum;
   cont_list[cont_count].sym = sym;
   cont_list[cont_count].stabs = p;
+  cont_list[cont_count].func = f;
   cont_count++;
 }
 
 static void 
-process_now(objfile) 
+process_now (objfile) 
   struct objfile * objfile;
 {
   int i;
@@ -803,14 +819,25 @@ process_now(objfile)
   int save_symbuf_idx = symbuf_idx;
   int save_symbuf_end = symbuf_end;
   int save_symnum = symnum;
+  struct symbol *sym;
+  char *stabs;
+  int err;
+  int (*func) (struct objfile *, struct symbol *, char *);
+
   for (i=0; i<cont_count; i++) 
     {
-      /* set state as if we were parsing stabs strings 
+      /* Set state as if we were parsing stabs strings 
          for this symbol */
       symbuf_idx = cont_list[i].sym_idx;   /* statics used by gdb */
       symbuf_end = cont_list[i].sym_end;  
       symnum = cont_list[i].symnum;  
-      resolve_cfront_continuation(objfile,cont_list[i].sym,cont_list[i].stabs);
+      sym = cont_list[i].sym;
+      stabs = cont_list[i].stabs;
+      func = cont_list[i].func;
+
+      err = (*func) (objfile, sym, stabs);
+      if (err)
+	error ("Internal error: unable to resolve stab.\n");
     }
   /* restore original state */
   symbuf_idx = save_symbuf_idx;
@@ -956,8 +983,6 @@ add_bincl_to_list (pst, name, instance)
       bincl_list = (struct header_file_location *)
 	xmrealloc (pst->objfile->md, (char *)bincl_list,
 		  bincls_allocated * sizeof (struct header_file_location));
-      if (bincl_list == NULL)
-	fatal ("virtual memory exhausted in add_bincl_to_list ();");
       next_bincl = bincl_list + offset;
     }
   next_bincl->pst = pst;
@@ -1782,8 +1807,9 @@ read_ofile_symtab (pst)
 
   pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT);
 
-  if (ARM_DEMANGLING)	/* process incomplete C++ types now */
-    process_now(objfile);
+  /* Process items which we had to "process_later" due to dependancies 
+     on other stabs. */
+  process_now (objfile);	
 
   end_stabs ();
 }
@@ -2337,6 +2363,29 @@ process_one_symbol (type, desc, valu, name, section_offsets, objfile)
       break;
     }
 
+  /* Special GNU C extension for referencing names.  */
+  if (name[0] == '#')
+    {
+      /* Initialize symbol reference names and determine if this is 
+         a definition.  If symbol reference is being defined, go 
+         ahead and add it.  Otherwise, just return sym. */
+      char *s;
+      int refnum;
+      extern int symbol_reference_defined (char **);
+      extern void ref_add (int, struct symbol *, char *, CORE_ADDR);
+      extern struct symbol * ref_search (int);
+
+      /* If defined, store away a pointer to the symbol;
+	 we'll use it later when we resolve references in
+	 "resolve_symbol_reference". */
+      s = name;
+      if (refnum = symbol_reference_defined (&s), refnum)
+	if (!ref_search (refnum))
+	  ref_add (refnum, 0, name, valu);
+      name = s;		/* Advance past refid. */
+    }
+
+
   previous_stab_code = type;
 }
 
diff --git a/gdb/partial-stab.h b/gdb/partial-stab.h
index 970676fa720..c494a07484d 100644
--- a/gdb/partial-stab.h
+++ b/gdb/partial-stab.h
@@ -666,6 +666,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 	    case '8':
 	    case '9':
 	    case '-':
+	    case '#':   /* for symbol identification (used in live ranges) */
 	   /* added to support cfront stabs strings */
 	    case 'Z':	/* for definition continuations */
 	    case 'P':	/* for prototypes */
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index f052a3b5f33..34e4875e48f 100644
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -169,9 +169,24 @@ read_cfront_static_fields PARAMS ((struct field_info *, char**,
 static int
 read_cfront_member_functions PARAMS ((struct field_info *, char **, 
 			struct type *, struct objfile *));
-
 /* end new functions added for cfront support */
 
+static void 
+add_live_range PARAMS ((struct objfile *, struct symbol *, 
+			CORE_ADDR, CORE_ADDR));
+
+static int 
+resolve_live_range PARAMS ((struct objfile *, struct symbol *, char *));
+
+static int 
+process_reference PARAMS ((char **string));
+
+static CORE_ADDR 
+ref_search_value PARAMS ((int refnum));
+
+struct symbol * 
+ref_search PARAMS ((int refnum));
+
 
 
 static const char vptr_name[] = { '_','v','p','t','r',CPLUS_MARKER,'\0' };
@@ -576,7 +591,7 @@ get_cfront_method_physname (fname)
   /* search ahead to find the start of the mangled suffix */
   if (*p == '_' && *(p+1)=='_') /* compiler generated; probably a ctor/dtor */
     p += 2;  		
-  while (p && ((p+1) - fname) < strlen (fname) && *(p+1) != '_')
+  while (p && (unsigned) ((p+1) - fname) < strlen (fname) && *(p+1) != '_')
     p = strchr (p, '_');
   if (!(p && *p == '_' && *(p+1) == '_')) 
     error ("Invalid mangled function name %s",fname);
@@ -710,12 +725,12 @@ read_cfront_baseclasses (fip, pp, type, objfile)
   	    char * bname;		/* base class name */
   	    struct symbol * bsym;	/* base class */
 	    char * p1, * p2;
-	    p1 = strchr(*pp,' ');
-	    p2 = strchr(*pp,';');
+	    p1 = strchr (*pp,' ');
+	    p2 = strchr (*pp,';');
 	    if (p1<p2)
-              bname = get_substring(pp,' ');
+              bname = get_substring (pp,' ');
 	    else
-              bname = get_substring(pp,';');
+              bname = get_substring (pp,';');
             if (!bname || !*bname)
 	      {
 	        complain (&msg_unknown, *pp);
@@ -752,12 +767,12 @@ read_cfront_baseclasses (fip, pp, type, objfile)
 */
 
 static int
-read_cfront_member_functions(fip, pp, type, objfile)
+read_cfront_member_functions (fip, pp, type, objfile)
      struct field_info *fip;
      char **pp;
      struct type *type;
      struct objfile *objfile;
-  {
+{
   /* This code extracted from read_member_functions 
      so as to do the similar thing for our funcs */
 
@@ -778,25 +793,25 @@ read_cfront_member_functions(fip, pp, type, objfile)
   struct next_fnfield *new_sublist;
   char *main_fn_name;
   char * fname;
-  struct symbol * ref_func=0;
+  struct symbol * ref_func = 0;
       
-  /* Process each list until we find something that is not a member function
-     or find the end of the functions. */
+  /* Process each list until we find the end of the member functions.
+     eg: p = "__ct__1AFv foo__1AFv ;;;" */
 
-  /* eg: p = "__ct__1AFv foo__1AFv ;;;" */
   STABS_CONTINUE (pp, objfile); 		/* handle \\ */
-  while (**pp!=';' && (fname = get_substring(pp,' '),fname)) 
+
+  while (**pp != ';' && (fname = get_substring (pp, ' '), fname)) 
     {
-      int is_static=0;
-      int sublist_count=0;
+      int is_static = 0;
+      int sublist_count = 0;
       char * pname;
-      if (fname[0]=='*')      /* static member */
+      if (fname[0] == '*')      /* static member */
         {
           is_static=1;
           sublist_count++;
           fname++;
         }
-      ref_func = lookup_symbol (fname, 0, VAR_NAMESPACE, 0, 0); /*demangled_name*/
+      ref_func = lookup_symbol (fname, 0, VAR_NAMESPACE, 0, 0); /* demangled name */
       if (!ref_func) 
         {
           static struct complaint msg = {"\
@@ -824,129 +839,132 @@ read_cfront_member_functions(fip, pp, type, objfile)
         if (dem != NULL)
           {
             dem_p = strrchr (dem, ':');
-            if (dem_p != 0 && *(dem_p-1)==':')
+            if (dem_p != 0 && *(dem_p-1) == ':')
               dem_p++;
 	    /* get rid of args */
             dem_args = strchr (dem_p, '(');
 	    if (dem_args == NULL)
-	      dem_len = strlen(dem_p);
-	   else
-	      dem_len = dem_args - dem_p;
-           main_fn_name =
+	      dem_len = strlen (dem_p);
+	    else
+      	      dem_len = dem_args - dem_p;
+            main_fn_name =
                    obsavestring (dem_p, dem_len, &objfile -> type_obstack);
-         }
-       else
-         {
-           main_fn_name =
-                   obsavestring (fname, strlen(fname), &objfile -> type_obstack);
-         }
-       } /* end of code for cfront work around */
-
-     new_fnlist -> fn_fieldlist.name = main_fn_name;
+          }
+        else
+          {
+            main_fn_name =
+                   obsavestring (fname, strlen (fname), &objfile -> type_obstack);
+          }
+      } /* end of code for cfront work around */
+
+    new_fnlist -> fn_fieldlist.name = main_fn_name;
       
-     /*-------------------------------------------------*/
-     /* Set up the sublists
-        Sublists are stuff like args, static, visibility, etc.
-        so in ARM, we have to set that info some other way.
-        Multiple sublists happen if overloading
-        eg: foo::26=##1;:;2A.;
-        In g++, we'd loop here thru all the sublists...  */
-     new_sublist =
+    /*-------------------------------------------------*/
+    /* Set up the sublists
+       Sublists are stuff like args, static, visibility, etc.
+       so in ARM, we have to set that info some other way.
+       Multiple sublists happen if overloading
+       eg: foo::26=##1;:;2A.;
+       In g++, we'd loop here thru all the sublists...  */
+
+    new_sublist =
     	(struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
-     make_cleanup (free, new_sublist);
-     memset (new_sublist, 0, sizeof (struct next_fnfield));
+    make_cleanup (free, new_sublist);
+    memset (new_sublist, 0, sizeof (struct next_fnfield));
 	  
-     /* eat 1; from :;2A.; */
-     new_sublist -> fn_field.type = SYMBOL_TYPE(ref_func); /* normally takes a read_type */
-     /* make this type look like a method stub for gdb */
-     TYPE_FLAGS (new_sublist -> fn_field.type) |= TYPE_FLAG_STUB;
-     TYPE_CODE (new_sublist -> fn_field.type) = TYPE_CODE_METHOD;
-
-     /* If this is just a stub, then we don't have the real name here. */
-     if (TYPE_FLAGS (new_sublist -> fn_field.type) & TYPE_FLAG_STUB)
-       {
-         if (!TYPE_DOMAIN_TYPE (new_sublist -> fn_field.type))
-         TYPE_DOMAIN_TYPE (new_sublist -> fn_field.type) = type;
-         new_sublist -> fn_field.is_stub = 1;
-       }
-     /* physname used later in mangling; eg PFs_i,5 for foo__1aFPFs_i 
-        physname gets strcat'd in order to recreate the onto mangled name */
-     pname = get_cfront_method_physname(fname);
-        new_sublist -> fn_field.physname = savestring (pname, strlen(pname));
-       
+    /* eat 1; from :;2A.; */
+    new_sublist -> fn_field.type = SYMBOL_TYPE(ref_func); /* normally takes a read_type */
+    /* Make this type look like a method stub for gdb */
+    TYPE_FLAGS (new_sublist -> fn_field.type) |= TYPE_FLAG_STUB;
+    TYPE_CODE (new_sublist -> fn_field.type) = TYPE_CODE_METHOD;
+
+    /* If this is just a stub, then we don't have the real name here. */
+    if (TYPE_FLAGS (new_sublist -> fn_field.type) & TYPE_FLAG_STUB)
+      {
+        if (!TYPE_DOMAIN_TYPE (new_sublist -> fn_field.type))
+        TYPE_DOMAIN_TYPE (new_sublist -> fn_field.type) = type;
+        new_sublist -> fn_field.is_stub = 1;
+      }
+
+    /* physname used later in mangling; eg PFs_i,5 for foo__1aFPFs_i 
+       physname gets strcat'd in order to recreate the onto mangled name */
+    pname = get_cfront_method_physname (fname);
+    new_sublist -> fn_field.physname = savestring (pname, strlen (pname));
+      
 
-     /* Set this member function's visibility fields. 
-        Unable to distinguish access from stabs definition!
-          Assuming public for now.  FIXME!
-	  (for private, set new_sublist->fn_field.is_private = 1,
-	  for public, set new_sublist->fn_field.is_protected = 1) */
+    /* Set this member function's visibility fields. 
+       Unable to distinguish access from stabs definition!
+         Assuming public for now.  FIXME!
+	 (for private, set new_sublist->fn_field.is_private = 1,
+	 for public, set new_sublist->fn_field.is_protected = 1) */
        
-     /* Unable to distinguish const/volatile from stabs definition!
-        Assuming normal for now.  FIXME! */
+    /* Unable to distinguish const/volatile from stabs definition!
+       Assuming normal for now.  FIXME! */
 
-     new_sublist -> fn_field.is_const = 0;
-     new_sublist -> fn_field.is_volatile = 0;	/* volatile not implemented in cfront */
+    new_sublist -> fn_field.is_const = 0;
+    new_sublist -> fn_field.is_volatile = 0;	/* volatile not implemented in cfront */
 	  
-     /* set virtual/static function info
-        How to get vtable offsets ? 
-        Assuming normal for now FIXME!! 
-          For vtables, figure out from whence this virtual function came.
-	    It may belong to virtual function table of
-	    one of its baseclasses.
-	  set:
-	    new_sublist -> fn_field.voffset = vtable offset,
-	    new_sublist -> fn_field.fcontext = look_ahead_type;
-	    where look_ahead_type is type of baseclass */
-      if (is_static)
-        new_sublist -> fn_field.voffset = VOFFSET_STATIC;
-      else /* normal member function.  */
-        new_sublist -> fn_field.voffset = 0;
-      new_sublist -> fn_field.fcontext = 0;
+    /* Set virtual/static function info
+       How to get vtable offsets ? 
+       Assuming normal for now FIXME!! 
+       For vtables, figure out from whence this virtual function came.
+       It may belong to virtual function table of
+       one of its baseclasses.
+	 set:
+	   new_sublist -> fn_field.voffset = vtable offset,
+	   new_sublist -> fn_field.fcontext = look_ahead_type;
+	   where look_ahead_type is type of baseclass */
+    if (is_static)
+      new_sublist -> fn_field.voffset = VOFFSET_STATIC;
+    else 				/* normal member function.  */
+      new_sublist -> fn_field.voffset = 0;
+    new_sublist -> fn_field.fcontext = 0;
  
 
-      /* prepare new sublist */
-	new_sublist -> next = sublist;
-	sublist = new_sublist;
-	length++;
-        /* In g++, we loop thu sublists - now we set from function */
-
-        new_fnlist -> fn_fieldlist.fn_fields = (struct fn_field *)
-	    obstack_alloc (&objfile -> type_obstack, 
-		       sizeof (struct fn_field) * length);
-        memset (new_fnlist -> fn_fieldlist.fn_fields, 0,
-	      sizeof (struct fn_field) * length);
-        for (i = length; (i--, sublist); sublist = sublist -> next)
-	  {
-	    new_fnlist -> fn_fieldlist.fn_fields[i] = sublist -> fn_field;
-	  }
-      
-        new_fnlist -> fn_fieldlist.length = length;
-        new_fnlist -> next = fip -> fnlist;
-        fip -> fnlist = new_fnlist;
-        nfn_fields++;
-        total_length += length;
-        STABS_CONTINUE (pp, objfile); /* handle \\ */
-      } /* end of loop */
-
-    if (nfn_fields)
+    /* Prepare new sublist */
+    new_sublist -> next = sublist;
+    sublist = new_sublist;
+    length++;
+
+    /* In g++, we loop thu sublists - now we set from functions. */
+    new_fnlist -> fn_fieldlist.fn_fields = (struct fn_field *)
+         obstack_alloc (&objfile -> type_obstack, 
+     	       sizeof (struct fn_field) * length);
+    memset (new_fnlist -> fn_fieldlist.fn_fields, 0,
+           sizeof (struct fn_field) * length);
+    for (i = length; (i--, sublist); sublist = sublist -> next)
       {
-        /* type should already have space */
-        TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
-        TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
-        memset (TYPE_FN_FIELDLISTS (type), 0,
-     		sizeof (struct fn_fieldlist) * nfn_fields);
-        TYPE_NFN_FIELDS (type) = nfn_fields;
-        TYPE_NFN_FIELDS_TOTAL (type) = total_length;
+        new_fnlist -> fn_fieldlist.fn_fields[i] = sublist -> fn_field;
       }
+      
+    new_fnlist -> fn_fieldlist.length = length;
+    new_fnlist -> next = fip -> fnlist;
+    fip -> fnlist = new_fnlist;
+    nfn_fields++;
+    total_length += length;
+    STABS_CONTINUE (pp, objfile); /* handle \\ */
+  } /* end of loop */
 
-      /* end of scope for reading member func */
+  if (nfn_fields)
+    {
+      /* type should already have space */
+      TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
+      TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
+      memset (TYPE_FN_FIELDLISTS (type), 0,
+         	sizeof (struct fn_fieldlist) * nfn_fields);
+      TYPE_NFN_FIELDS (type) = nfn_fields;
+      TYPE_NFN_FIELDS_TOTAL (type) = total_length;
+    }
 
-    /* eg: ";;" */
-    /* skip trailing ';' and bump count of number of fields seen */
-    if (**pp == ';')
-      (*pp)++;
-    else
-      return 0;
+  /* end of scope for reading member func */
+
+  /* eg: ";;" */
+
+  /* Skip trailing ';' and bump count of number of fields seen */
+  if (**pp == ';')
+    (*pp)++;
+  else
+    return 0;
   return 1;
 }
 
@@ -954,8 +972,8 @@ read_cfront_member_functions(fip, pp, type, objfile)
    while parsing the stabs.  The main need for this function is
    to add information such as methods to classes.
    Examples of "p": "sA;;__ct__1AFv foo__1AFv ;;;" */
-void 
-resolve_cfront_continuation(objfile, sym, p)
+int
+resolve_cfront_continuation (objfile, sym, p)
   struct objfile * objfile;
   struct symbol * sym;
   char * p;
@@ -967,13 +985,13 @@ resolve_cfront_continuation(objfile, sym, p)
   struct type *type;
   struct cleanup *back_to;
 
-  /* need to make sure that fi isn't gunna conflict with struct 
+  /* Need to make sure that fi isn't gunna conflict with struct 
      in case struct already had some fnfs */
   fi.list = NULL;
   fi.fnlist = NULL;       
   back_to = make_cleanup (null_cleanup, 0);
 
-  /* we only accept structs, classes and unions at the moment. 
+  /* We only accept structs, classes and unions at the moment. 
      Other continuation types include t (typedef), r (long dbl), ... 
      We may want to add support for them as well; 
      right now they are handled by duplicating the symbol information 
@@ -981,20 +999,19 @@ resolve_cfront_continuation(objfile, sym, p)
   if (*p != 's'       /* structs */
     && *p != 'c'      /* class */
     && *p != 'u')     /* union */
-    return;  /* only handle C++ types */
+    return 0;  /* only handle C++ types */
   p++;  
 
-  /* get symbol typs name and validate 
+  /* Get symbol typs name and validate 
      eg: p = "A;;__ct__1AFv foo__1AFv ;;;" */
-  sname = get_substring(&p,';');
-  if (!sname || strcmp(sname,SYMBOL_NAME(sym)))
-    error("Internal error: base symbol type name does not match\n");
+  sname = get_substring (&p, ';');
+  if (!sname || strcmp (sname, SYMBOL_NAME(sym)))
+    error ("Internal error: base symbol type name does not match\n");
 
-  /* find symbol's internal gdb reference */
-  ref_sym = lookup_symbol (SYMBOL_NAME(sym), 0, STRUCT_NAMESPACE, 0, 0); /*demangled_name*/
-  /* This is the real sym that we want; 
+  /* Find symbol's internal gdb reference using demangled_name.
+     This is the real sym that we want; 
      sym was a temp hack to make debugger happy */
-  /* ref_sym should already have space */
+  ref_sym = lookup_symbol (SYMBOL_NAME(sym), 0, STRUCT_NAMESPACE, 0, 0); 
   type = SYMBOL_TYPE(ref_sym);
 
 
@@ -1008,7 +1025,7 @@ resolve_cfront_continuation(objfile, sym, p)
 	    || !read_struct_fields (&fi, &p, type, objfile) */
       || !copy_cfront_struct_fields (&fi, type, objfile)
       || !read_cfront_member_functions (&fi, &p, type, objfile)
-      || !read_cfront_static_fields(&fi, &p, type, objfile)
+      || !read_cfront_static_fields (&fi, &p, type, objfile)
       || !attach_fields_to_type (&fi, type, objfile)
       || !attach_fn_fields_to_type (&fi, type)
       /* g++ does this next, but cfront doesn't seem to have this: 
@@ -1019,10 +1036,239 @@ resolve_cfront_continuation(objfile, sym, p)
     }
 
   do_cleanups (back_to);
+  return 0;  
 }
 /* End of code added to support parsing of ARM/Cfront stabs strings */
 
 
+/* This routine fixes up symbol references to point to the original
+   symbol definition.
+   The main need for this function is to add information for supporting 
+   live range splitting.
+   eg: p : "#7=", "#2=z:r(0,1)" "#2:r(0,1);l(#5,#6),l(#7,#4)" */
+int
+resolve_symbol_reference (objfile, sym, p)
+  struct objfile * objfile;
+  struct symbol * sym;
+  char * p;
+{
+  int refnum;
+  struct symbol * ref_sym=0;
+  struct cleanup *back_to;
+
+  back_to = make_cleanup (null_cleanup, 0);
+
+  if (*p != '#')       /* symbol ref id */
+    return 0;  
+
+  /* Use "#<num>" as the name; we'll fix the name later.
+     We stored the original symbol name as "#<id>=<name>"
+     so we can now search for "#<id>" to resolving the reference.
+     We'll fix the names later by removing the "#<id>" or "#<id>=" */
+
+  /*---------------------------------------------------------*/
+  /* Get the reference id number, and 
+     advance p past the names so we can parse the rest. 
+       eg: id=2 for p : "2=", "2=z:r(0,1)" "2:r(0,1);l(#5,#6),l(#7,#4)" */
+  /*---------------------------------------------------------*/
+
+  /* This gets reference name from string.  sym may not have a name. */
+  refnum = process_reference (&p);
+  ref_sym = ref_search (refnum);
+  if (!ref_sym)
+    error ("error: symbol for reference not found.\n");
+
+  /* Parse the stab of the referencing symbol
+     now that we have the referenced symbol.
+     Add it as a new symbol and a link back to the referenced symbol.
+     eg: p : "=", "=z:r(0,1)" ":r(0,1);l(#5,#6),l(#7,#4)" */
+
+
+  /* If the stab symbol table and string contain:
+         RSYM   0      5      00000000 868    #15=z:r(0,1)
+         LBRAC  0      0      00000000 899    #5=
+         SLINE  0      16     00000003 923    #6=
+     Then the same symbols can be later referenced by:
+         RSYM   0      5      00000000 927    #15:r(0,1);l(#5,#6)
+     This is used in live range splitting to:
+     1) specify that a symbol (#15) is actually just a new storage 
+        class for a symbol (#15=z) which was previously defined.
+     2) specify that the beginning and ending ranges for a symbol 
+        (#15) are the values of the beginning (#5) and ending (#6) 
+        symbols. */
+       
+   /* Read number as reference id.
+      eg: p : "=", "=z:r(0,1)" ":r(0,1);l(#5,#6),l(#7,#4)" */
+   /* FIXME! Might I want to use SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
+      in case of "l(0,0)"? */
+
+   /*--------------------------------------------------*/
+   /* Add this symbol to the reference list.           */
+   /*--------------------------------------------------*/
+   SYMBOL_ALIASES (sym) = SYMBOL_ALIASES (ref_sym);
+   SYMBOL_ALIASES (ref_sym) = sym;
+
+   /* Want to fix up name so that other functions (eg. valops)
+      will correctly print the name.
+      Don't add_symbol_to_list so that lookup_symbol won't find it.
+      nope... needed for fixups. */
+   SYMBOL_NAME (sym) = SYMBOL_NAME (ref_sym);
+
+  /* Done!  */
+
+  do_cleanups (back_to);
+  return 0;  
+}
+
+/* Get range symbol reference. eg. "#2),l(#3,#5)"   
+   postpone resolve_reference until after we're done reading symbols. */
+struct symbol *
+resolve_reference (char *p)
+{
+    char sym_refid[32];
+    struct symbol *sym = 0;
+    char *s = p;
+    int len;
+
+    if (!s || *s != '#')
+      return 0;
+    p = strchr (s, ')');
+    if (!p || p == s)
+      return 0;
+    len = p - s + 1;
+    strncpy (sym_refid, s, len);
+    sym_refid[len] = '\0';
+    sym = lookup_symbol (sym_refid, 0, VAR_NAMESPACE, 0, 0); 
+    return sym;
+}
+
+/* Structure for storing pointers to reference definitions for fast lookup 
+   during "process_later". */
+#define MAX_REFS 100	/* FIXME!  Change to use heap. */
+static struct ref_map_s
+{
+  char *stabs;
+  CORE_ADDR value;
+  struct symbol *sym;
+} ref_map[MAX_REFS];	
+
+/* Initialize our list of references.
+   This should be called before any symbol table is read.
+   FIXME: Will reference numbers be unique only to objects?  If so, we may 
+   need to add something to disambiguate the refids.  Or, it might be OK to 
+   leave as is, as long as we read and process an object's symbol table all 
+   at once.  */
+static int ref_count = 0;	/* Ptr to free cell in linked list. */
+static void ref_init ()
+{
+  ref_count = 0;
+  memset (ref_map, 0, MAX_REFS * sizeof (struct ref_map_s));
+}
+
+/* Create array of pointers mapping refids to symbols and stab strings.
+   Add pointers to reference definition symbols and/or their values as we 
+   find them, using their reference numbers as our index. 
+   These will be used later when we resolve references. */
+void ref_add (int refnum, struct symbol *sym, char *stabs, CORE_ADDR value)
+{
+  if (ref_count == 0)
+    ref_init ();
+  if (refnum >= ref_count)
+    ref_count = refnum + 1;
+  if (ref_count > MAX_REFS)
+    error ("no more free slots in chain\n");
+  ref_map[refnum].stabs = stabs;
+  ref_map[refnum].sym = sym;
+  ref_map[refnum].value = value;
+}
+
+/* Remove reference at refnum. 
+   This should be called before a new symbol table is read to clear out the 
+   previous symbol's reference information. */
+/* FIXME!  not used at the moment. */
+static void ref_rmv (int refnum)
+{
+  if (ref_count < 0)
+    error ("slots are empty\n");
+  if (refnum < 0 || refnum > ref_count)
+    error ("No reference for refnum.\n");
+  /* Copy last element over the removed element and reduce count. */
+  ref_map[refnum].stabs = ref_map[ref_count].stabs;
+  ref_map[refnum].sym = ref_map[ref_count].sym;
+  --ref_count;
+}
+
+/* Return defined sym for the reference "refnum" */
+struct symbol *
+ref_search (int refnum)
+{
+  if (refnum < 0 || refnum > ref_count)
+    return 0;
+  return ref_map[refnum].sym;
+}
+
+/* Return value for the reference "refnum" */
+CORE_ADDR
+ref_search_value (int refnum)
+{
+  if (refnum < 0 || refnum > ref_count)
+    return 0;
+  return ref_map[refnum].value;
+}
+   
+/* Parse reference id and advance string to the next character following
+   the string. 
+   Return the reference number. */
+
+static int 
+process_reference (char **string)
+{
+  char *p;
+  int refnum = 0;
+
+  if (**string != '#') 
+    return 0;	
+     
+  /* Read number as reference id. */
+  p = *string + 1;	/* Advance beyond '#' */
+  while (*p && isdigit (*p))
+    {
+      refnum = refnum * 10 + *p - '0';
+      p++;
+    }
+  *string = p;
+  return refnum;
+}
+
+/* If string defines a reference, store away a pointer to the reference 
+   definition for fast lookup when we "process_later",
+   and return the reference number. */
+int
+symbol_reference_defined (char **string)
+{
+  char *p = *string;
+  int refnum = 0;
+
+  refnum = process_reference (&p);
+
+  /* Defining symbols end in '=' */
+  if (*p == '=') 
+    {
+      /* Symbol is being defined here. */ 
+
+      *string = p + 1;
+      return refnum;
+    }
+  else
+    {
+      /* Must be a reference.   Either the symbol has already been defined,
+         or this is a forward reference to it.  */
+
+      *string = p;
+      return 0;        /* Not defined here */
+    }
+}
+
 /* ARGSUSED */
 struct symbol *
 define_symbol (valu, string, desc, type, objfile)
@@ -1056,7 +1302,7 @@ define_symbol (valu, string, desc, type, objfile)
   while (p[1] == ':')
     {
        p += 2;
-       p = strchr(p, ':');
+       p = strchr (p, ':');
     }
 
   /* If a nameless stab entry, all we need is the type, not the symbol.
@@ -1125,6 +1371,45 @@ define_symbol (valu, string, desc, type, objfile)
 	    goto normal;		/* Do *something* with it */
 	}
     }
+  else if (string[0] == '#')
+    {
+      /* Special GNU C extension for referencing symbols.  */
+      char *s;
+      int refnum, nlen;
+
+      /* Initialize symbol references and determine if this is 
+         a definition.  If symbol reference is being defined, go 
+         ahead and add it.  Otherwise, just return sym. */
+      s = string;
+      if (refnum = symbol_reference_defined (&s), refnum)
+        ref_add (refnum, sym, string, SYMBOL_VALUE (sym));
+      else
+        process_later (sym, string, resolve_symbol_reference);
+
+      /* s is after refid... advance string there
+         so that the symbol name will not include the refid. */
+      nlen = p - s;
+      if (nlen > 0)
+        {
+          SYMBOL_NAME (sym) = (char *)
+    	    obstack_alloc (&objfile -> symbol_obstack, nlen);
+          strncpy (SYMBOL_NAME (sym), s, nlen);
+          SYMBOL_NAME (sym)[nlen] = '\0';
+          SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
+        }
+      else
+        /* FIXME! Want SYMBOL_NAME (sym) = 0;
+	   Get error if leave name 0.  So give it something. */
+        {
+          nlen = p - string;
+          SYMBOL_NAME (sym)	= (char *)
+    	    obstack_alloc (&objfile -> symbol_obstack, nlen);
+          strncpy (SYMBOL_NAME (sym), string, nlen);
+          SYMBOL_NAME (sym)[nlen] = '\0';
+          SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
+        }
+      string = s;
+    }
   else
     {
     normal:
@@ -1332,11 +1617,18 @@ define_symbol (valu, string, desc, type, objfile)
 	 corresponding linker definition to find the value.
 	 These definitions appear at the end of the namelist.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
-      i = hashname (SYMBOL_NAME (sym));
-      SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
-      global_sym_chain[i] = sym;
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      /* Don't add symbol references to global_sym_chain.
+	 Symbol references don't have valid names and wont't match up with
+	 minimal symbols when the global_sym_chain is relocated.
+	 We'll fixup symbol references when we fixup the defining symbol.  */
+      if (SYMBOL_NAME (sym) && SYMBOL_NAME (sym)[0] != '#')
+	{
+          i = hashname (SYMBOL_NAME (sym));
+          SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
+          global_sym_chain[i] = sym;
+	}
       add_symbol_to_list (sym, &global_symbols);
       break;
 
@@ -1741,29 +2033,30 @@ define_symbol (valu, string, desc, type, objfile)
       add_symbol_to_list (sym, &local_symbols);
       break;
 
-    /* New code added to support cfront stabs strings */
-    /* Note: case 'P' already handled above */
+    /* New code added to support cfront stabs strings.
+       Note: case 'P' already handled above */
     case 'Z':
       /* Cfront type continuation coming up!
-	find the original definition and add to it.
-	We'll have to do this for the typedef too,
-	since we clloned the symbol to define a type in read_type.
-	Stabs info examples:
-	__1C :Ztl 
-	foo__1CFv :ZtF (first def foo__1CFv:F(0,3);(0,24))
-	C:ZsC;;__ct__1CFv func1__1CFv func2__1CFv ... ;;;
-	where C is the name of the class. */
-	/* can't lookup symbol yet 'cuz symbols not read yet
-	   so we save it for processing later */
-	process_later(sym,p);
+	 Find the original definition and add to it.
+	 We'll have to do this for the typedef too,
+	 since we cloned the symbol to define a type in read_type.
+	 Stabs info examples:
+		 __1C :Ztl 
+		 foo__1CFv :ZtF (first def foo__1CFv:F(0,3);(0,24))
+		 C:ZsC;;__ct__1CFv func1__1CFv func2__1CFv ... ;;;
+		 where C is the name of the class.
+	 Unfortunately, we can't lookup the original symbol yet 'cuz 
+	 we haven't finished reading all the symbols.
+	 Instead, we save it for processing later */
+      process_later (sym, p, resolve_cfront_continuation);
       SYMBOL_TYPE (sym) = error_type (&p, objfile); /* FIXME! change later */ 
-	SYMBOL_CLASS (sym) = LOC_CONST; 
-	SYMBOL_VALUE (sym) = 0; 
-	SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-	/* don't add to list - we'll delete it later when 
-           we add the continuation to the real sym */
-	return sym;
-    /* End of new code added to support cfront stabs strings */
+      SYMBOL_CLASS (sym) = LOC_CONST; 
+      SYMBOL_VALUE (sym) = 0; 
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      /* Don't add to list - we'll delete it later when 
+         we add the continuation to the real sym */
+      return sym;
+      /* End of new code added to support cfront stabs strings */
 
     default:
       SYMBOL_TYPE (sym) = error_type (&p, objfile);
@@ -1798,9 +2091,129 @@ define_symbol (valu, string, desc, type, objfile)
 	}
     }
 
+  /* Is there more to parse?  eg. ";l(#1,#2);l(#3,#5)" */
+  while (*p && (*p == ';' || *p == ','))
+    {
+      p++;
+      if (*p && *p == 'l')
+        {
+          /* GNU extensions for live range splitting may be appended to 
+             the end of the stab string.  eg. "l(#1,#2);l(#3,#5)" */
+
+          /* Fix up ranges later. */
+          process_later (sym, p, resolve_live_range);
+
+	  /* Find end of live range info. */
+	  p = strchr (p, ')');
+          if (!*p || *p != ')')
+            error ("Internal error: live range format not recognized.\n");
+          p++;
+       }
+    }
   return sym;
 }
 
+
+/* Add live range information to symbol. (eg. p is l(#1,#2)...) */
+static int 
+resolve_live_range (objfile, sym, p)
+  struct objfile * objfile;
+  struct symbol *sym;
+  char *p;
+{
+  char *s=p;
+  int refnum;
+  CORE_ADDR start, end;
+  
+  if (!*p || *p != 'l')
+    error ("Internal error: live range string.\n");
+  p++;
+
+  if (!*p || *p != '(')
+    error ("Internal error: live range string.\n");
+  p++;
+	
+  /* Get starting value of range symbol reference. eg. "#1,#2),l(#3,#5)"
+     and advance p past the refid. */
+  refnum = process_reference (&p);
+  start = ref_search_value (refnum);
+  if (!start)
+    error ("Internal error: live range symbol not found.\n");
+
+  if (!*p || *p != ',')
+    error ("Internal error: live range string.\n");
+  p++;
+
+  /* Get ending value of range symbol reference. eg. "#2),l(#3,#5)" */
+  refnum = process_reference (&p);
+  end = ref_search_value (refnum);
+  if (!end)
+    error ("Internal error: live range symbol not found.\n");
+
+  add_live_range (objfile, sym, start, end);
+
+  if (!*p || *p != ')')
+    error ("Internal error: live range string.\n");
+  p++;
+  return 0; 
+}
+
+void
+add_live_range (objfile, sym, start, end)
+  struct objfile *objfile;
+  struct symbol *sym;
+  CORE_ADDR start, end;
+{
+  struct live_range *r, *rs;
+
+  if (start >= end)
+    error ("Internal error: end of live range follows start.\n");
+
+  /* Alloc new live range structure. */
+  r = (struct live_range *)
+		obstack_alloc (&objfile->type_obstack, 
+				sizeof (struct live_range));
+  r->start = start;
+  r->end = end;
+  r->next = 0;
+
+  /* Append this range to the symbol's range list. */
+  if (!SYMBOL_RANGE (sym))
+    {
+      SYMBOL_RANGE (sym) = r;
+    }
+  else
+    {
+      /* Get the last range for the symbol. */
+      for (rs = SYMBOL_RANGE (sym); rs->next; rs = rs->next)
+	;
+      rs->next = r;
+    }
+}
+
+/* Given addr, Search thu alias list to find the one active. */
+struct symbol *
+ref_search_val (sym, addr)
+  struct symbol *sym;
+  CORE_ADDR addr;
+{
+  struct live_range *r;
+
+  while (sym)
+    {
+      if (!SYMBOL_RANGE (sym))
+        return sym;
+      for (r = SYMBOL_RANGE (sym); r; r = r->next)
+	{
+	  if (r->start <= addr
+		    && r->end > addr)
+	    return sym;
+	}
+      sym = SYMBOL_ALIASES (sym);
+    }
+  return 0;
+}
+
 
 /* Skip rest of this symbol and return an error type.
 
@@ -1953,8 +2366,8 @@ read_type (pp, objfile)
 	      }
 	    }
 	   
-	  q1 = strchr(*pp, '<');
-	  p = strchr(*pp, ':');
+	  q1 = strchr (*pp, '<');
+	  p = strchr (*pp, ':');
 	  if (p == NULL)
 	    return error_type (pp, objfile);
 	  if (q1 && p > q1 && p[1] == ':')
@@ -2094,7 +2507,7 @@ read_type (pp, objfile)
 	  ++*pp;
 	  while (**pp != ')')
             {
-              t = read_type(pp, objfile);
+              t = read_type (pp, objfile);
               if (**pp == ',') ++*pp;
             }
 	}
@@ -2876,7 +3289,7 @@ read_one_struct_field (fip, pp, p, type, objfile)
           if (dem_p != 0 && *(dem_p-1)==':')
             dem_p++;
           FIELD_NAME (fip->list->field) =
-            obsavestring (dem_p, strlen(dem_p), &objfile -> type_obstack);
+            obsavestring (dem_p, strlen (dem_p), &objfile -> type_obstack);
         }
       else
         {
@@ -3350,7 +3763,7 @@ attach_fn_fields_to_type (fip, type)
    */
 
 static int
-read_cfront_static_fields(fip, pp, type, objfile)
+read_cfront_static_fields (fip, pp, type, objfile)
      struct field_info *fip;
      char **pp;
      struct type *type;
@@ -3371,7 +3784,7 @@ read_cfront_static_fields(fip, pp, type, objfile)
 
   /* eg: p = "as__1A ;;;" */
   STABS_CONTINUE (pp, objfile); 		/* handle \\ */
-  while (**pp!=';' && (sname = get_substring(pp,' '),sname)) 
+  while (**pp!=';' && (sname = get_substring (pp, ' '), sname)) 
     {
       ref_static = lookup_symbol (sname, 0, VAR_NAMESPACE, 0, 0); /*demangled_name*/
       if (!ref_static) 
@@ -3399,7 +3812,7 @@ read_cfront_static_fields(fip, pp, type, objfile)
       fip -> list -> field.type = stype; 
 
       /* set bitpos & bitsize */
-      SET_FIELD_PHYSNAME (fip->list->field, savestring (sname, strlen(sname)));
+      SET_FIELD_PHYSNAME (fip->list->field, savestring (sname, strlen (sname)));
 
       /* set name field */
       /* The following is code to work around cfront generated stabs.
@@ -3416,12 +3829,12 @@ read_cfront_static_fields(fip, pp, type, objfile)
               if (dem_p != 0 && *(dem_p-1)==':')
                 dem_p++;
               fip->list->field.name =
-                obsavestring (dem_p, strlen(dem_p), &objfile -> type_obstack);
+                obsavestring (dem_p, strlen (dem_p), &objfile -> type_obstack);
             }
           else
             {
               fip->list->field.name =
-                obsavestring (sname, strlen(sname), &objfile -> type_obstack); 
+                obsavestring (sname, strlen (sname), &objfile -> type_obstack); 
 	    }
         } /* end of code for cfront work around */ 
     } /* loop again for next static field */
@@ -3435,7 +3848,7 @@ read_cfront_static_fields(fip, pp, type, objfile)
    once we have collected all the class members. */
 
 static int
-copy_cfront_struct_fields(fip, type, objfile)
+copy_cfront_struct_fields (fip, type, objfile)
      struct field_info *fip;
      struct type *type;
      struct objfile *objfile;
@@ -4489,7 +4902,7 @@ scan_file_globals (objfile)
 {
   int hash;
   struct minimal_symbol *msymbol;
-  struct symbol *sym, *prev;
+  struct symbol *sym, *prev, *rsym;
   struct objfile *resolve_objfile;
 
   /* SVR4 based linkers copy referenced global symbols from shared
@@ -4558,17 +4971,25 @@ scan_file_globals (objfile)
 		  /* Note: this code might be executed several times for
 		     the same symbol if there are multiple references.  */
 
-		  if (SYMBOL_CLASS (sym) == LOC_BLOCK)
+		  /* If symbol has aliases, do minimal symbol fixups for each.
+		     These live aliases/references weren't added to 
+		     global_sym_chain hash but may also need to be fixed up. */
+		  /* FIXME: Maybe should have added aliases to the global chain,		     resolved symbol name, then treated aliases as normal 
+		     symbols?  Still, we wouldn't want to add_to_list. */
+		  /* Now do the same for each alias of this symbol */
+		  for (rsym = sym; rsym; rsym = SYMBOL_ALIASES (rsym))
 		    {
-		      fix_common_block (sym, SYMBOL_VALUE_ADDRESS (msymbol));
+		      if (SYMBOL_CLASS (rsym) == LOC_BLOCK)
+		        {
+		          fix_common_block (rsym, SYMBOL_VALUE_ADDRESS (msymbol));
+		        }
+		      else
+		        {
+		          SYMBOL_VALUE_ADDRESS (rsym)
+			    = SYMBOL_VALUE_ADDRESS (msymbol);
+		        }
+		      SYMBOL_SECTION (rsym) = SYMBOL_SECTION (msymbol);
 		    }
-		  else
-		    {
-		      SYMBOL_VALUE_ADDRESS (sym)
-			= SYMBOL_VALUE_ADDRESS (msymbol);
-		    }
-
-		  SYMBOL_SECTION (sym) = SYMBOL_SECTION (msymbol);
 		  
 		  if (prev)
 		    {
diff --git a/gdb/stabsread.h b/gdb/stabsread.h
index c08635f711b..dcaa6da3b43 100644
--- a/gdb/stabsread.h
+++ b/gdb/stabsread.h
@@ -168,7 +168,7 @@ end_stabs PARAMS ((void));
 extern void
 finish_global_stabs PARAMS ((struct objfile *objfile));
 
-extern void 
+extern int
 resolve_cfront_continuation PARAMS((struct objfile * objfile, 
 		struct symbol * sym, char * p));
 
@@ -236,6 +236,7 @@ extern void stabsect_build_psymtabs
 extern void elfstab_offset_sections PARAMS ((struct objfile *,
 					     struct partial_symtab *));
 
-extern void process_later PARAMS ((struct symbol *, char *));
+extern void process_later PARAMS ((struct symbol *, char *, 
+		int (*f) (struct objfile *, struct symbol *, char *)));
 
 #undef EXTERN
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 7edd1a6d567..9ae6442247c 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -912,6 +912,7 @@ lookup_block_symbol (block, name, namespace)
      const char *name;
      const namespace_enum namespace;
 {
+  extern struct symbol *ref_search_val (struct symbol *sym, CORE_ADDR addr);
   register int bot, top, inc;
   register struct symbol *sym;
   register struct symbol *sym_found = NULL;
@@ -1017,6 +1018,10 @@ lookup_block_symbol (block, name, namespace)
 	  if (SYMBOL_NAMESPACE (sym) == namespace &&
 	      SYMBOL_MATCHES_NAME (sym, name))
 	    {
+	      /* Given pc, search thu alias list to find the active symbol. */
+              if (SYMBOL_ALIASES (sym))
+                sym = ref_search_val (sym, read_pc ());
+
 	      sym_found = sym;
 	      if (SYMBOL_CLASS (sym) != LOC_ARG &&
 		  SYMBOL_CLASS (sym) != LOC_LOCAL_ARG &&
@@ -2080,15 +2085,25 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
 	}
       if (p[0] == ':' || p[0] == ' ' || p[0] == '\t')
 	break;
+      if (p[0] == '.' && strchr (p, ':') == NULL) /* Java qualified method. */
+	{
+	  /* Find the *last* '.', since the others are package qualifiers. */
+	  for (p1 = p;  *p1;  p1++)
+	    {
+	      if (*p1 == '.')
+		p = p1;
+	    }
+	  break;
+	}
     }
   while (p[0] == ' ' || p[0] == '\t') p++;
 
-  if ((p[0] == ':') && !has_parens)
+  if ((p[0] == ':' || p[0] == '.') && !has_parens)
     {
 
-      /*  C++  */
+      /*  C++ or Java */
       if (is_quoted) *argptr = *argptr+1;
-      if (p[1] ==':')
+      if (p[0] == '.' || p[1] ==':')
 	{
 	  /* Extract the class name.  */
 	  p1 = p;
@@ -2098,7 +2113,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
 	  copy[p - *argptr] = 0;
 
 	  /* Discard the class name from the arg.  */
-	  p = p1 + 2;
+	  p = p1 + (p1[0] == ':' ? 2 : 1);
 	  while (*p == ' ' || *p == '\t') p++;
 	  *argptr = p;
 
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 83c2377d340..4bf17d73411 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -84,7 +84,7 @@ struct general_symbol_info
 
   union
     {
-      struct cplus_specific      /* For C++ */
+      struct cplus_specific      /* For C++ and Java */
 	{
 	  char *demangled_name;
 	} cplus_specific;
@@ -135,7 +135,8 @@ extern CORE_ADDR symbol_overlayed_address PARAMS((CORE_ADDR, asection *));
 #define SYMBOL_INIT_LANGUAGE_SPECIFIC(symbol,language)			\
   do {									\
     SYMBOL_LANGUAGE (symbol) = language;				\
-    if (SYMBOL_LANGUAGE (symbol) == language_cplus)			\
+    if (SYMBOL_LANGUAGE (symbol) == language_cplus			\
+	|| SYMBOL_LANGUAGE (symbol) == language_java)			\
       {									\
 	SYMBOL_CPLUS_DEMANGLED_NAME (symbol) = NULL;			\
       }									\
@@ -179,6 +180,23 @@ extern CORE_ADDR symbol_overlayed_address PARAMS((CORE_ADDR, asection *));
 	    SYMBOL_CPLUS_DEMANGLED_NAME (symbol) = NULL;		\
 	  }								\
       }									\
+    if (SYMBOL_LANGUAGE (symbol) == language_java)			\
+      {									\
+	demangled =							\
+	  cplus_demangle (SYMBOL_NAME (symbol),				\
+			  DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);		\
+	if (demangled != NULL)						\
+	  {								\
+	    SYMBOL_LANGUAGE (symbol) = language_java;			\
+	    SYMBOL_CPLUS_DEMANGLED_NAME (symbol) = 			\
+	      obsavestring (demangled, strlen (demangled), (obstack));	\
+	    free (demangled);						\
+	  }								\
+	else								\
+	  {								\
+	    SYMBOL_CPLUS_DEMANGLED_NAME (symbol) = NULL;		\
+	  }								\
+      }									\
     if (demangled == NULL						\
 	&& (SYMBOL_LANGUAGE (symbol) == language_chill			\
 	    || SYMBOL_LANGUAGE (symbol) == language_auto))		\
@@ -208,6 +226,7 @@ extern CORE_ADDR symbol_overlayed_address PARAMS((CORE_ADDR, asection *));
 
 #define SYMBOL_DEMANGLED_NAME(symbol)					\
   (SYMBOL_LANGUAGE (symbol) == language_cplus				\
+   || SYMBOL_LANGUAGE (symbol) == language_java				\
    ? SYMBOL_CPLUS_DEMANGLED_NAME (symbol)				\
    : (SYMBOL_LANGUAGE (symbol) == language_chill			\
       ? SYMBOL_CHILL_DEMANGLED_NAME (symbol)				\
@@ -584,6 +603,15 @@ enum address_class
   LOC_OPTIMIZED_OUT
 };
 
+/* Linked list of symbol's live ranges. */
+
+struct live_range		
+{
+  CORE_ADDR start;
+  CORE_ADDR end;
+  struct live_range *next;	
+};
+
 struct symbol
 {
 
@@ -623,6 +651,23 @@ struct symbol
       short basereg;
     }
   aux_value;
+
+  /* Live range information (if present) for debugging of optimized code.  
+     Gcc extensions were added to stabs to encode live range information.
+     The syntax for referencing (defining) symbol aliases is "#n" ("#n=")
+     where n is a number.  The syntax for specifying a range is "l(#<m>,#<n>)",
+     where m and n are numbers. 
+     aliases - list of other symbols which are lexically the same symbol, 
+         but were optimized into different storage classes (eg. for the
+         local symbol "x", one symbol contains range information where x 
+         is on the stack, while an alias contains the live ranges where x 
+         is in a register).
+     range - list of instruction ranges where the symbol is live. */
+  struct live_range_info 		
+    {
+      struct symbol *aliases;	/* Link to other aliases for this symbol. */
+      struct live_range	*range; /* Linked list of live ranges. */
+    } live;
 };
 
 #define SYMBOL_NAMESPACE(symbol)	(symbol)->namespace
@@ -630,6 +675,11 @@ struct symbol
 #define SYMBOL_TYPE(symbol)		(symbol)->type
 #define SYMBOL_LINE(symbol)		(symbol)->line
 #define SYMBOL_BASEREG(symbol)		(symbol)->aux_value.basereg
+#define SYMBOL_ALIASES(symbol)		(symbol)->live.aliases
+#define SYMBOL_RANGE(symbol)		(symbol)->live.range 
+#define SYMBOL_RANGE_START(symbol)	(symbol)->live.range->start
+#define SYMBOL_RANGE_END(symbol)	(symbol)->live.range->end
+#define SYMBOL_RANGE_NEXT(symbol)	(symbol)->live.range->next
 
 /* A partial_symbol records the name, namespace, and address class of
    symbols whose types we have not parsed yet.  For functions, it also