[lldb] Make protected ctor and method of SBAddress take a const reference instead of a pointer.

[JDevlieghere]

Summary

Every call to the protected SBAddress constructor takes the address of a valid object which means we might as well pass it as a const reference instead of a pointer and drop the null check.

[werat]

Thanks for refactoring this!

[labath]

cool

lldb/source/API/SBValue.cpp

1359

the Address( part is redundant.

lldb/include/lldb/API/SBAddress.h

protected:
   friend bool LLDB_API operator==(const SBAddress &lhs, const SBAddress &rhs);
 
   lldb_private::Address *get();
 
   lldb_private::Address &ref();
 
   const lldb_private::Address &ref() const;
 
-  SBAddress(const lldb_private::Address *lldb_object_ptr);
+  SBAddress(const lldb_private::Address &address);
 
-  void SetAddress(const lldb_private::Address *lldb_object_ptr);
+  void SetAddress(const lldb_private::Address &address);
 
 private:
   std::unique_ptr<lldb_private::Address> m_opaque_up;
 };
 
 bool LLDB_API operator==(const SBAddress &lhs, const SBAddress &rhs);
 
 } // namespace lldb
 
 #endif // LLDB_API_SBADDRESS_H

lldb/source/API/SBAddress.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 SBAddress::SBAddress() : m_opaque_up(new Address()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress);
 }
 
-SBAddress::SBAddress(const Address *lldb_object_ptr)
-    : m_opaque_up(new Address()) {
-  if (lldb_object_ptr)
-    m_opaque_up = std::make_unique<Address>(*lldb_object_ptr);
-}
+SBAddress::SBAddress(const Address &address)
+    : m_opaque_up(std::make_unique<Address>(address)) {}
 
 SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) {
   LLDB_RECORD_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset)
void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
   LLDB_RECORD_METHOD(void, SBAddress, SetAddress,
                      (lldb::SBSection, lldb::addr_t), section, offset);
 
   Address &addr = ref();
   addr.SetSection(section.GetSP());
   addr.SetOffset(offset);
 }
 
-void SBAddress::SetAddress(const Address *lldb_object_ptr) {
-  if (lldb_object_ptr)
-    ref() = *lldb_object_ptr;
-  else
-    m_opaque_up = std::make_unique<Address>();
-}
+void SBAddress::SetAddress(const Address &address) { ref() = address; }
 
 lldb::addr_t SBAddress::GetFileAddress() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBAddress, GetFileAddress);
 
   if (m_opaque_up->IsValid())
     return m_opaque_up->GetFileAddress();
   else
     return LLDB_INVALID_ADDRESS;

lldb/source/API/SBBreakpointLocation.cpp

SBBreakpointLocation::operator bool() const {
   return bool(GetSP());
 }
 
 SBAddress SBBreakpointLocation::GetAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress);
 
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp) {
-    return LLDB_RECORD_RESULT(SBAddress(&loc_sp->GetAddress()));
+    return LLDB_RECORD_RESULT(SBAddress(loc_sp->GetAddress()));
   }
 
   return LLDB_RECORD_RESULT(SBAddress());
 }
 
 addr_t SBBreakpointLocation::GetLoadAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation,
                              GetLoadAddress);

 LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
                    (const char *), callback_function_name);
 }
 
 SBError SBBreakpointLocation::SetScriptCallbackFunction(
     const char *callback_function_name,
     SBStructuredData &extra_args) {
   LLDB_RECORD_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
-                     (const char *, SBStructuredData &), 
-                     callback_function_name, extra_args);
+                     (const char *, SBStructuredData &), callback_function_name,
+                     extra_args);
   SBError sb_error;
   BreakpointLocationSP loc_sp = GetSP();
 
   if (loc_sp) {
     Status error;
     std::lock_guard<std::recursive_mutex> guard(
         loc_sp->GetTarget().GetAPIMutex());
     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
     error = loc_sp->GetBreakpoint()
         .GetTarget()
         .GetDebugger()
         .GetScriptInterpreter()
         ->SetBreakpointCommandCallbackFunction(bp_options,
                                                callback_function_name,
                                                extra_args.m_impl_up
                                                    ->GetObjectSP());
       sb_error.SetError(error);
     } else
       sb_error.SetErrorString("invalid breakpoint");
-    
     return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBError
 SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
                      (const char *), callback_body_text);
 

lldb/source/API/SBFrame.cpp

SBAddress SBFrame::GetPCAddress() const {
   StackFrame *frame = exe_ctx.GetFramePtr();
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame)
-        sb_addr.SetAddress(&frame->GetFrameCodeAddress());
+        sb_addr.SetAddress(frame->GetFrameCodeAddress());
     }
   }
   return LLDB_RECORD_RESULT(sb_addr);
 }
 
 void SBFrame::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
 

lldb/source/API/SBFunction.cpp

void SBFunction::reset(lldb_private::Function *lldb_object_ptr) {
   m_opaque_ptr = lldb_object_ptr;
 }
 
 SBAddress SBFunction::GetStartAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetStartAddress);
 
   SBAddress addr;
   if (m_opaque_ptr)
