[DWARFExpression] Remove ctor that takes just a compile unit.

[JDevlieghere]

Summary

Like many of our DWARF classes, the DWARFExpression can be initialized in many ways. One such way was through a constructor that takes just the compile unit. This constructor is used to initialize both empty DWARFExpressions, and DWARFExpression that will be populated later. To make the distinction more clear, I changed the constructor to a default constructor and updated its call sites. Where the DWARFExpression was being populated later, I replaced that with a call to the copy assignment constructor.

[JDevlieghere]

s/SetOpcodeData/UpdateValue/

[labath]

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

508–509 ↗

(On Diff #201331)

This is not the copy assignment constructor. That would be something like:
*frame_base = DWARFExpression(...).
This code looks pretty dodgy, as you're trampling over an already constructed object. I'm not sure whether that in itself is UB, but it definitely is not a good idea.

[labath]

(Other than that, the change seems like a nice improvement.)

[clayborg]

lldb/include/lldb/Expression/DWARFExpression.h

311–312 ↗

(On Diff #201331)

correct the comment or remove changes?

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

508–509 ↗

(On Diff #201331)

Use move?:

*frame_base = std::move(DWARFExpression(...));

518–519 ↗

(On Diff #201331)

use move like suggested above?

[labath]

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

508–509 ↗

(On Diff #201331)

move is not needed as DWARFExpression(...) is a temporary.

[JDevlieghere]

Address CR feedback

[clayborg]

lgtm. Pavel, you good?

lldb/trunk/include/lldb/Expression/DWARFExpression.h

enum LocationListFormat : uint8_t {
     NonLocationList,     // Not a location list
     RegularLocationList, // Location list format used in non-split dwarf files
     SplitDwarfLocationList, // Location list format used in pre-DWARF v5 split
                             // dwarf files (.debug_loc.dwo)
     LocLists,               // Location list format used in DWARF v5
                             // (.debug_loclists/.debug_loclists.dwo).
   };
 
-  /// Constructor
-  explicit DWARFExpression(DWARFUnit *dwarf_cu);
+  DWARFExpression();
 
   /// 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,
-                  DWARFUnit *dwarf_cu, lldb::offset_t data_offset,
+                  const DWARFUnit *dwarf_cu, lldb::offset_t data_offset,
                   lldb::offset_t data_length);
 
   /// Destructor
   virtual ~DWARFExpression();
 
   /// Print the description of the expression to a stream
   ///
   /// \param[in] s
public:
   ///
   /// \return
   ///     LLDB_INVALID_ADDRESS if the location doesn't contain a
   ///     DW_OP_addr for \a op_addr_idx, otherwise a valid file address
   lldb::addr_t GetLocation_DW_OP_addr(uint32_t op_addr_idx, bool &error) const;
 
   bool Update_DW_OP_addr(lldb::addr_t file_addr);
 
+  void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size,
+                   uint8_t addr_byte_size);
+
   void SetModule(const lldb::ModuleSP &module) { m_module_wp = module; }
 
   bool ContainsThreadLocalStorage() const;
 
   bool LinkThreadLocalStorage(
       lldb::ModuleSP new_module_sp,
       std::function<lldb::addr_t(lldb::addr_t file_addr)> const
           &link_address_callback);
 
-  /// Make the expression parser read its location information from a given
-  /// data source.  Does not change the offset and length
-  ///
-  /// \param[in] data
-  ///     A data extractor configured to read the DWARF location expression's
-  ///     bytecode.
-  void SetOpcodeData(const DataExtractor &data);
-
-  /// Make the expression parser read its location information from a given
-  /// data source
-  ///
-  /// \param[in] module_sp
-  ///     The module that defines the DWARF expression.
-  ///
-  /// \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.
-  void SetOpcodeData(lldb::ModuleSP module_sp, const DataExtractor &data,
-                     lldb::offset_t data_offset, lldb::offset_t data_length);
-
-  /// Copy the DWARF location expression into a local buffer.
-  ///
-  /// It is a good idea to copy the data so we don't keep the entire object
-  /// file worth of data around just for a few bytes of location expression.
-  /// LLDB typically will mmap the entire contents of debug information files,
-  /// and if we use SetOpcodeData, it will get a shared reference to all of
-  /// this data for the and cause the object file to have to stay around. Even
-  /// worse, a very very large ".a" that contains one or more .o files could
-  /// end up being referenced. Location lists are typically small so even
-  /// though we are copying the data, it shouldn't amount to that much for the
-  /// variables we end up parsing.
-  ///
-  /// \param[in] module_sp
-  ///     The module that defines the DWARF expression.
-  ///
-  /// \param[in] data
-  ///     A data extractor configured to read and copy 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.
-  void CopyOpcodeData(lldb::ModuleSP module_sp, const DataExtractor &data,
-                      lldb::offset_t data_offset, lldb::offset_t data_length);
-
-  void CopyOpcodeData(const void *data, lldb::offset_t data_length,
-                      lldb::ByteOrder byte_order, uint8_t addr_byte_size);
-
-  void CopyOpcodeData(uint64_t const_value,
-                      lldb::offset_t const_value_byte_size,
-                      uint8_t addr_byte_size);
-
   /// Tells the expression that it refers to a location list.
   ///
   /// \param[in] slide
   ///     This value should be a slide that is applied to any values
   ///     in the location list data so the values become zero based
   ///     offsets into the object that owns the location list. We need
   ///     to make location lists relative to the objects that own them
   ///     so we can relink addresses on the fly.
public:
   /// \param[in] error_ptr
   ///     If non-NULL, used to report errors in expression evaluation.
   ///
   /// \return
   ///     True on success; false otherwise.  If error_ptr is non-NULL,
   ///     details of the failure are provided through it.
   static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
                        lldb::ModuleSP opcode_ctx, const DataExtractor &opcodes,
-                       DWARFUnit *dwarf_cu, const lldb::offset_t offset,
+                       const DWARFUnit *dwarf_cu, const lldb::offset_t offset,
                        const lldb::offset_t length,
                        const lldb::RegisterKind reg_set,
                        const Value *initial_value_ptr,
                        const Value *object_address_ptr, Value &result,
                        Status *error_ptr);
 
   bool GetExpressionData(DataExtractor &data) const {
     data = m_data;
static bool PrintDWARFExpression(Stream &s, const DataExtractor &data,
                                    bool location_expression);
 
   static void PrintDWARFLocationList(Stream &s, const DWARFUnit *cu,
                                      const DataExtractor &debug_loc_data,
                                      lldb::offset_t offset);
 
   bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op);
 
-protected:
+private:
   /// Pretty-prints the location expression to a stream
   ///
   /// \param[in] stream
   ///     The stream to use for pretty-printing.
   ///
   /// \param[in] offset
   ///     The offset into the data buffer of the opcodes to be printed.
   ///
private:
 
   static bool AddressRangeForLocationListEntry(
       const DWARFUnit *dwarf_cu, const DataExtractor &debug_loc_data,
       lldb::offset_t *offset_ptr, lldb::addr_t &low_pc, lldb::addr_t &high_pc);
 
   bool GetOpAndEndOffsets(StackFrame &frame, lldb::offset_t &op_offset,
                           lldb::offset_t &end_offset);
 
-  /// Classes that inherit from DWARFExpression can see and modify these
+  /// Module which defined this expression.
+  lldb::ModuleWP m_module_wp;
+
+  /// A data extractor capable of reading opcode bytes
+  DataExtractor m_data;
 
-  lldb::ModuleWP m_module_wp; ///< Module which defined this expression.
-  DataExtractor m_data; ///< A data extractor capable of reading opcode bytes
-  DWARFUnit *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_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)
+  /// 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_const_index)
+  const DWARFUnit *m_dwarf_cu;
+
+  /// One of the defines that starts with LLDB_REGKIND_
+  lldb::RegisterKind m_reg_kind;
+
+  /// A value used to slide the location list offsets so that m_c they are
+  /// relative to the object that owns the location list (the function for
+  /// frame base and variable location lists)
+  lldb::addr_t m_loclist_slide;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_DWARFExpression_h_

lldb/trunk/source/Expression/DWARFExpression.cpp

ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
   lldb::offset_t offset = addr_base + index * index_size;
   return dwarf_cu->GetSymbolFileDWARF()
       ->GetDWARFContext()
       .getOrLoadAddrData()
       .GetMaxU64(&offset, index_size);
 }
 
 // DWARFExpression constructor
