Add support for DW_OP_GNU_const_index to dwarf expression

[tberghammer]

Summary

Add support for DW_OP_GNU_const_index to dwarf expression

DW_OP_GNU_const_index is a new opcode used when split dwarf is enabled

[clayborg]

Looks good.

include/lldb/Expression/DWARFExpression.h

protected:
     //------------------------------------------------------------------
     /// Classes that inherit from DWARFExpression can see and modify these
     //------------------------------------------------------------------
 
     lldb::ModuleWP m_module_wp;                 ///< Module which defined this expression.
     DataExtractor m_data;                       ///< A data extractor capable of reading opcode bytes
     DWARFCompileUnit* m_dwarf_cu;               ///< The DWARF compile unit this expression belongs to. It is used
                                                 ///< to evaluate values indexing into the .debug_addr section (e.g.
-                                                ///< DW_OP_GNU_addr_index
+                                                ///< DW_OP_GNU_addr_index, DW_OP_GNU_const_index)
     lldb::RegisterKind m_reg_kind;              ///< One of the defines that starts with LLDB_REGKIND_
     lldb::addr_t m_loclist_slide;               ///< A value used to slide the location list offsets so that 
                                                 ///< they are relative to the object that owns the location list
                                                 ///< (the function for frame base and variable location lists)
 
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_DWARFExpression_h_

source/Expression/DWARFExpression.cpp

switch (val) {
     case 0x94: return "DW_OP_deref_size";
     case 0x95: return "DW_OP_xderef_size";
     case 0x96: return "DW_OP_nop";
     case 0x97: return "DW_OP_push_object_address";
     case 0x98: return "DW_OP_call2";
     case 0x99: return "DW_OP_call4";
     case 0x9a: return "DW_OP_call_ref";
     case 0xfb: return "DW_OP_GNU_addr_index";
+    case 0xfc: return "DW_OP_GNU_const_index";
 //    case DW_OP_APPLE_array_ref: return "DW_OP_APPLE_array_ref";
 //    case DW_OP_APPLE_extern: return "DW_OP_APPLE_extern";
     case DW_OP_APPLE_uninit: return "DW_OP_APPLE_uninit";
 //    case DW_OP_APPLE_assign: return "DW_OP_APPLE_assign";
 //    case DW_OP_APPLE_address_of: return "DW_OP_APPLE_address_of";
 //    case DW_OP_APPLE_value_of: return "DW_OP_APPLE_value_of";
 //    case DW_OP_APPLE_deref_type: return "DW_OP_APPLE_deref_type";
 //    case DW_OP_APPLE_expr_local: return "DW_OP_APPLE_expr_local";

 //            s->PutCString("DW_OP_APPLE_array_ref");
 //            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_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:
             s->PutCString("DW_OP_APPLE_uninit");  // 0xF0
             break;
 //        case DW_OP_APPLE_assign:        // 0xF1 - pops value off and assigns it to second item on stack (2nd item must have assignable context)
 //            s->PutCString("DW_OP_APPLE_assign");
switch (op)
         case DW_OP_breg27:      // 0x8b 1 ULEB128 register
         case DW_OP_breg28:      // 0x8c 1 ULEB128 register
         case DW_OP_breg29:      // 0x8d 1 ULEB128 register
         case DW_OP_breg30:      // 0x8e 1 ULEB128 register
         case DW_OP_breg31:      // 0x8f 1 ULEB128 register
         case DW_OP_regx:        // 0x90 1 ULEB128 register
         case DW_OP_fbreg:       // 0x91 1 SLEB128 offset
         case DW_OP_piece:       // 0x93 1 ULEB128 size of piece addressed
-        case DW_OP_GNU_addr_index: // 0xfb 1 ULEB128 index
+        case DW_OP_GNU_addr_index:  // 0xfb 1 ULEB128 index
+        case DW_OP_GNU_const_index: // 0xfc 1 ULEB128 index
             data.Skip_LEB128(&offset); 
-            return offset - data_offset;   
+            return offset - data_offset;
             
             // All opcodes that have a 2 ULEB (signed or unsigned) arguments
         case DW_OP_bregx:       // 0x92 2 ULEB128 register followed by SLEB128 offset
         case DW_OP_bit_piece:   // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3);
             data.Skip_LEB128(&offset); 
             data.Skip_LEB128(&offset); 
             return offset - data_offset;   
 

         // 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_GNU_addr_index:
             {
                 if (!dwarf_cu)
                 {
                     if (error_ptr)
-                        error_ptr->SetErrorString ("DW_OP_GNU_addr_index found without a compile being specified");
+                        error_ptr->SetErrorString ("DW_OP_GNU_addr_index found without a compile unit being specified");
                     return false;
                 }
                 uint64_t index = opcodes.GetULEB128(&offset);
                 uint32_t index_size = dwarf_cu->GetAddressByteSize();
                 dw_offset_t addr_base = dwarf_cu->GetAddrBase();
                 lldb::offset_t offset = addr_base + index * index_size;
                 uint64_t value = dwarf_cu->GetSymbolFileDWARF()->get_debug_addr_data().GetMaxU64(&offset, index_size);
                 stack.push_back(Scalar(value));
                 stack.back().SetValueType(Value::eValueTypeFileAddress);
             }
             break;
 
+        //----------------------------------------------------------------------
+        // OPCODE: DW_OP_GNU_const_index
+        // OPERANDS: 1
+        //      ULEB128: index to the .debug_addr section
+        // DESCRIPTION: Pushes an constant with the size of a machine 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_GNU_const_index:
+            {
+                if (!dwarf_cu)
+                {
+                    if (error_ptr)
+                        error_ptr->SetErrorString ("DW_OP_GNU_const_index found without a compile unit being specified");
+                    return false;
+                }
+                uint64_t index = opcodes.GetULEB128(&offset);
+                uint32_t index_size = dwarf_cu->GetAddressByteSize();
+                dw_offset_t addr_base = dwarf_cu->GetAddrBase();
+                lldb::offset_t offset = addr_base + index * index_size;
+                const DWARFDataExtractor& debug_addr = dwarf_cu->GetSymbolFileDWARF()->get_debug_addr_data();
+                switch (index_size)
+                {
+                    case 4:
+                        stack.push_back(Scalar(debug_addr.GetU32(&offset)));
+                        break;
+                    case 8:
+                        stack.push_back(Scalar(debug_addr.GetU64(&offset)));
+                        break;
+                    default:
+                        assert(false && "Unhandled index size");
+                        return false;
+                }
+            }
+            break;
+
         default:
             if (log)
                 log->Printf("Unhandled opcode %s in DWARFExpression.", DW_OP_value_to_name(op));
             break;
         }
     }
 
     if (stack.empty())

source/Plugins/SymbolFile/DWARF/DWARFLocationDescription.cpp

switch (opcode)
             size = 4;       break;
         case DW_OP_call_ref:
             size = dwarf_ref_size;  break;
         case DW_OP_piece:
             size = 128; break;
         case DW_OP_regx:
             size = 128; break;
         case DW_OP_GNU_addr_index:
+        case DW_OP_GNU_const_index:
             size = 128; break;
         default:
             s.Printf("UNKNOWN ONE-OPERAND OPCODE, #%u", opcode);
             return 1;
     }
 
     switch (size)
     {

test/lang/c/const_variables/Makefile

 LEVEL = ../../../make
 
 C_SOURCES := main.c functions.c
 
-CFLAGS ?= -g -O3
+CFLAGS_EXTRAS += -O3
 
 include $(LEVEL)/Makefile.rules