daily update

[deliverable/binutils-gdb.git] / bfd / dwarf2.c

diff --git a/bfd/dwarf2.c b/bfd/dwarf2.c
index 2635a5739ef9f18fbb7e4b5c15037bc71df9da02..5cfcc908e8dccb2ff709e52e1c8935fc1f54dca0 100644 (file)
--- a/bfd/dwarf2.c
+++ b/bfd/dwarf2.c
@@ -722,7 +722,6 @@ struct funcinfo
   char *file;                          /* Source location file name */
   int line;                            /* Source location line number */
   int tag;
-  int nesting_level;
   char *name;
   struct arange arange;
   asection *sec;                       /* Where the symbol is defined */
@@ -1431,28 +1430,8 @@ lookup_address_in_function_table (struct comp_unit *unit,
 
   if (best_fit)
     {
-      struct funcinfo* curr_func = best_fit;
-
       *functionname_ptr = best_fit->name;
       *function_ptr = best_fit;
-
-      /* If we found a match and it is a function that was inlined,
-        traverse the function list looking for the function at the
-        next higher scope and save a pointer to it for future use.
-        Note that because of the way the DWARF info is generated, and
-        the way we build the function list, the first function at the
-        next higher level is the one we want. */
-
-      for (each_func = best_fit -> prev_func;
-          each_func && (curr_func->tag == DW_TAG_inlined_subroutine);
-          each_func = each_func->prev_func)
-       {
-         if (each_func->nesting_level < curr_func->nesting_level)
-           {
-             curr_func->caller_func = each_func;
-             curr_func = each_func;
-           }
-       }
       return TRUE;
     }
   else
@@ -1568,17 +1547,22 @@ find_abstract_instance_name (struct comp_unit *unit, bfd_uint64_t die_ref)
        }
       else
        {
-         for (i = 0; i < abbrev->num_attrs && !name; ++i)
+         for (i = 0; i < abbrev->num_attrs; ++i)
            {
              info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
              switch (attr.name)
                {
                case DW_AT_name:
-                 name = attr.u.str;
+                 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
+                 if (name == NULL)
+                   name = attr.u.str;
                  break;
                case DW_AT_specification:
                  name = find_abstract_instance_name (unit, attr.u.val);
                  break;
+               case DW_AT_MIPS_linkage_name:
+                 name = attr.u.str;
+                 break;
                default:
                  break;
                }
@@ -1640,6 +1624,16 @@ scan_unit_for_symbols (struct comp_unit *unit)
   bfd *abfd = unit->abfd;
   bfd_byte *info_ptr = unit->first_child_die_ptr;
   int nesting_level = 1;
+  struct funcinfo **nested_funcs;
+  int nested_funcs_size;
+
+  /* Maintain a stack of in-scope functions and inlined functions, which we
+     can use to set the caller_func field.  */
+  nested_funcs_size = 32;
+  nested_funcs = bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
+  if (nested_funcs == NULL)
+    return FALSE;
+  nested_funcs[nesting_level] = 0;
 
   while (nesting_level)
     {
@@ -1666,6 +1660,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
          (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
                             abbrev_number);
          bfd_set_error (bfd_error_bad_value);
+         free (nested_funcs);
          return FALSE;
        }
 
@@ -1677,9 +1672,17 @@ scan_unit_for_symbols (struct comp_unit *unit)
          bfd_size_type amt = sizeof (struct funcinfo);
          func = bfd_zalloc (abfd, amt);
          func->tag = abbrev->tag;
-         func->nesting_level = nesting_level;
          func->prev_func = unit->function_table;
          unit->function_table = func;
+
+         if (func->tag == DW_TAG_inlined_subroutine)
+           for (i = nesting_level - 1; i >= 1; i--)
+             if (nested_funcs[i])
+               {
+                 func->caller_func = nested_funcs[i];
+                 break;
+               }
+         nested_funcs[nesting_level] = func;
        }
       else
        {
@@ -1693,6 +1696,9 @@ scan_unit_for_symbols (struct comp_unit *unit)
              var->prev_var = unit->variable_table;
              unit->variable_table = var;
            }
+
+         /* No inline function in scope at this nesting level.  */
+         nested_funcs[nesting_level] = 0;
        }
 
       for (i = 0; i < abbrev->num_attrs; ++i)
@@ -1782,9 +1788,17 @@ scan_unit_for_symbols (struct comp_unit *unit)
                      if (*attr.u.blk->data == DW_OP_addr)
                        {
                          var->stack = 0;
-                         var->addr = bfd_get ((attr.u.blk->size - 1) * 8,
-                                              unit->abfd,
-                                              attr.u.blk->data + 1);
+
+                         /* Verify that DW_OP_addr is the only opcode in the
+                            location, in which case the block size will be 1
+                            plus the address size.  */
+                         /* ??? For TLS variables, gcc can emit
+                            DW_OP_addr <addr> DW_OP_GNU_push_tls_address
+                            which we don't handle here yet.  */
+                         if (attr.u.blk->size == unit->addr_size + 1U)
+                           var->addr = bfd_get (unit->addr_size * 8,
+                                                unit->abfd,
+                                                attr.u.blk->data + 1);
                        }
                      break;
                    
@@ -1805,9 +1819,29 @@ scan_unit_for_symbols (struct comp_unit *unit)
        }
 
       if (abbrev->has_children)
-       nesting_level++;
+       {
+         nesting_level++;
+
+         if (nesting_level >= nested_funcs_size)
+           {
+             struct funcinfo **tmp;
+
+             nested_funcs_size *= 2;
+             tmp = bfd_realloc (nested_funcs,
+                                (nested_funcs_size
+                                 * sizeof (struct funcinfo *)));
+             if (tmp == NULL)
+               {
+                 free (nested_funcs);
+                 return FALSE;
+               }
+             nested_funcs = tmp;
+           }
+         nested_funcs[nesting_level] = 0;
+       }
     }
 
+  free (nested_funcs);
   return TRUE;
 }
 
@@ -2175,9 +2209,9 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
   stash = *pinfo;
   addr = offset;
   if (section->output_section)
-    addr += section->output_section->vma + section->output_offset;
+    addr += section->output_section->lma + section->output_offset;
   else
-    addr += section->vma;
+    addr += section->lma;
   *filename_ptr = NULL;
   *functionname_ptr = NULL;
   *linenumber_ptr = 0;
@@ -2384,9 +2418,9 @@ _bfd_dwarf2_find_line (bfd *abfd,
 
   addr = symbol->value;
   if (section->output_section)
-    addr += section->output_section->vma + section->output_offset;
+    addr += section->output_section->lma + section->output_offset;
   else
-    addr += section->vma;
+    addr += section->lma;
 
   *filename_ptr = NULL;
   stash = *pinfo;