-    addr.SetAddress(&m_opaque_ptr->GetAddressRange().GetBaseAddress());
+    addr.SetAddress(m_opaque_ptr->GetAddressRange().GetBaseAddress());
   return LLDB_RECORD_RESULT(addr);
 }
 
 SBAddress SBFunction::GetEndAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBFunction, GetEndAddress);
 
   SBAddress addr;
   if (m_opaque_ptr) {
     addr_t byte_size = m_opaque_ptr->GetAddressRange().GetByteSize();
     if (byte_size > 0) {
-      addr.SetAddress(&m_opaque_ptr->GetAddressRange().GetBaseAddress());
+      addr.SetAddress(m_opaque_ptr->GetAddressRange().GetBaseAddress());
       addr->Slide(byte_size);
     }
   }
   return LLDB_RECORD_RESULT(addr);
 }
 
 const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
   LLDB_RECORD_METHOD(const char *, SBFunction, GetArgumentName, (uint32_t),

lldb/source/API/SBInstruction.cpp

 }
 
 SBAddress SBInstruction::GetAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress);
 
   SBAddress sb_addr;
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp && inst_sp->GetAddress().IsValid())
-    sb_addr.SetAddress(&inst_sp->GetAddress());
+    sb_addr.SetAddress(inst_sp->GetAddress());
   return LLDB_RECORD_RESULT(sb_addr);
 }
 
 const char *SBInstruction::GetMnemonic(SBTarget target) {
   LLDB_RECORD_METHOD(const char *, SBInstruction, GetMnemonic, (lldb::SBTarget),
                      target);
 
   lldb::InstructionSP inst_sp(GetOpaque());

lldb/source/API/SBLineEntry.cpp

 SBLineEntry::~SBLineEntry() = default;
 
 SBAddress SBLineEntry::GetStartAddress() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry,
                                    GetStartAddress);
 
   SBAddress sb_address;
   if (m_opaque_up)
-    sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress());
+    sb_address.SetAddress(m_opaque_up->range.GetBaseAddress());
 
   return LLDB_RECORD_RESULT(sb_address);
 }
 
 SBAddress SBLineEntry::GetEndAddress() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry, GetEndAddress);
 
   SBAddress sb_address;
   if (m_opaque_up) {
-    sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress());
+    sb_address.SetAddress(m_opaque_up->range.GetBaseAddress());
     sb_address.OffsetAddress(m_opaque_up->range.GetByteSize());
   }
   return LLDB_RECORD_RESULT(sb_address);
 }
 
 bool SBLineEntry::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid);
   return this->operator bool();

lldb/source/API/SBQueueItem.cpp

void SBQueueItem::SetKind(lldb::QueueItemKind kind) {
   }
 }
 
 SBAddress SBQueueItem::GetAddress() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBQueueItem, GetAddress);
 
   SBAddress result;
   if (m_queue_item_sp) {
-    result.SetAddress(&m_queue_item_sp->GetAddress());
+    result.SetAddress(m_queue_item_sp->GetAddress());
   }
   return LLDB_RECORD_RESULT(result);
 }
 
 void SBQueueItem::SetAddress(SBAddress addr) {
   LLDB_RECORD_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress), addr);
 
   if (m_queue_item_sp) {

lldb/source/API/SBSymbol.cpp

 
 void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; }
 
 SBAddress SBSymbol::GetStartAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetStartAddress);
 
   SBAddress addr;
   if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
-    addr.SetAddress(&m_opaque_ptr->GetAddressRef());
+    addr.SetAddress(m_opaque_ptr->GetAddressRef());
   }
   return LLDB_RECORD_RESULT(addr);
 }
 
 SBAddress SBSymbol::GetEndAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress);
 
   SBAddress addr;
   if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
     lldb::addr_t range_size = m_opaque_ptr->GetByteSize();
     if (range_size > 0) {
-      addr.SetAddress(&m_opaque_ptr->GetAddressRef());
+      addr.SetAddress(m_opaque_ptr->GetAddressRef());
       addr->Slide(m_opaque_ptr->GetByteSize());
     }
   }
   return LLDB_RECORD_RESULT(addr);
 }
 
 uint32_t SBSymbol::GetPrologueByteSize() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize);

lldb/source/API/SBValue.cpp

if (target_sp) {
         // no need to check the return value on this.. if it can actually do
         // the resolve addr will be in the form (section,offset), otherwise it
         // will simply be returned as (NULL, value)
         addr.SetLoadAddress(value, target_sp.get());
       }
     }
   }
 
-  return LLDB_RECORD_RESULT(SBAddress(new Address(addr)));
+  return LLDB_RECORD_RESULT(SBAddress(Address(addr)));
 }
 
 lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
   LLDB_RECORD_METHOD(lldb::SBData, SBValue, GetPointeeData,
                      (uint32_t, uint32_t), item_idx, item_count);
 
   lldb::SBData sb_data;
   ValueLocker locker;