[lldb] Fix DW_OP_addrx uses.

[tamur]

Summary

DW_OP_GNU_addr_index has been renamed as DW_OP_addrx in the standard. clang produces DW_OP_addrx tags and with this change lldb starts to process them.

[shafik]

lldb/source/Expression/DWARFExpression.cpp

2910 ↗

(On Diff #189410)

Should this comment be updated?

[tamur]

lldb/source/Expression/DWARFExpression.cpp

2910 ↗

(On Diff #189410)

Updated the comment.

[aprantl]

The code looks fine, but this needs a testcase.

[aprantl]

Is there a way to force clang to generate this and/or are existing tests failing because this support is missing?

[tamur]

Added a test. (test with dwarf5 generation would fail without other changes).

[labath]

Would a test similar to lit/SymbolFile/DWARF/array-sizes.s be possible/appropriate?
I'm thinking of something like:

• produce debug info in the form of a .s file (either with clang of via hand-tuning dwarf) which uses DW_OP_addrx
• assemble&link it
• run lldb, have it open the file and print the value of the global variable

The advantage of this would be that it's more explicit about what is being tested, and it would keep testing the same thing even if clang decides to encode variable locations differently in the future.

[tamur]

Discarded changes to the unit test and added a lit test.

[labath]

Thank you. The test looks good to me.

lldb/trunk/lit/SymbolFile/DWARF/dwarf5_locations.s

+# This tests that lldb is able to process DW_OP_addrx tags introduced in dwarf5.
+# REQUIRES: lld
+# RUN: llvm-mc -g -dwarf-version=5 -triple x86_64-unknown-linux-gnu %s -filetype=obj > %t.o
+# RUN: ld.lld -m elf_x86_64 %t.o -o %t 
+# RUN: lldb-test symbols %t | FileCheck %s
+
+# CHECK: Variable{0xffffffff00000011}, name = "color"
+# CHECK-SAME: location = DW_OP_addrx(0x0)
+
+        .text
+        .section        .debug_str,"MS",@progbits,1
+.Lstr_offsets_base0:
+        .asciz  "color"
+
+        .section        .debug_str_offsets,"",@progbits
+        .long   .Lstr_offsets_base0
+
+        .section        .debug_abbrev,"",@progbits
+        .byte   1                       # Abbreviation Code
+        .byte   17                      # DW_TAG_compile_unit
+        .byte   1                       # DW_CHILDREN_yes
+        .byte   114                     # DW_AT_str_offsets_base
+        .byte   23                      # DW_FORM_sec_offset
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   2                       # Abbreviation Code
+        .byte   52                      # DW_TAG_variable
+        .byte   0                       # DW_CHILDREN_no
+        .byte   3                       # DW_AT_name
+        .byte   37                      # DW_FORM_strx1
+        .byte   63                      # DW_AT_external
+        .byte   25                      # DW_FORM_flag_present
+        .byte   2                       # DW_AT_location
+        .byte   24                      # DW_FORM_exprloc
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   0                       # EOM(3)
+        .byte   0                       # EOM(4)
+
+        .section        .debug_info,"",@progbits
+        .long   .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+        .short  5                       # DWARF version number
+        .byte   1                       # DWARF Unit Type
+        .byte   8                       # Address Size (in bytes)
+        .long   .debug_abbrev           # Offset Into Abbrev. Section
+        .byte   1                       # Abbrev [1] 0xc:0x22 DW_TAG_compile_unit
+        .long   .Lstr_offsets_base0     # DW_AT_str_offsets_base
+        .byte   2                       # Abbrev [2] 0x1e:0xb DW_TAG_variable
+        .byte   0                       # DW_AT_name
+                                        # DW_AT_external
+        .byte   2                       # DW_AT_location
+        .byte   161
+        .byte   0
+        .byte   0                       # End Of Children Mark
+.Ldebug_info_end0:
+
+        .section        .debug_addr,"",@progbits
+        .long   .Ldebug_addr_end0-.Ldebug_addr_start0 # Length of contribution
+.Ldebug_addr_start0:
+        .short  5                       # DWARF version number
+        .byte   8                       # Address size
+        .byte   0                       # Segment selector size
+        .quad   color
+.Ldebug_addr_end0:
+

lldb/trunk/source/Expression/DWARFExpression.cpp

while (m_data.ValidOffset(offset) && offset < end_offset) {
     //            break;
     case DW_OP_form_tls_address:
       s->PutCString("DW_OP_form_tls_address"); // 0x9b
       break;
     case DW_OP_GNU_addr_index: // 0xfb
       s->Printf("DW_OP_GNU_addr_index(0x%" PRIx64 ")",
                 m_data.GetULEB128(&offset));
       break;
+    case DW_OP_addrx:
+      s->Printf("DW_OP_addrx(0x%" PRIx64 ")",
+                m_data.GetULEB128(&offset));
+      break;
     case DW_OP_GNU_const_index: // 0xfc
       s->Printf("DW_OP_GNU_const_index(0x%" PRIx64 ")",
                 m_data.GetULEB128(&offset));
       break;
     case DW_OP_GNU_push_tls_address:
       s->PutCString("DW_OP_GNU_push_tls_address"); // 0xe0
       break;
     case DW_OP_APPLE_uninit:
case DW_OP_call4:   // 0x99 1 4-byte offset of DIE (DWARF3)
     return 4;
 
   // Opcodes with a single 8 byte arguments
   case DW_OP_const8u: // 0x0e 1 8-byte constant
   case DW_OP_const8s: // 0x0f 1 8-byte constant
     return 8;
 
   // All opcodes that have a single ULEB (signed or unsigned) argument
+  case DW_OP_addrx:           // 0xa1 1 ULEB128 index
   case DW_OP_constu:          // 0x10 1 ULEB128 constant
   case DW_OP_consts:          // 0x11 1 SLEB128 constant
   case DW_OP_plus_uconst:     // 0x23 1 ULEB128 addend
   case DW_OP_breg0:           // 0x70 1 ULEB128 register
   case DW_OP_breg1:           // 0x71 1 ULEB128 register
   case DW_OP_breg2:           // 0x72 1 ULEB128 register
   case DW_OP_breg3:           // 0x73 1 ULEB128 register
   case DW_OP_breg4:           // 0x74 1 ULEB128 register
while (m_data.ValidOffset(offset)) {
     const uint8_t op = m_data.GetU8(&offset);
 
     if (op == DW_OP_addr) {
       const lldb::addr_t op_file_addr = m_data.GetAddress(&offset);
       if (curr_op_addr_idx == op_addr_idx)
         return op_file_addr;
       else
         ++curr_op_addr_idx;
-    } else if (op == DW_OP_GNU_addr_index) {
+    } else if (op == DW_OP_GNU_addr_index || op == DW_OP_addrx) {
       uint64_t index = m_data.GetULEB128(&offset);
       if (curr_op_addr_idx == op_addr_idx) {
         if (!m_dwarf_cu) {
           error = true;
           break;
         }
 
         return ReadAddressFromDebugAddrSection(m_dwarf_cu, index);
case DW_OP_GNU_push_tls_address: {
         return false;
       }
 
       stack.back().GetScalar() = tls_load_addr;
       stack.back().SetValueType(Value::eValueTypeLoadAddress);
     } break;
 
     //----------------------------------------------------------------------
-    // OPCODE: DW_OP_GNU_addr_index
+    // OPCODE: DW_OP_addrx (DW_OP_GNU_addr_index is the legacy name.)
     // OPERANDS: 1
     //      ULEB128: index to the .debug_addr section
     // DESCRIPTION: Pushes an address to the stack from the .debug_addr
     // section with the base address specified by the DW_AT_addr_base attribute
     // and the 0 based index is the ULEB128 encoded index.
     //----------------------------------------------------------------------
+    case DW_OP_addrx:
     case DW_OP_GNU_addr_index: {
       if (!dwarf_cu) {
         if (error_ptr)
           error_ptr->SetErrorString("DW_OP_GNU_addr_index found without a "
                                     "compile unit being specified");
         return false;
       }
       uint64_t index = opcodes.GetULEB128(&offset);
case DW_OP_call2:
     size = 2;
     break;
   case DW_OP_call4:
     size = 4;
     break;
   case DW_OP_call_ref:
     size = dwarf_ref_size;
     break;
+  case DW_OP_addrx:
   case DW_OP_piece:
   case DW_OP_plus_uconst:
   case DW_OP_regx:
   case DW_OP_GNU_addr_index:
   case DW_OP_GNU_const_index:
     size = 128;
     break;
   default:

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

if (abbr_idx) {
               // 8 byte values
               case DW_FORM_data8:
               case DW_FORM_ref8:
               case DW_FORM_ref_sig8:
                 form_size = 8;
                 break;
 
               // signed or unsigned LEB 128 values
+              case DW_FORM_addrx:
               case DW_FORM_sdata:
               case DW_FORM_udata:
               case DW_FORM_ref_udata:
               case DW_FORM_GNU_addr_index:
               case DW_FORM_GNU_str_index:
                 debug_info_data.Skip_LEB128(&offset);
                 break;
 
for (uint32_t i = 0; i < numAttributes; ++i) {
           break;
 
         case DW_AT_entry_pc:
           lo_pc = form_value.Address();
           break;
 
         case DW_AT_high_pc:
           if (form_value.Form() == DW_FORM_addr ||
+              form_value.Form() == DW_FORM_addrx ||
               form_value.Form() == DW_FORM_GNU_addr_index) {
             hi_pc = form_value.Address();
           } else {
             hi_pc = form_value.Unsigned();
             if (lo_pc == LLDB_INVALID_ADDRESS)
               do_offset = hi_pc != LLDB_INVALID_ADDRESS;
             else
               hi_pc += lo_pc; // DWARF 4 introduces <offset-from-lo-pc> to save

 //----------------------------------------------------------------------
 dw_addr_t DWARFDebugInfoEntry::GetAttributeHighPC(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, dw_addr_t lo_pc,
     uint64_t fail_value, bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, DW_AT_high_pc, form_value, nullptr,
                         check_specification_or_abstract_origin)) {
     dw_form_t form = form_value.Form();
-    if (form == DW_FORM_addr || form == DW_FORM_GNU_addr_index)
+    if (form == DW_FORM_addr || form == DW_FORM_addrx ||
+        form == DW_FORM_GNU_addr_index)
       return form_value.Address();
 
     // DWARF4 can specify the hi_pc as an <offset-from-lowpc>
     return lo_pc + form_value.Unsigned();
   }
   return fail_value;
 }
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

int DWARFFormValue::Compare(const DWARFFormValue &a_value,
   dw_form_t a_form = a_value.Form();
   dw_form_t b_form = b_value.Form();
   if (a_form < b_form)
     return -1;
   if (a_form > b_form)
     return 1;
   switch (a_form) {
   case DW_FORM_addr:
+  case DW_FORM_addrx:
   case DW_FORM_flag:
   case DW_FORM_data1:
   case DW_FORM_data2:
   case DW_FORM_data4:
   case DW_FORM_data8:
   case DW_FORM_udata:
   case DW_FORM_ref_addr:
   case DW_FORM_sec_offset:

lldb/trunk/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp

void DWARFMappedHash::Prologue::AppendAtom(AtomType type, dw_form_t form) {
   atom_mask |= 1u << type;
   switch (form) {
   case DW_FORM_indirect:
   case DW_FORM_exprloc:
   case DW_FORM_flag_present:
   case DW_FORM_ref_sig8:
     llvm_unreachable("Unhandled atom form");
 
+  case DW_FORM_addrx:
   case DW_FORM_string:
   case DW_FORM_block:
   case DW_FORM_block1:
   case DW_FORM_sdata:
   case DW_FORM_udata:
   case DW_FORM_ref_udata:
   case DW_FORM_GNU_addr_index:
   case DW_FORM_GNU_str_index: