daily update

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

diff --git a/bfd/dwarf2.c b/bfd/dwarf2.c
index 1eae5e1b732f486a923678736b6aed47c855c93c..12858338f6ad6d6e490368d59f32a0b2be6591da 100644 (file)
--- a/bfd/dwarf2.c
+++ b/bfd/dwarf2.c
@@ -45,6 +45,7 @@ struct line_head
   unsigned short version;
   bfd_vma prologue_length;
   unsigned char minimum_instruction_length;
+  unsigned char maximum_ops_per_insn;
   unsigned char default_is_stmt;
   int line_base;
   unsigned char line_range;
@@ -760,7 +761,7 @@ read_attribute_value (struct attribute *attr,
     case DW_FORM_ref_addr:
       /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
         DWARF3.  */
-      if (unit->version == 3)
+      if (unit->version == 3 || unit->version == 4)
        {
          if (unit->offset_size == 4)
            attr->u.val = read_4_bytes (unit->abfd, info_ptr);
@@ -774,6 +775,13 @@ read_attribute_value (struct attribute *attr,
       attr->u.val = read_address (unit, info_ptr);
       info_ptr += unit->addr_size;
       break;
+    case DW_FORM_sec_offset:
+      if (unit->offset_size == 4)
+       attr->u.val = read_4_bytes (unit->abfd, info_ptr);
+      else
+       attr->u.val = read_8_bytes (unit->abfd, info_ptr);
+      info_ptr += unit->offset_size;
+      break;
     case DW_FORM_block2:
       amt = sizeof (struct dwarf_block);
       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
@@ -816,6 +824,7 @@ read_attribute_value (struct attribute *attr,
       attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
       info_ptr += bytes_read;
       break;
+    case DW_FORM_exprloc:
     case DW_FORM_block:
       amt = sizeof (struct dwarf_block);
       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
@@ -846,6 +855,9 @@ read_attribute_value (struct attribute *attr,
       attr->u.val = read_1_byte (abfd, info_ptr);
       info_ptr += 1;
       break;
+    case DW_FORM_flag_present:
+      attr->u.val = 1;
+      break;
     case DW_FORM_sdata:
       attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
       info_ptr += bytes_read;
@@ -887,6 +899,7 @@ read_attribute_value (struct attribute *attr,
       (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
                             form);
       bfd_set_error (bfd_error_bad_value);
+      return NULL;
     }
   return info_ptr;
 }
@@ -916,7 +929,8 @@ struct line_info
   char *filename;
   unsigned int line;
   unsigned int column;
-  int end_sequence;            /* End of (sequential) code sequence.  */
+  unsigned char op_index;
+  unsigned char end_sequence;          /* End of (sequential) code sequence.  */
 };
 
 struct fileinfo
@@ -990,7 +1004,9 @@ new_line_sorts_after (struct line_info *new_line, struct line_info *line)
 {
   return (new_line->address > line->address
          || (new_line->address == line->address
-             && new_line->end_sequence < line->end_sequence));
+             && (new_line->op_index > line->op_index
+                 || (new_line->op_index == line->op_index
+                     && new_line->end_sequence < line->end_sequence))));
 }
 
 
@@ -1002,6 +1018,7 @@ new_line_sorts_after (struct line_info *new_line, struct line_info *line)
 static bfd_boolean
 add_line_info (struct line_info_table *table,
               bfd_vma address,
+              unsigned char op_index,
               char *filename,
               unsigned int line,
               unsigned int column,
@@ -1015,7 +1032,9 @@ add_line_info (struct line_info_table *table,
     return FALSE;
 
   /* Set member data of 'info'.  */
+  info->prev_line = NULL;
   info->address = address;
+  info->op_index = op_index;
   info->line = line;
   info->column = column;
   info->end_sequence = end_sequence;
@@ -1047,6 +1066,7 @@ add_line_info (struct line_info_table *table,
 
   if (seq
       && seq->last_line->address == address
+      && seq->last_line->op_index == op_index
       && seq->last_line->end_sequence == end_sequence)
     {
       /* We only keep the last entry with the same address and end
@@ -1242,6 +1262,11 @@ compare_sequences (const void* a, const void* b)
   if (seq1->last_line->address > seq2->last_line->address)
     return -1;
 
+  if (seq1->last_line->op_index < seq2->last_line->op_index)
+    return 1;
+  if (seq1->last_line->op_index > seq2->last_line->op_index)
+    return -1;
+
   return 0;
 }
 
@@ -1372,6 +1397,13 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
     }
   line_end = line_ptr + lh.total_length;
   lh.version = read_2_bytes (abfd, line_ptr);
+  if (lh.version < 2 || lh.version > 4)
+    {
+      (*_bfd_error_handler)
+       (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
+      bfd_set_error (bfd_error_bad_value);
+      return NULL;
+    }
   line_ptr += 2;
   if (offset_size == 4)
     lh.prologue_length = read_4_bytes (abfd, line_ptr);
@@ -1380,6 +1412,20 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
   line_ptr += offset_size;
   lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
   line_ptr += 1;
+  if (lh.version >= 4)
+    {
+      lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr);
+      line_ptr += 1;
+    }
+  else
+    lh.maximum_ops_per_insn = 1;
+  if (lh.maximum_ops_per_insn == 0)
+    {
+      (*_bfd_error_handler)
+       (_("Dwarf Error: Invalid maximum operations per instruction."));
+      bfd_set_error (bfd_error_bad_value);
+      return NULL;
+    }
   lh.default_is_stmt = read_1_byte (abfd, line_ptr);
   line_ptr += 1;
   lh.line_base = read_1_signed_byte (abfd, line_ptr);
@@ -1460,6 +1506,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
     {
       /* State machine registers.  */
       bfd_vma address = 0;
+      unsigned char op_index = 0;
       char * filename = table->num_files ? concat_filename (table, 1) : NULL;
       unsigned int line = 1;
       unsigned int column = 0;
@@ -1483,11 +1530,21 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
            {
              /* Special operand.  */
              adj_opcode = op_code - lh.opcode_base;
-             address += (adj_opcode / lh.line_range)
-               * lh.minimum_instruction_length;
+             if (lh.maximum_ops_per_insn == 1)
+               address += (adj_opcode / lh.line_range)
+                          * lh.minimum_instruction_length;
+             else
+               {
+                 address += ((op_index + (adj_opcode / lh.line_range))
+                             / lh.maximum_ops_per_insn)
+                            * lh.minimum_instruction_length;
+                 op_index = (op_index + (adj_opcode / lh.line_range))
+                            % lh.maximum_ops_per_insn;
+               }
              line += lh.line_base + (adj_opcode % lh.line_range);
              /* Append row to matrix using current values.  */
-             if (!add_line_info (table, address, filename, line, column, 0))
+             if (!add_line_info (table, address, op_index, filename,
+                                 line, column, 0))
                goto line_fail;
              if (address < low_pc)
                low_pc = address;
@@ -1506,8 +1563,8 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
                {
                case DW_LNE_end_sequence:
                  end_sequence = 1;
-                 if (!add_line_info (table, address, filename, line, column,
-                                     end_sequence))
+                 if (!add_line_info (table, address, op_index, filename,
+                                     line, column, end_sequence))
                    goto line_fail;
                  if (address < low_pc)
                    low_pc = address;
@@ -1518,6 +1575,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
                  break;
                case DW_LNE_set_address:
                  address = read_address (unit, line_ptr);
+                 op_index = 0;
                  line_ptr += unit->addr_size;
                  break;
                case DW_LNE_define_file:
@@ -1560,7 +1618,8 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
                }
              break;
            case DW_LNS_copy:
-             if (!add_line_info (table, address, filename, line, column, 0))
+             if (!add_line_info (table, address, op_index,
+                                 filename, line, column, 0))
                goto line_fail;
              if (address < low_pc)
                low_pc = address;
@@ -1568,8 +1627,18 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
                high_pc = address;
              break;
            case DW_LNS_advance_pc:
-             address += lh.minimum_instruction_length
-               * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+             if (lh.maximum_ops_per_insn == 1)
+               address += lh.minimum_instruction_length
+                          * read_unsigned_leb128 (abfd, line_ptr,
+                                                  &bytes_read);
+             else
+               {
+                 bfd_vma adjust = read_unsigned_leb128 (abfd, line_ptr,
+                                                        &bytes_read);
+                 address = ((op_index + adjust) / lh.maximum_ops_per_insn)
+                           * lh.minimum_instruction_length;
+                 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
+               }
              line_ptr += bytes_read;
              break;
            case DW_LNS_advance_line:
@@ -1599,11 +1668,20 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
            case DW_LNS_set_basic_block:
              break;
            case DW_LNS_const_add_pc:
-             address += lh.minimum_instruction_length
-                     * ((255 - lh.opcode_base) / lh.line_range);
+             if (lh.maximum_ops_per_insn == 1)
+               address += lh.minimum_instruction_length
+                          * ((255 - lh.opcode_base) / lh.line_range);
+             else
+               {
+                 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
+                 address += lh.minimum_instruction_length
+                            * ((op_index + adjust) / lh.maximum_ops_per_insn);
+                 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
+               }
              break;
            case DW_LNS_fixed_advance_pc:
              address += read_2_bytes (abfd, line_ptr);
+             op_index = 0;
              line_ptr += 2;
              break;
            default:
@@ -1873,13 +1951,15 @@ find_abstract_instance_name (struct comp_unit *unit,
              switch (attr.name)
                {
                case DW_AT_name:
-                 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
+                 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_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);
                  break;
+               case DW_AT_linkage_name:
                case DW_AT_MIPS_linkage_name:
                  name = attr.u.str;
                  break;
@@ -2049,11 +2129,13 @@ scan_unit_for_symbols (struct comp_unit *unit)
                  break;
 
                case DW_AT_name:
-                 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
+                 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
+                    over DW_AT_name.  */
                  if (func->name == NULL)
                    func->name = attr.u.str;
                  break;
 
+               case DW_AT_linkage_name:
                case DW_AT_MIPS_linkage_name:
                  func->name = attr.u.str;
                  break;
@@ -2113,6 +2195,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
                    case DW_FORM_block1:
                    case DW_FORM_block2:
                    case DW_FORM_block4:
+                   case DW_FORM_exprloc:
                      if (*attr.u.blk->data == DW_OP_addr)
                        {
                          var->stack = 0;
@@ -2216,9 +2299,9 @@ parse_comp_unit (struct dwarf2_debug *stash,
   addr_size = read_1_byte (abfd, info_ptr);
   info_ptr += 1;
 
-  if (version != 2 && version != 3)
+  if (version != 2 && version != 3 && version != 4)
     {
-      (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 and 3 information."), version);
+      (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2, 3 and 4 information."), version);
       bfd_set_error (bfd_error_bad_value);
       return 0;
     }