Handle DW_OP_GNU_addr_index in DWARF expressions

[tberghammer]

Summary

Handle DW_OP_GNU_addr_index in DWARF expressions

This is a new operand in the dwarf expressions used when split dwarf is enabled

[clayborg]

Looks good.

DWARFExpression is unique in that it is separate from the DWARF plug-in itself because DWARF expressions are in .eh_frame and other things that don't require the rest of DWARF. It would be nice to not pass a DWARFCompileUnit to DWARFExpression, but then we would need to abstract everything we needed from DWARFCompileUnit into lldb_private::CompileUnit and the things we get from the DWARFCompileUnit are not things we want in the lldb_private::CompileUnit API, so this is the right solution.

include/lldb/Expression/DWARFExpression.h

 
 #include "lldb/lldb-private.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Scalar.h"
 
+class DWARFCompileUnit;
+
 namespace lldb_private {
     
+class ClangExpressionDeclMap;
 class ClangExpressionVariable;
 class ClangExpressionVariableList;
 
-class ClangExpressionDeclMap;
 
 //----------------------------------------------------------------------
 /// @class DWARFExpression DWARFExpression.h "lldb/Expression/DWARFExpression.h"
 /// @brief Encapsulates a DWARF location expression and interprets it.
 ///
 /// DWARF location expressions are used in two ways by LLDB.  The first 
 /// use is to find entities specified in the debug information, since
 /// their locations are specified in precisely this language.  The second
 /// is to interpret expressions without having to run the target in cases
 /// where the overhead from copying JIT-compiled code into the target is
 /// too high or where the target cannot be run.  This class encapsulates
 /// a single DWARF location expression or a location list and interprets
 /// it.
 //----------------------------------------------------------------------
 class DWARFExpression
 {
 public:
     //------------------------------------------------------------------
     /// Constructor
     //------------------------------------------------------------------
-    DWARFExpression();
+    explicit DWARFExpression(DWARFCompileUnit* dwarf_cu);
 
     //------------------------------------------------------------------
     /// Constructor
     ///
     /// @param[in] data
     ///     A data extractor configured to read the DWARF location expression's
     ///     bytecode.
     ///
     /// @param[in] data_offset
     ///     The offset of the location expression in the extractor.
     ///
     /// @param[in] data_length
     ///     The byte length of the location expression.
     //------------------------------------------------------------------
     DWARFExpression(lldb::ModuleSP module,
                     const DataExtractor& data,
+                    DWARFCompileUnit* dwarf_cu,
                     lldb::offset_t data_offset,
                     lldb::offset_t data_length);
 
     //------------------------------------------------------------------
     /// Copy constructor
     //------------------------------------------------------------------
     DWARFExpression(const DWARFExpression& rhs);
 
//
     //------------------------------------------------------------------
     static bool
     Evaluate (ExecutionContext *exe_ctx,
               ClangExpressionVariableList *expr_locals,
               ClangExpressionDeclMap *decl_map,
               RegisterContext *reg_ctx,
               lldb::ModuleSP opcode_ctx,
               const DataExtractor& opcodes,
+              DWARFCompileUnit* dwarf_cu,
               const lldb::offset_t offset,
               const lldb::offset_t length,
               const lldb::RegisterKind reg_set,
               const Value* initial_value_ptr,
               Value& result,
               Error *error_ptr);
 
     //------------------------------------------------------------------
GetLocation (lldb::addr_t base_addr,
                  lldb::offset_t &len);
 
     //------------------------------------------------------------------
     /// 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
     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

 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StackID.h"
 #include "lldb/Target/Thread.h"
 
+#include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 // TODO- why is this also defined (in a better way) in DWARFDefines.cpp?
 const char *
 DW_OP_value_to_name (uint32_t val)
 {
   static char invalid[100];
switch (val) {
     case 0x93: return "DW_OP_piece";
     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 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";
 //    case DW_OP_APPLE_constf: return "DW_OP_APPLE_constf";
 //    case DW_OP_APPLE_scalar_cast: return "DW_OP_APPLE_scalar_cast";
 //    case DW_OP_APPLE_clang_cast: return "DW_OP_APPLE_clang_cast";
 //    case DW_OP_APPLE_clear: return "DW_OP_APPLE_clear";
 //    case DW_OP_APPLE_error: return "DW_OP_APPLE_error";
     default:
        snprintf (invalid, sizeof(invalid), "Unknown DW_OP constant: 0x%x", val);
        return invalid;
   }
 }
 
 
 //----------------------------------------------------------------------
 // DWARFExpression constructor
 //----------------------------------------------------------------------
-DWARFExpression::DWARFExpression() :
+DWARFExpression::DWARFExpression(DWARFCompileUnit* dwarf_cu) :
     m_module_wp(),
     m_data(),
+    m_dwarf_cu(dwarf_cu),
     m_reg_kind (eRegisterKindDWARF),
     m_loclist_slide (LLDB_INVALID_ADDRESS)
 {
 }
 
 DWARFExpression::DWARFExpression(const DWARFExpression& rhs) :
     m_module_wp(rhs.m_module_wp),
     m_data(rhs.m_data),
+    m_dwarf_cu(rhs.m_dwarf_cu),
     m_reg_kind (rhs.m_reg_kind),
     m_loclist_slide(rhs.m_loclist_slide)
 {
 }
 
 
-DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp, const DataExtractor& data, lldb::offset_t data_offset, lldb::offset_t data_length) :
+DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
+                                 const DataExtractor& data,
+                                 DWARFCompileUnit* dwarf_cu,
+                                 lldb::offset_t data_offset,
+                                 lldb::offset_t data_length) :
     m_module_wp(),
     m_data(data, data_offset, data_length),
+    m_dwarf_cu(dwarf_cu),
     m_reg_kind (eRegisterKindDWARF),
     m_loclist_slide(LLDB_INVALID_ADDRESS)
 {
     if (module_sp)
         m_module_wp = module_sp;
 }
 
 //----------------------------------------------------------------------

 //            s->Printf("DW_OP_APPLE_extern(%" PRIu64 ")", m_data.GetULEB128(&offset));
 //            break;
 //        case DW_OP_APPLE_array_ref:
 //            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_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
             data.Skip_LEB128(&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;   
 
         case DW_OP_implicit_value: // 0x9e ULEB128 size followed by block of that size (DWARF4)
             {
                 uint64_t block_len = data.Skip_LEB128(&offset); 
                 offset += block_len;
                 return offset - data_offset;   
             }
             
         default:
             break;
     }
     return LLDB_INVALID_OFFSET;
 }
 
 lldb::addr_t
-DWARFExpression::GetLocation_DW_OP_addr (uint32_t op_addr_idx, bool &error) const
+DWARFExpression::GetLocation_DW_OP_addr (uint32_t op_addr_idx,
+                                         bool &error) const
 {
     error = false;
     if (IsLocationList())
         return LLDB_INVALID_ADDRESS;
     lldb::offset_t offset = 0;
     uint32_t curr_op_addr_idx = 0;
     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)
+        {
+            uint64_t index = m_data.GetULEB128(&offset);
+            if (curr_op_addr_idx == op_addr_idx)
+            {
+                if (!m_dwarf_cu)
+                {
+                    error = true;
+                    break;
+                }
+
+                uint32_t index_size = m_dwarf_cu->GetAddressByteSize();
+                dw_offset_t addr_base = m_dwarf_cu->GetAddrBase();
+                lldb::offset_t offset = addr_base + index * index_size;
+                return m_dwarf_cu->GetSymbolFileDWARF()->get_debug_addr_data().GetMaxU64(&offset, index_size);
+            }
+            else
+                ++curr_op_addr_idx;
+        }
         else
         {
             const offset_t op_arg_size = GetOpcodeDataSize (m_data, offset, op);
             if (op_arg_size == LLDB_INVALID_OFFSET)
             {
                 error = true;
                 break;
             }
while (m_data.ValidOffset(offset))
             const uint32_t addr_byte_size = m_data.GetAddressByteSize();
             // We have to make a copy of the data as we don't know if this
             // data is from a read only memory mapped buffer, so we duplicate
             // all of the data first, then modify it, and if all goes well,
             // we then replace the data for this expression
             
             // So first we copy the data into a heap buffer
             std::unique_ptr<DataBufferHeap> head_data_ap (new DataBufferHeap (m_data.GetDataStart(),
                                                                               m_data.GetByteSize()));
             
             // Make en encoder so we can write the address into the buffer using
             // the correct byte order (endianness)
             DataEncoder encoder (head_data_ap->GetBytes(), 
                                  head_data_ap->GetByteSize(),
                                  m_data.GetByteOrder(),
                                  addr_byte_size);
             
if (IsLocationList())
                 {
                     lo_pc += curr_loclist_base_load_addr - m_loclist_slide;
                     hi_pc += curr_loclist_base_load_addr - m_loclist_slide;
 
                     uint16_t length = m_data.GetU16(&offset);
 
                     if (length > 0 && lo_pc <= pc && pc < hi_pc)
                     {
-                        return DWARFExpression::Evaluate (exe_ctx, expr_locals, decl_map, reg_ctx, module_sp, m_data, offset, length, m_reg_kind, initial_value_ptr, result, error_ptr);
+                        return DWARFExpression::Evaluate (exe_ctx,
+                                                          expr_locals,
+                                                          decl_map,
+                                                          reg_ctx,
+                                                          module_sp,
+                                                          m_data,
+                                                          m_dwarf_cu,
+                                                          offset,
+                                                          length,
+                                                          m_reg_kind,
+                                                          initial_value_ptr,
+                                                          result,
+                                                          error_ptr);
                     }
                     offset += length;
                 }
             }
         }
         if (error_ptr)
             error_ptr->SetErrorString ("variable not available");
         return false;
     }
 
     // Not a location list, just a single expression.
-    return DWARFExpression::Evaluate (exe_ctx, expr_locals, decl_map, reg_ctx, module_sp, m_data, 0, m_data.GetByteSize(), m_reg_kind, initial_value_ptr, result, error_ptr);
+    return DWARFExpression::Evaluate (exe_ctx,
+                                      expr_locals,
+                                      decl_map,
+                                      reg_ctx,
+                                      module_sp,
+                                      m_data,
+                                      m_dwarf_cu,
+                                      0,
+                                      m_data.GetByteSize(),
+                                      m_reg_kind,
+                                      initial_value_ptr,
+                                      result,
+                                      error_ptr);
 }
 
 
 
 bool
 DWARFExpression::Evaluate
 (
     ExecutionContext *exe_ctx,
     ClangExpressionVariableList *expr_locals,
     ClangExpressionDeclMap *decl_map,
     RegisterContext *reg_ctx,
     lldb::ModuleSP module_sp,
     const DataExtractor& opcodes,
+    DWARFCompileUnit* dwarf_cu,
     const lldb::offset_t opcodes_offset,
     const lldb::offset_t opcodes_length,
     const lldb::RegisterKind reg_kind,
     const Value* initial_value_ptr,
     Value& result,
     Error *error_ptr
 )
 {

 
                 // Convert the TLS offset into the absolute address.
                 Scalar tmp = stack.back().ResolveValue(exe_ctx);
                 stack.back() = tmp + tls_addr;
                 stack.back().SetValueType (Value::eValueTypeLoadAddress);
             }
             break;
 
+        //----------------------------------------------------------------------
+        // OPCODE: DW_OP_GNU_addr_index
+        // 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_GNU_addr_index:
+            {
+                if (!dwarf_cu)
+                {
+                    if (error_ptr)
+                        error_ptr->SetErrorString ("DW_OP_GNU_addr_index found without a compile 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;
+
         default:
             if (log)
                 log->Printf("Unhandled opcode %s in DWARFExpression.", DW_OP_value_to_name(op));
             break;
         }
     }
 
     if (stack.empty())

source/Plugins/Process/Utility/RegisterContextLLDB.cpp

RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc)
     }
 
     if (unwindplan_regloc.IsDWARFExpression() || unwindplan_regloc.IsAtDWARFExpression())
     {
         DataExtractor dwarfdata (unwindplan_regloc.GetDWARFExpressionBytes(),
                                  unwindplan_regloc.GetDWARFExpressionLength(),
                                  process->GetByteOrder(), process->GetAddressByteSize());
         ModuleSP opcode_ctx;
-        DWARFExpression dwarfexpr (opcode_ctx, dwarfdata, 0, unwindplan_regloc.GetDWARFExpressionLength());
+        DWARFExpression dwarfexpr (opcode_ctx,
+                                   dwarfdata,
+                                   nullptr,
+                                   0,
+                                   unwindplan_regloc.GetDWARFExpressionLength());
         dwarfexpr.SetRegisterKind (unwindplan_registerkind);
         Value result;
         Error error;
         if (dwarfexpr.Evaluate (&exe_ctx, NULL, NULL, this, 0, NULL, result, &error))
         {
             addr_t val;
             val = result.GetScalar().ULongLong();
             if (unwindplan_regloc.IsDWARFExpression())
RegisterContextLLDB::ReadCFAValueForRow (lldb::RegisterKind row_register_kind,
     case UnwindPlan::Row::CFAValue::isDWARFExpression:
         {
             ExecutionContext exe_ctx(m_thread.shared_from_this());
             Process *process = exe_ctx.GetProcessPtr();
             DataExtractor dwarfdata (row->GetCFAValue().GetDWARFExpressionBytes(),
                                      row->GetCFAValue().GetDWARFExpressionLength(),
                                      process->GetByteOrder(), process->GetAddressByteSize());
             ModuleSP opcode_ctx;
-            DWARFExpression dwarfexpr (opcode_ctx, dwarfdata, 0, row->GetCFAValue().GetDWARFExpressionLength());
+            DWARFExpression dwarfexpr (opcode_ctx,
+                                       dwarfdata,
+                                       nullptr,
+                                       0,
+                                       row->GetCFAValue().GetDWARFExpressionLength());
             dwarfexpr.SetRegisterKind (row_register_kind);
             Value result;
             Error error;
             if (dwarfexpr.Evaluate (&exe_ctx, NULL, NULL, this, 0, NULL, result, &error))
             {
                 cfa_value = result.GetScalar().ULongLong();
 
                 UnwindLogMsg ("CFA value set by DWARF expression is 0x%" PRIx64, cfa_value);

source/Plugins/SymbolFile/DWARF/DWARFLocationDescription.cpp

switch (opcode)
         case DW_OP_call4:
             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:
+            size = 128; break;
         default:
             s.Printf("UNKNOWN ONE-OPERAND OPCODE, #%u", opcode);
             return 1;
     }
 
     switch (size)
     {
     case -1:    sint = (int8_t)     data.GetU8(offset_ptr);     s.Printf("%+" PRIi64, sint); break;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if ((tag == DW_TAG_variable) ||
                                                          attributes);
         if (num_attributes > 0)
         {
             const char *name = NULL;
             const char *mangled = NULL;
             Declaration decl;
             uint32_t i;
             lldb::user_id_t type_uid = LLDB_INVALID_UID;
-            DWARFExpression location;
+            DWARFExpression location(dwarf_cu);
             bool is_external = false;
             bool is_artificial = false;
             bool location_is_const_value_data = false;
             bool has_explicit_location = false;
             DWARFFormValue const_value;
             //AccessType accessibility = eAccessNone;
 
             for (i=0; i<num_attributes; ++i)

source/Symbol/ClangASTContext.cpp

ClangASTContext::ParseFunctionFromDWARF (const SymbolContext& sc,
     const char *name = NULL;
     const char *mangled = NULL;
     int decl_file = 0;
     int decl_line = 0;
     int decl_column = 0;
     int call_file = 0;
     int call_line = 0;
     int call_column = 0;
-    DWARFExpression frame_base;
+    DWARFExpression frame_base(dwarf_cu);
 
     assert (die->Tag() == DW_TAG_subprogram);
 
     if (die->Tag() != DW_TAG_subprogram)
         return NULL;
 
     if (die->GetDIENamesAndRanges (dwarf,
                                    dwarf_cu,
for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
                                         uint32_t block_length = form_value.Unsigned();
                                         uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
                                         if (DWARFExpression::Evaluate(NULL, // ExecutionContext *
                                                                       NULL, // ClangExpressionVariableList *
                                                                       NULL, // ClangExpressionDeclMap *
                                                                       NULL, // RegisterContext *
                                                                       module_sp,
                                                                       debug_info_data,
+                                                                      dwarf_cu,
                                                                       block_offset,
                                                                       block_length,
                                                                       eRegisterKindDWARF,
                                                                       &initialValue,
                                                                       memberOffset,
                                                                       NULL))
                                         {
                                             member_byte_offset = memberOffset.ResolveValue(NULL).UInt();
for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
                 DWARFDebugInfoEntry::Attributes attributes;
                 const size_t num_attributes = die->GetAttributes (dwarf,
                                                                   dwarf_cu,
                                                                   fixed_form_sizes,
                                                                   attributes);
                 if (num_attributes > 0)
                 {
                     Declaration decl;
-                    DWARFExpression location;
+                    DWARFExpression location(dwarf_cu);
                     lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
                     AccessType accessibility = default_accessibility;
                     bool is_virtual = false;
                     bool is_base_of_class = true;
                     off_t member_byte_offset = 0;
                     uint32_t i;
                     for (i=0; i<num_attributes; ++i)
                     {
for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
                                         uint32_t block_length = form_value.Unsigned();
                                         uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
                                         if (DWARFExpression::Evaluate (NULL,
                                                                        NULL,
                                                                        NULL,
                                                                        NULL,
                                                                        module_sp,
                                                                        debug_info_data,
+                                                                       dwarf_cu,
                                                                        block_offset,
                                                                        block_length,
                                                                        eRegisterKindDWARF,
                                                                        &initialValue,
                                                                        memberOffset,
                                                                        NULL))
                                         {
                                             member_byte_offset = memberOffset.ResolveValue(NULL).UInt();

source/Symbol/Function.cpp

 ) :
     UserID (func_uid),
     m_comp_unit (comp_unit),
     m_type_uid (type_uid),
     m_type (type),
     m_mangled (mangled),
     m_block (func_uid),
     m_range (range),
-    m_frame_base (),
+    m_frame_base (nullptr),
     m_flags (),
     m_prologue_byte_size (0)
 {
     m_block.SetParentScope(this);
     assert(comp_unit != nullptr);
 }
 
 Function::Function
 (
     CompileUnit *comp_unit,
     lldb::user_id_t func_uid,
     lldb::user_id_t type_uid,
     const char *mangled,
     Type *type,
     const AddressRange &range
 ) :
     UserID (func_uid),
     m_comp_unit (comp_unit),
     m_type_uid (type_uid),
     m_type (type),
     m_mangled (ConstString(mangled), true),
     m_block (func_uid),
     m_range (range),
-    m_frame_base (),
+    m_frame_base (nullptr),
     m_flags (),
     m_prologue_byte_size (0)
 {
     m_block.SetParentScope(this);
     assert(comp_unit != nullptr);
 }