-DWARFExpression::DWARFExpression(DWARFUnit *dwarf_cu)
-    : m_module_wp(), m_data(), m_dwarf_cu(dwarf_cu),
+DWARFExpression::DWARFExpression()
+    : m_module_wp(), m_data(), m_dwarf_cu(nullptr),
       m_reg_kind(eRegisterKindDWARF), m_loclist_slide(LLDB_INVALID_ADDRESS) {}
 
 DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
                                  const DataExtractor &data,
-                                 DWARFUnit *dwarf_cu,
+                                 const DWARFUnit *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;
 }
 
 // Destructor
 DWARFExpression::~DWARFExpression() {}
 
 bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }
 
-void DWARFExpression::SetOpcodeData(const DataExtractor &data) {
-  m_data = data;
-}
-
-void DWARFExpression::CopyOpcodeData(lldb::ModuleSP module_sp,
-                                     const DataExtractor &data,
-                                     lldb::offset_t data_offset,
-                                     lldb::offset_t data_length) {
-  const uint8_t *bytes = data.PeekData(data_offset, data_length);
-  if (bytes) {
-    m_module_wp = module_sp;
-    m_data.SetData(DataBufferSP(new DataBufferHeap(bytes, data_length)));
-    m_data.SetByteOrder(data.GetByteOrder());
-    m_data.SetAddressByteSize(data.GetAddressByteSize());
-  }
-}
-
-void DWARFExpression::CopyOpcodeData(const void *data,
-                                     lldb::offset_t data_length,
-                                     ByteOrder byte_order,
-                                     uint8_t addr_byte_size) {
-  if (data && data_length) {
-    m_data.SetData(DataBufferSP(new DataBufferHeap(data, data_length)));
-    m_data.SetByteOrder(byte_order);
-    m_data.SetAddressByteSize(addr_byte_size);
-  }
-}
-
-void DWARFExpression::CopyOpcodeData(uint64_t const_value,
-                                     lldb::offset_t const_value_byte_size,
-                                     uint8_t addr_byte_size) {
-  if (const_value_byte_size) {
-    m_data.SetData(
-        DataBufferSP(new DataBufferHeap(&const_value, const_value_byte_size)));
-    m_data.SetByteOrder(endian::InlHostByteOrder());
-    m_data.SetAddressByteSize(addr_byte_size);
-  }
-}
-
-void DWARFExpression::SetOpcodeData(lldb::ModuleSP module_sp,
-                                    const DataExtractor &data,
-                                    lldb::offset_t data_offset,
-                                    lldb::offset_t data_length) {
-  m_module_wp = module_sp;
-  m_data.SetData(data, data_offset, data_length);
-}
+void DWARFExpression::UpdateValue(uint64_t const_value,
+  if (!const_value_byte_size)
+    return;
+
 
 void DWARFExpression::DumpLocation(Stream *s, lldb::offset_t offset,
                                    lldb::offset_t length,
                                    lldb::DescriptionLevel level,
                                    ABI *abi) const {
   if (!m_data.ValidOffsetForDataOfSize(offset, length))
     return;
   const lldb::offset_t start_offset = offset;
bool DWARFExpression::Evaluate(ExecutionContext *exe_ctx,
   return DWARFExpression::Evaluate(
       exe_ctx, reg_ctx, module_sp, m_data, m_dwarf_cu, 0, m_data.GetByteSize(),
       m_reg_kind, initial_value_ptr, object_address_ptr, result, error_ptr);
 }
 
 bool DWARFExpression::Evaluate(
     ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
     lldb::ModuleSP module_sp, const DataExtractor &opcodes,
-    DWARFUnit *dwarf_cu, const lldb::offset_t opcodes_offset,
+    const DWARFUnit *dwarf_cu, const lldb::offset_t opcodes_offset,
     const lldb::offset_t opcodes_length, const lldb::RegisterKind reg_kind,
     const Value *initial_value_ptr, const Value *object_address_ptr,
     Value &result, Status *error_ptr) {
 
   if (opcodes_length == 0) {
     if (error_ptr)
       error_ptr->SetErrorString(
           "no location, value may have been optimized out");

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

Function *DWARFASTParserClang::ParseFunctionFromDWARF(CompileUnit &comp_unit,
   const char *name = nullptr;
   const char *mangled = nullptr;
   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(die.GetCU());
+  DWARFExpression frame_base;
 
   const dw_tag_t tag = die.Tag();
 
   if (tag != DW_TAG_subprogram)
     return nullptr;
 
   if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line,
                                decl_column, call_file, call_line, call_column,
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
 
     switch (tag) {
     case DW_TAG_member:
     case DW_TAG_APPLE_property: {
       DWARFAttributes attributes;
       const size_t num_attributes = die.GetAttributes(attributes);
       if (num_attributes > 0) {
         Declaration decl;
-        // DWARFExpression location;
         const char *name = nullptr;
         const char *prop_name = nullptr;
         const char *prop_getter_name = nullptr;
         const char *prop_setter_name = nullptr;
         uint32_t prop_attributes = 0;
 
         bool is_artificial = false;
         DWARFFormValue encoding_form;
case DW_TAG_inheritance: {
       is_a_class = true;
       if (default_accessibility == eAccessNone)
         default_accessibility = eAccessPrivate;
       // TODO: implement DW_TAG_inheritance type parsing
       DWARFAttributes attributes;
       const size_t num_attributes = die.GetAttributes(attributes);
       if (num_attributes > 0) {
         Declaration decl;
-        DWARFExpression location(die.GetCU());
         DWARFFormValue encoding_form;
         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) {
           const dw_attr_t attr = attributes.AttributeAtIndex(i);

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

for (uint32_t i = 0; i < numAttributes; ++i) {
           break;
 
         case DW_AT_frame_base:
           if (frame_base) {
             if (form_value.BlockData()) {
               uint32_t block_offset =
                   form_value.BlockData() - debug_info_data.GetDataStart();
               uint32_t block_length = form_value.Unsigned();
-              frame_base->SetOpcodeData(module, debug_info_data, block_offset,
-                                        block_length);
+              *frame_base = DWARFExpression(module, debug_info_data, cu,
+                                            block_offset, block_length);
             } else {
               const DWARFDataExtractor &debug_loc_data =
                   dwarf2Data->DebugLocData();
               const dw_offset_t debug_loc_offset = form_value.Unsigned();
 
               size_t loc_list_length = DWARFExpression::LocationListSize(
                   cu, debug_loc_data, debug_loc_offset);
               if (loc_list_length > 0) {
-                frame_base->SetOpcodeData(module, debug_loc_data,
-                                          debug_loc_offset, loc_list_length);
+                *frame_base =
+                    DWARFExpression(module, debug_loc_data, cu,
                 if (lo_pc != LLDB_INVALID_ADDRESS) {
                   assert(lo_pc >= cu->GetBaseAddress());
                   frame_base->SetLocationListSlide(lo_pc -
                                                    cu->GetBaseAddress());
                 } else {
                   set_frame_base_loclist_addr = true;
                 }
               }

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

if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
     const size_t num_attributes = die.GetAttributes(attributes);
     DWARFDIE spec_die;
     if (num_attributes > 0) {
       const char *name = nullptr;
       const char *mangled = nullptr;
       Declaration decl;
       uint32_t i;
       DWARFFormValue type_die_form;
-      DWARFExpression location(die.GetCU());
+      DWARFExpression location;
       bool is_external = false;
       bool is_artificial = false;
       bool location_is_const_value_data = false;
       bool has_explicit_location = false;
       DWARFFormValue const_value;
       Variable::RangeList scope_ranges;
       // AccessType accessibility = eAccessNone;
 
if (num_attributes > 0) {
               // The constant value will be either a block, a data value or a
               // string.
               auto debug_info_data = die.GetData();
               if (DWARFFormValue::IsBlockForm(form_value.Form())) {
                 // Retrieve the value as a block expression.
                 uint32_t block_offset =
                     form_value.BlockData() - debug_info_data.GetDataStart();
                 uint32_t block_length = form_value.Unsigned();
-                location.CopyOpcodeData(module, debug_info_data, block_offset,
-                                        block_length);
+                location = DWARFExpression(module, debug_info_data, die.GetCU(),
+                                           block_offset, block_length);
               } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
                 // Retrieve the value as a data expression.
                 uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
                 if (auto data_length = form_value.GetFixedSize())
-                  location.CopyOpcodeData(module, debug_info_data, data_offset,
-                                          *data_length);
+                  location =
+                      DWARFExpression(module, debug_info_data, die.GetCU(),
+                                      data_offset, *data_length);
                 else {
                   const uint8_t *data_pointer = form_value.BlockData();
                   if (data_pointer) {
                     form_value.Unsigned();
                   } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
                     // we need to get the byte size of the type later after we
                     // create the variable
                     const_value = form_value;
                   }
                 }
               } else {
                 // Retrieve the value as a string expression.
                 if (form_value.Form() == DW_FORM_strp) {
                   uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
                   if (auto data_length = form_value.GetFixedSize())
-                    location.CopyOpcodeData(module, debug_info_data,
-                                            data_offset, *data_length);
+                    location =
+                        DWARFExpression(module, debug_info_data, die.GetCU(),
                 } else {
                   const char *str = form_value.AsCString();
                   uint32_t string_offset =
                       str - (const char *)debug_info_data.GetDataStart();
                   uint32_t string_length = strlen(str) + 1;
-                  location.CopyOpcodeData(module, debug_info_data,
-                                          string_offset, string_length);
+                  location =
+                      DWARFExpression(module, debug_info_data, die.GetCU(),
                 }
               }
             }
             break;
           case DW_AT_location: {
             location_is_const_value_data = false;
             has_explicit_location = true;
             if (DWARFFormValue::IsBlockForm(form_value.Form())) {
               auto data = die.GetData();
 
               uint32_t block_offset =
                   form_value.BlockData() - data.GetDataStart();
               uint32_t block_length = form_value.Unsigned();
-              location.CopyOpcodeData(module, data, block_offset, block_length);
+              location = DWARFExpression(module, data, die.GetCU(),
+                                         block_offset, block_length);
             } else {
               const DWARFDataExtractor &debug_loc_data = DebugLocData();
               const dw_offset_t debug_loc_offset = form_value.Unsigned();
 
               size_t loc_list_length = DWARFExpression::LocationListSize(
                   die.GetCU(), debug_loc_data, debug_loc_offset);
               if (loc_list_length > 0) {
-                location.CopyOpcodeData(module, debug_loc_data,
+                location = DWARFExpression(module, debug_loc_data, die.GetCU(),
                                            debug_loc_offset, loc_list_length);
                 assert(func_low_pc != LLDB_INVALID_ADDRESS);
                 location.SetLocationListSlide(
                     func_low_pc -
                     attributes.CompileUnitAtIndex(i)->GetBaseAddress());
               }
             }
           } break;
           case DW_AT_specification:
if (num_attributes > 0) {
         }
       }
 
       if (symbol_context_scope) {
         SymbolFileTypeSP type_sp(
             new SymbolFileType(*this, GetUID(DIERef(type_die_form))));
 
         if (const_value.Form() && type_sp && type_sp->GetType())
-          location.CopyOpcodeData(
-              const_value.Unsigned(),
+          location.UpdateValue(const_value.Unsigned(),
                                type_sp->GetType()->GetByteSize().getValueOr(0),
                                die.GetCU()->GetAddressByteSize());
 
         var_sp = std::make_shared<Variable>(
             die.GetID(), name, mangled, type_sp, scope, symbol_context_scope,
             scope_ranges, &decl, location, is_external, is_artificial,
             is_static_member);
 
         var_sp->SetLocationIsConstantValueData(location_is_const_value_data);
       } else {

lldb/trunk/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp

 template <typename StreamWriter>
 static DWARFExpression MakeLocationExpressionInternal(lldb::ModuleSP module,
                                                       StreamWriter &&writer) {
   const ArchSpec &architecture = module->GetArchitecture();
   ByteOrder byte_order = architecture.GetByteOrder();
   uint32_t address_size = architecture.GetAddressByteSize();
   uint32_t byte_size = architecture.GetDataByteSize();
   if (byte_order == eByteOrderInvalid || address_size == 0)
-    return DWARFExpression(nullptr);
+    return DWARFExpression();
 
   RegisterKind register_kind = eRegisterKindDWARF;
   StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order);
 
   if (!writer(stream, register_kind))
-    return DWARFExpression(nullptr);
+    return DWARFExpression();
 
   DataBufferSP buffer =
       std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize());
   DataExtractor extractor(buffer, byte_order, address_size, byte_size);
   DWARFExpression result(module, extractor, nullptr, 0, buffer->GetByteSize());
   result.SetRegisterKind(register_kind);
 
   return result;

lldb/trunk/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.cpp

 }
 
 DWARFExpression ConvertPDBLocationToDWARFExpression(
     ModuleSP module, const PDBSymbolData &symbol,
     const Variable::RangeList &ranges, bool &is_constant) {
   is_constant = true;
 
   if (!module)
-    return DWARFExpression(nullptr);
+    return DWARFExpression();
 
   const ArchSpec &architecture = module->GetArchitecture();
   llvm::Triple::ArchType arch_type = architecture.GetMachine();
   ByteOrder byte_order = architecture.GetByteOrder();
   uint32_t address_size = architecture.GetAddressByteSize();
   uint32_t byte_size = architecture.GetDataByteSize();
   if (byte_order == eByteOrderInvalid || address_size == 0)
-    return DWARFExpression(nullptr);
+    return DWARFExpression();
 
   RegisterKind register_kind = eRegisterKindDWARF;
   StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order);
   switch (symbol.getLocationType()) {
   case PDB_LocType::Static:
   case PDB_LocType::TLS: {
     stream.PutHex8(DW_OP_addr);
 
     SectionList *section_list = module->GetSectionList();
     if (!section_list)
-      return DWARFExpression(nullptr);
+      return DWARFExpression();
 
     uint32_t section_id = symbol.getAddressSection();
 
     auto section = section_list->FindSectionByID(section_id);
     if (!section)
-      return DWARFExpression(nullptr);
+      return DWARFExpression();
 
     uint32_t offset = symbol.getAddressOffset();
     stream.PutMaxHex64(section->GetFileAddress() + offset, address_size,
                        byte_order);
 
     is_constant = false;
 
     break;
if (reg_id == llvm::codeview::RegisterId::VFRAME) {
       }
 
       register_kind = eRegisterKindGeneric;
       reg_num = LLDB_REGNUM_GENERIC_FP;
     } else {
       register_kind = eRegisterKindLLDB;
       reg_num = GetLLDBRegisterNumber(arch_type, reg_id);
       if (reg_num == LLDB_INVALID_REGNUM)
-        return DWARFExpression(nullptr);
+        return DWARFExpression();
     }
 
     if (reg_num > 31) {
       stream.PutHex8(DW_OP_bregx);
       stream.PutULEB128(reg_num);
     } else
       stream.PutHex8(DW_OP_breg0 + reg_num);
 
     int32_t offset = symbol.getOffset();
     stream.PutSLEB128(offset);
 
     is_constant = false;
 
     break;
   }
   case PDB_LocType::Enregistered: {
     register_kind = eRegisterKindLLDB;
     uint32_t reg_num = GetLLDBRegisterNumber(arch_type, symbol.getRegisterId());
     if (reg_num == LLDB_INVALID_REGNUM)
-      return DWARFExpression(nullptr);
+      return DWARFExpression();
 
     if (reg_num > 31) {
       stream.PutHex8(DW_OP_regx);
       stream.PutULEB128(reg_num);
     } else
       stream.PutHex8(DW_OP_reg0 + reg_num);
 
     is_constant = false;
 
     break;
   }
   case PDB_LocType::Constant: {
     Variant value = symbol.getValue();
     stream.PutRawBytes(&value.Value, sizeof(value.Value),
                        endian::InlHostByteOrder());
     break;
   }
   default:
-    return DWARFExpression(nullptr);
+    return DWARFExpression();
   }
 
   DataBufferSP buffer =
       std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize());
   DataExtractor extractor(buffer, byte_order, address_size, byte_size);
   DWARFExpression result(module, extractor, nullptr, 0, buffer->GetByteSize());
   result.SetRegisterKind(register_kind);
 
   return result;
 }

lldb/trunk/source/Symbol/Function.cpp

 }
 
 //
 Function::Function(CompileUnit *comp_unit, lldb::user_id_t func_uid,
                    lldb::user_id_t type_uid, const Mangled &mangled, Type *type,
                    const AddressRange &range)
     : 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(nullptr), m_flags(), m_prologue_byte_size(0) {
+      m_frame_base(), m_flags(), m_prologue_byte_size(0) {
   m_block.SetParentScope(this);
   assert(comp_unit != nullptr);
 }
 
 Function::~Function() {}
 
 void Function::GetStartLineSourceInfo(FileSpec &source_file,
                                       uint32_t &line_no) {