[Reproducers] Capture return values of functions returning by ptr/ref

[JDevlieghere]

Summary

For some reason I had convinced myself that functions returning by pointer or reference do not require recording their result. However, after further considering I don't see how that could work, at least not with the current implementation. Interestingly enough, the reproducer instrumentation already (mostly) accounts for this, though the lldb-instr tool did not.

This patch adds the missing macros and updates the lldb-instr tool.

[JDevlieghere]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

679

Let's cast this or hide it behind a macro to prevent code duplication.

lldb/unittests/Utility/ReproducerInstrumentationTest.cpp

552

Oops, this should be removed.

[labath]

I agree that these functions should be recorded. I think the reason that the infrastructure already mostly supports that is that we were modelling constructors as functions that return pointers (and you definitely need to record constructors).

lldb/include/lldb/Utility/ReproducerInstrumentation.h

678–716

I would expect that all of these could be replaced with one function using universal references. I.e., something like:

template<typename Result> Result &&RecordResult(Result &&r) {
...
m_serializer.SerializeAll(r); // No std::forward, as you don't want to move r into this function
...
return std::forward<Result>(r);
}

Can you try that out?

[JDevlieghere]

• Add tests for lldb-instr
• Feedback Pavel

[friss]

This seems super mechanical and we discussed it at length offline. LGTM

lldb/include/lldb/Utility/ReproducerInstrumentation.h

#define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method)               \
   if (lldb_private::repro::InstrumentationData data =                          \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     sb_recorder.emplace(data.GetSerializer(), data.GetRegistry(),              \
                         LLVM_PRETTY_FUNCTION);                                 \
     sb_recorder->Record(static_cast<Result (*)()>(&Class::Method));            \
   }
 
 #define LLDB_RECORD_RESULT(Result)                                             \
-  sb_recorder ? sb_recorder->RecordResult(Result) : Result;
+  sb_recorder ? sb_recorder->RecordResult(Result) : (Result);
 
 /// The LLDB_RECORD_DUMMY macro is special because it doesn't actually record
 /// anything. It's used to track API boundaries when we cannot record for
 /// technical reasons.
 #define LLDB_RECORD_DUMMY(Result, Class, Method, Signature, ...)               \
   LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "{0} ({1})",             \
            LLVM_PRETTY_FUNCTION, log_args(__VA_ARGS__));                       \
   llvm::Optional<lldb_private::repro::Recorder> sb_recorder;
public:
 
   /// Records a single function call.
   template <typename Result, typename... FArgs, typename... RArgs>
   void Record(Result (*f)(FArgs...), const RArgs &... args) {
     if (!ShouldCapture())
       return;
 
     unsigned id = m_registry.GetID(uintptr_t(f));
-
-#ifndef LLDB_REPRO_INSTR_TRACE
-    LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "Recording {0}: {1}",
-             id, m_pretty_func);
-#else
-    llvm::errs() << "Recording " << id << ": " << m_pretty_func << "\n";
-#endif
+    Log(id);
 
     m_serializer.SerializeAll(id);
     m_serializer.SerializeAll(args...);
 
     if (std::is_class<typename std::remove_pointer<
             typename std::remove_reference<Result>::type>::type>::value) {
       m_result_recorded = false;
     } else {
       m_serializer.SerializeAll(0);
       m_result_recorded = true;
     }
   }
 
   /// Records a single function call.
   template <typename... Args>
   void Record(void (*f)(Args...), const Args &... args) {
     if (!ShouldCapture())
       return;
 
     unsigned id = m_registry.GetID(uintptr_t(f));
-
-#ifndef LLDB_REPRO_INSTR_TRACE
-    LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "Recording {0}: {1}",
-             id, m_pretty_func);
-#else
-    llvm::errs() << "Recording " << id << ": " << m_pretty_func << "\n";
-#endif
+    Log(id);
 
     m_serializer.SerializeAll(id);
     m_serializer.SerializeAll(args...);
 
     // Record result.
     m_serializer.SerializeAll(0);
     m_result_recorded = true;
   }
 
   /// Record the result of a function call.
-  template <typename Result> Result RecordResult(const Result &r) {
+  template <typename Result> const Result &RecordResult(const Result &r) {
+    UpdateBoundary();
+    if (ShouldCapture()) {
+      assert(!m_result_recorded);
+      m_serializer.SerializeAll(r);
+      m_result_recorded = true;
+    }
+    return r;
+  }
+
+  template <typename Result> Result &RecordResult(Result &r) {
+    UpdateBoundary();
+    if (ShouldCapture()) {
+      assert(!m_result_recorded);
+      m_serializer.SerializeAll(r);
+      m_result_recorded = true;
+    }
+    return r;
+  }
+
+  template <typename Result> const Result *RecordResult(const Result *r) {
+    UpdateBoundary();
+    if (ShouldCapture()) {
+      assert(!m_result_recorded);
+      m_serializer.SerializeAll(r);
+      m_result_recorded = true;
+    }
+    return r;
+  }
+
+  template <typename Result> Result *RecordResult(Result *r) {
     UpdateBoundary();
     if (ShouldCapture()) {
       assert(!m_result_recorded);
       m_serializer.SerializeAll(r);
       m_result_recorded = true;
     }
     return r;
   }
 
 private:
   void UpdateBoundary() {
     if (m_local_boundary)
       g_global_boundary = false;
   }
 
   bool ShouldCapture() { return m_local_boundary; }
+  void Log(unsigned id);
 
   Serializer &m_serializer;
   Registry &m_registry;
 
   /// Pretty function for logging.
   llvm::StringRef m_pretty_func;
 
   /// Whether this function call was the one crossing the API boundary.

lldb/source/API/SBAddress.cpp

 SBAddress::~SBAddress() {}
 
 const SBAddress &SBAddress::operator=(const SBAddress &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBAddress &,
                      SBAddress, operator=,(const lldb::SBAddress &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
   if (lhs.IsValid() && rhs.IsValid())
     return lhs.ref() == rhs.ref();
   return false;
 }
 

lldb/source/API/SBAttachInfo.cpp

 lldb_private::ProcessAttachInfo &SBAttachInfo::ref() { return *m_opaque_sp; }
 
 SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) {
   LLDB_RECORD_METHOD(lldb::SBAttachInfo &,
                      SBAttachInfo, operator=,(const lldb::SBAttachInfo &), rhs);
 
   if (this != &rhs)
     m_opaque_sp = clone(rhs.m_opaque_sp);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 lldb::pid_t SBAttachInfo::GetProcessID() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID);
 
   return m_opaque_sp->GetProcessID();
 }
 

lldb/source/API/SBBlock.cpp

SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
   LLDB_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs);
 }
 
 const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBBlock &,
                      SBBlock, operator=,(const lldb::SBBlock &), rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBBlock::~SBBlock() { m_opaque_ptr = NULL; }
 
 bool SBBlock::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid);
   return this->operator bool();
 }

lldb/source/API/SBBreakpoint.cpp

 
 SBBreakpoint::~SBBreakpoint() = default;
 
 const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBBreakpoint &,
                      SBBreakpoint, operator=,(const lldb::SBBreakpoint &), rhs);
 
   m_opaque_wp = rhs.m_opaque_wp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) {
   LLDB_RECORD_METHOD(
       bool, SBBreakpoint, operator==,(const lldb::SBBreakpoint &), rhs);
 
   return m_opaque_wp.lock() == rhs.m_opaque_wp.lock();
 }

lldb/source/API/SBBreakpointLocation.cpp

 const SBBreakpointLocation &SBBreakpointLocation::
 operator=(const SBBreakpointLocation &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBBreakpointLocation &,
       SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &),
       rhs);
 
   m_opaque_wp = rhs.m_opaque_wp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBBreakpointLocation::~SBBreakpointLocation() {}
 
 BreakpointLocationSP SBBreakpointLocation::GetSP() const {
   return m_opaque_wp.lock();
 }
 

lldb/source/API/SBBreakpointName.cpp

 const SBBreakpointName &SBBreakpointName::
 operator=(const SBBreakpointName &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBBreakpointName &,
       SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
 
   if (!rhs.m_impl_up) {
     m_impl_up.reset();
-    return *this;
+    return LLDB_RECORD_RESULT(*this);
   }
 
   m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(),
                                            rhs.m_impl_up->GetName()));
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
   LLDB_RECORD_METHOD(
       bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs);
 
   return *m_impl_up == *rhs.m_impl_up;
 }

lldb/source/API/SBBroadcaster.cpp

const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBBroadcaster &,
                      SBBroadcaster, operator=,(const lldb::SBBroadcaster &),
                      rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
     m_opaque_ptr = rhs.m_opaque_ptr;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBBroadcaster::~SBBroadcaster() { reset(NULL, false); }
 
 void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
                      (uint32_t, bool), event_type, unique);
 

lldb/source/API/SBCommandInterpreter.cpp

 const SBCommandInterpreter &SBCommandInterpreter::
 operator=(const SBCommandInterpreter &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBCommandInterpreter &,
       SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &),
       rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBCommandInterpreter::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid);
   return this->operator bool();
 }
 SBCommandInterpreter::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool);

lldb/source/API/SBCommandReturnObject.cpp

 }
 
 SBCommandReturnObject::~SBCommandReturnObject() = default;
 
 CommandReturnObject *SBCommandReturnObject::Release() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb_private::CommandReturnObject *,
                              SBCommandReturnObject, Release);
 
-  return m_opaque_up.release();
+  return LLDB_RECORD_RESULT(m_opaque_up.release());
 }
 
 const SBCommandReturnObject &SBCommandReturnObject::
 operator=(const SBCommandReturnObject &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBCommandReturnObject &,
       SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &),
       rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBCommandReturnObject::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid);
   return this->operator bool();
 }
 SBCommandReturnObject::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool);

lldb/source/API/SBCompileUnit.cpp

 }
 
 const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBCompileUnit &,
                      SBCompileUnit, operator=,(const lldb::SBCompileUnit &),
                      rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = NULL; }
 
 SBFileSpec SBCompileUnit::GetFileSpec() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit,
                                    GetFileSpec);
 

lldb/source/API/SBData.cpp

 }
 
 const SBData &SBData::operator=(const SBData &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBData &,
                      SBData, operator=,(const lldb::SBData &), rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBData::~SBData() {}
 
 void SBData::SetOpaque(const lldb::DataExtractorSP &data_sp) {
   m_opaque_sp = data_sp;
 }
 

lldb/source/API/SBDebugger.cpp

 
 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
   LLDB_RECORD_METHOD(lldb::SBDebugger &,
                      SBDebugger, operator=,(const lldb::SBDebugger &), rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 void SBDebugger::Initialize() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize);
   SBError ignored = SBDebugger::InitializeWithErrorHandling();
 }
 
 lldb::SBError SBDebugger::InitializeWithErrorHandling() {

 }
 
 FILE *SBDebugger::GetInputFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle);
 
   if (m_opaque_sp) {
     StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
     if (stream_file_sp)
-      return stream_file_sp->GetFile().GetStream();
+      return LLDB_RECORD_RESULT(stream_file_sp->GetFile().GetStream());
   }
   return nullptr;
 }
 
 FILE *SBDebugger::GetOutputFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle);
 
   if (m_opaque_sp) {
     StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
     if (stream_file_sp)
-      return stream_file_sp->GetFile().GetStream();
+      return LLDB_RECORD_RESULT(stream_file_sp->GetFile().GetStream());
   }
   return nullptr;
 }
 
 FILE *SBDebugger::GetErrorFileHandle() {
   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle);
 
   if (m_opaque_sp) {
     StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
     if (stream_file_sp)
-      return stream_file_sp->GetFile().GetStream();
+      return LLDB_RECORD_RESULT(stream_file_sp->GetFile().GetStream());
   }
   return nullptr;
 }
 
 void SBDebugger::SaveInputTerminalState() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
 
   if (m_opaque_sp)

lldb/source/API/SBDeclaration.cpp

 
 const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBDeclaration &,
                      SBDeclaration, operator=,(const lldb::SBDeclaration &),
                      rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 void SBDeclaration::SetDeclaration(
     const lldb_private::Declaration &lldb_object_ref) {
   ref() = lldb_object_ref;
 }
 
 SBDeclaration::~SBDeclaration() {}

lldb/source/API/SBError.cpp

 SBError::~SBError() {}
 
 const SBError &SBError::operator=(const SBError &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBError &,
                      SBError, operator=,(const lldb::SBError &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 const char *SBError::GetCString() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBError, GetCString);
 
   if (m_opaque_up)
     return m_opaque_up->AsCString();
   return NULL;

lldb/source/API/SBEvent.cpp

 const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBEvent &,
                      SBEvent, operator=,(const lldb::SBEvent &), rhs);
 
   if (this != &rhs) {
     m_event_sp = rhs.m_event_sp;
     m_opaque_ptr = rhs.m_opaque_ptr;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBEvent::~SBEvent() {}
 
 const char *SBEvent::GetDataFlavor() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor);
 
   Event *lldb_event = get();

lldb/source/API/SBExecutionContext.cpp

 
 const SBExecutionContext &SBExecutionContext::
 operator=(const lldb::SBExecutionContext &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBExecutionContext &,
       SBExecutionContext, operator=,(const lldb::SBExecutionContext &), rhs);
 
   m_exe_ctx_sp = rhs.m_exe_ctx_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 ExecutionContextRef *SBExecutionContext::get() const {
   return m_exe_ctx_sp.get();
 }
 
 SBTarget SBExecutionContext::GetTarget() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBExecutionContext,

lldb/source/API/SBExpressionOptions.cpp

 const SBExpressionOptions &SBExpressionOptions::
 operator=(const SBExpressionOptions &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBExpressionOptions &,
       SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBExpressionOptions::~SBExpressionOptions() {}
 
 bool SBExpressionOptions::GetCoerceResultToId() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions,
                                    GetCoerceResultToId);
 

lldb/source/API/SBFileSpec.cpp

 SBFileSpec::~SBFileSpec() {}
 
 const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBFileSpec &,
                      SBFileSpec, operator=,(const lldb::SBFileSpec &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBFileSpec::operator==(const SBFileSpec &rhs) const {
   LLDB_RECORD_METHOD_CONST(bool, SBFileSpec, operator==,(const SBFileSpec &rhs),
                            rhs);
 
   return ref() == rhs.ref();
 }

lldb/source/API/SBFileSpecList.cpp

 
 const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBFileSpecList &,
                      SBFileSpecList, operator=,(const lldb::SBFileSpecList &),
                      rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 uint32_t SBFileSpecList::GetSize() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFileSpecList, GetSize);
 
   return m_opaque_up->GetSize();
 }
 

lldb/source/API/SBFrame.cpp

 SBFrame::~SBFrame() = default;
 
 const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBFrame &,
                      SBFrame, operator=,(const lldb::SBFrame &), rhs);
 
   if (this != &rhs)
     m_opaque_sp = clone(rhs.m_opaque_sp);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 StackFrameSP SBFrame::GetFrameSP() const {
   return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP());
 }
 
 void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
   return m_opaque_sp->SetFrameSP(lldb_object_sp);

lldb/source/API/SBFunction.cpp

SBFunction::SBFunction(const lldb::SBFunction &rhs)
   LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs);
 }
 
 const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBFunction &,
                      SBFunction, operator=,(const lldb::SBFunction &), rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBFunction::~SBFunction() { m_opaque_ptr = NULL; }
 
 bool SBFunction::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid);
   return this->operator bool();
 }

lldb/source/API/SBInstruction.cpp

 
 const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBInstruction &,
                      SBInstruction, operator=,(const lldb::SBInstruction &),
                      rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBInstruction::~SBInstruction() {}
 
 bool SBInstruction::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid);
   return this->operator bool();
 }

lldb/source/API/SBInstructionList.cpp

 const SBInstructionList &SBInstructionList::
 operator=(const SBInstructionList &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBInstructionList &,
       SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBInstructionList::~SBInstructionList() {}
 
 bool SBInstructionList::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid);
   return this->operator bool();
 }

lldb/source/API/SBLineEntry.cpp

 }
 
 const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBLineEntry &,
                      SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) {
   m_opaque_up = llvm::make_unique<LineEntry>(lldb_object_ref);
 }
 
 SBLineEntry::~SBLineEntry() {}
 

lldb/source/API/SBListener.cpp

 const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBListener &,
                      SBListener, operator=,(const lldb::SBListener &), rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
     m_unused_ptr = nullptr;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBListener::SBListener(const lldb::ListenerSP &listener_sp)
     : m_opaque_sp(listener_sp), m_unused_ptr(nullptr) {}
 
 SBListener::~SBListener() {}
 
 bool SBListener::IsValid() const {

lldb/source/API/SBMemoryRegionInfo.cpp

 const SBMemoryRegionInfo &SBMemoryRegionInfo::
 operator=(const SBMemoryRegionInfo &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBMemoryRegionInfo &,
       SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBMemoryRegionInfo::~SBMemoryRegionInfo() {}
 
 void SBMemoryRegionInfo::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear);
 
   m_opaque_up->Clear();

lldb/source/API/SBMemoryRegionInfoList.cpp

operator=(const SBMemoryRegionInfoList &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBMemoryRegionInfoList &,
       SBMemoryRegionInfoList, operator=,(const lldb::SBMemoryRegionInfoList &),
       rhs);
 
   if (this != &rhs) {
     *m_opaque_up = *rhs.m_opaque_up;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 uint32_t SBMemoryRegionInfoList::GetSize() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize);
 
   return m_opaque_up->GetSize();
 }
 

lldb/source/API/SBModule.cpp

 }
 
 const SBModule &SBModule::operator=(const SBModule &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBModule &,
                      SBModule, operator=,(const lldb::SBModule &), rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBModule::~SBModule() {}
 
 bool SBModule::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid);
   return this->operator bool();
 }

lldb/source/API/SBModuleSpec.cpp

 }
 
 const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBModuleSpec &,
                      SBModuleSpec, operator=,(const lldb::SBModuleSpec &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBModuleSpec::~SBModuleSpec() {}
 
 bool SBModuleSpec::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid);
   return this->operator bool();
 }

 
 SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
   LLDB_RECORD_METHOD(
       lldb::SBModuleSpecList &,
       SBModuleSpecList, operator=,(const lldb::SBModuleSpecList &), rhs);
 
   if (this != &rhs)
     *m_opaque_up = *rhs.m_opaque_up;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBModuleSpecList::~SBModuleSpecList() {}
 
 SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) {
   LLDB_RECORD_STATIC_METHOD(lldb::SBModuleSpecList, SBModuleSpecList,
                             GetModuleSpecifications, (const char *), path);
 

lldb/source/API/SBProcess.cpp

 }
 
 const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBProcess &,
                      SBProcess, operator=,(const lldb::SBProcess &), rhs);
 
   if (this != &rhs)
     m_opaque_wp = rhs.m_opaque_wp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBProcess::~SBProcess() {}
 
 const char *SBProcess::GetBroadcasterClassName() {

lldb/source/API/SBProcessInfo.cpp

 
 SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
   LLDB_RECORD_METHOD(lldb::SBProcessInfo &,
                      SBProcessInfo, operator=,(const lldb::SBProcessInfo &),
                      rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 ProcessInstanceInfo &SBProcessInfo::ref() {
   if (m_opaque_up == nullptr) {
     m_opaque_up.reset(new ProcessInstanceInfo());
   }
   return *m_opaque_up;
 }

lldb/source/API/SBQueue.cpp

SBQueue::SBQueue(const SBQueue &rhs) {
   m_opaque_sp = rhs.m_opaque_sp;
 }
 
 const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBQueue &,
                      SBQueue, operator=,(const lldb::SBQueue &), rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBQueue::~SBQueue() {}
 
 bool SBQueue::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid);
   return this->operator bool();
 }

lldb/source/API/SBSection.cpp

if (section_sp)
     m_opaque_wp = section_sp;
 }
 
 const SBSection &SBSection::operator=(const SBSection &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBSection &,
                      SBSection, operator=,(const lldb::SBSection &), rhs);
 
   m_opaque_wp = rhs.m_opaque_wp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBSection::~SBSection() {}
 
 bool SBSection::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid);
   return this->operator bool();
 }

lldb/source/API/SBSourceManager.cpp

 
 const lldb::SBSourceManager &SBSourceManager::
 operator=(const lldb::SBSourceManager &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBSourceManager &,
                      SBSourceManager, operator=,(const lldb::SBSourceManager &),
                      rhs);
 
   m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get())));
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBSourceManager::~SBSourceManager() {}
 
 size_t SBSourceManager::DisplaySourceLinesWithLineNumbers(
     const SBFileSpec &file, uint32_t line, uint32_t context_before,
     uint32_t context_after, const char *current_line_cstr, SBStream &s) {
   LLDB_RECORD_METHOD(size_t, SBSourceManager, DisplaySourceLinesWithLineNumbers,

lldb/source/API/SBStringList.cpp

 }
 
 const SBStringList &SBStringList::operator=(const SBStringList &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBStringList &,
                      SBStringList, operator=,(const lldb::SBStringList &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBStringList::~SBStringList() {}
 
 const lldb_private::StringList *SBStringList::operator->() const {
   return m_opaque_up.get();
 }
 

lldb/source/API/SBStructuredData.cpp

 
 SBStructuredData &SBStructuredData::
 operator=(const lldb::SBStructuredData &rhs) {
   LLDB_RECORD_METHOD(
       lldb::SBStructuredData &,
       SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs);
 
   *m_impl_up = *rhs.m_impl_up;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
   LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
                      (lldb::SBStream &), stream);
 
   lldb::SBError error;
   std::string json_str(stream.GetData());

lldb/source/API/SBSymbol.cpp

SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
   LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs);
 }
 
 const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBSymbol &,
                      SBSymbol, operator=,(const lldb::SBSymbol &), rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBSymbol::~SBSymbol() { m_opaque_ptr = NULL; }
 
 void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) {
   m_opaque_ptr = lldb_object_ptr;
 }
 

lldb/source/API/SBSymbolContext.cpp

 
 const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
                      SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
                      rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) {
   if (sc_ptr)
     m_opaque_up = llvm::make_unique<SymbolContext>(*sc_ptr);
   else
     m_opaque_up->Clear(true);
 }

lldb/source/API/SBSymbolContextList.cpp

 const SBSymbolContextList &SBSymbolContextList::
 operator=(const SBSymbolContextList &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBSymbolContextList &,
       SBSymbolContextList, operator=,(const lldb::SBSymbolContextList &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 uint32_t SBSymbolContextList::GetSize() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBSymbolContextList, GetSize);
 
   if (m_opaque_up)
     return m_opaque_up->GetSize();
   return 0;

lldb/source/API/SBTarget.cpp

 }
 
 const SBTarget &SBTarget::operator=(const SBTarget &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBTarget &,
                      SBTarget, operator=,(const lldb::SBTarget &), rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBTarget::~SBTarget() {}
 
 bool SBTarget::EventIsTargetEvent(const SBEvent &event) {

lldb/source/API/SBThread.cpp

 //----------------------------------------------------------------------
 
 const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBThread &,
                      SBThread, operator=,(const lldb::SBThread &), rhs);
 
   if (this != &rhs)
     m_opaque_sp = clone(rhs.m_opaque_sp);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBThread::~SBThread() {}
 
 lldb::SBQueue SBThread::GetQueue() const {
bool SBThread::SafeToCallFunctions() {
   return true;
 }
 
 lldb_private::Thread *SBThread::operator->() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, operator->);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
-    return thread_sp.get();
-  else
-    return NULL;
+    return LLDB_RECORD_RESULT(thread_sp.get());
+  return nullptr;
 }
 
 lldb_private::Thread *SBThread::get() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, get);
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
-    return thread_sp.get();
-  else
-    return NULL;
+    return LLDB_RECORD_RESULT(thread_sp.get());
+  return nullptr;
 }
 
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBThread>(Registry &R) {
   LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName,

lldb/source/API/SBThreadCollection.cpp

 const SBThreadCollection &SBThreadCollection::
 operator=(const SBThreadCollection &rhs) {
   LLDB_RECORD_METHOD(
       const lldb::SBThreadCollection &,
       SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBThreadCollection::SBThreadCollection(const ThreadCollectionSP &threads)
     : m_opaque_sp(threads) {}
 
 SBThreadCollection::~SBThreadCollection() {}
 
 void SBThreadCollection::SetOpaque(const lldb::ThreadCollectionSP &threads) {

lldb/source/API/SBThreadPlan.cpp

 //----------------------------------------------------------------------
 
 const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
                      SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBThreadPlan::~SBThreadPlan() {}
 
 lldb_private::ThreadPlan *SBThreadPlan::get() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb_private::ThreadPlan *, SBThreadPlan, get);
 
-  return m_opaque_sp.get();
+  return LLDB_RECORD_RESULT(m_opaque_sp.get());
 }
 
 bool SBThreadPlan::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
   return this->operator bool();
 }
 SBThreadPlan::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool);

lldb/source/API/SBType.cpp

 
 SBType &SBType::operator=(const SBType &rhs) {
   LLDB_RECORD_METHOD(lldb::SBType &, SBType, operator=,(const lldb::SBType &),
                      rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBType::~SBType() {}
 
 TypeImpl &SBType::ref() {
   if (m_opaque_sp.get() == NULL)
     m_opaque_sp = std::make_shared<TypeImpl>();
   return *m_opaque_sp;
LLDB_RECORD_METHOD(lldb::SBTypeList &,
                      SBTypeList, operator=,(const lldb::SBTypeList &), rhs);
 
   if (this != &rhs) {
     m_opaque_up.reset(new TypeListImpl());
     for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
          i < rhs_size; i++)
       Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 void SBTypeList::Append(SBType type) {
   LLDB_RECORD_METHOD(void, SBTypeList, Append, (lldb::SBType), type);
 
   if (type.IsValid())
     m_opaque_up->Append(type.m_opaque_sp);
 }

 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
   LLDB_RECORD_METHOD(lldb::SBTypeMember &,
                      SBTypeMember, operator=,(const lldb::SBTypeMember &), rhs);
 
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new TypeMemberImpl(rhs.ref()));
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeMember::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid);
   return this->operator bool();
 }
 SBTypeMember::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool);

 operator=(const lldb::SBTypeMemberFunction &rhs) {
   LLDB_RECORD_METHOD(
       lldb::SBTypeMemberFunction &,
       SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &),
       rhs);
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeMemberFunction::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid);
   return this->operator bool();
 }
 SBTypeMemberFunction::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool);

lldb/source/API/SBTypeCategory.cpp

 operator=(const lldb::SBTypeCategory &rhs) {
   LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
                      SBTypeCategory, operator=,(const lldb::SBTypeCategory &),
                      rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
   LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
                      rhs);
 
   if (!IsValid())
     return !rhs.IsValid();

lldb/source/API/SBTypeEnumMember.cpp

SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs)
     : m_opaque_sp() {
   LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &),
                           rhs);
 
   m_opaque_sp = clone(rhs.m_opaque_sp);
 }
 
 SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
-  LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &),
+  LLDB_RECORD_METHOD(SBTypeEnumMember &,SBTypeEnumMember,operator=, (const lldb::SBTypeEnumMember &),
                           rhs);
 
   if (this != &rhs)
     m_opaque_sp = clone(rhs.m_opaque_sp);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeEnumMember::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid);
   return this->operator bool();
 }
 SBTypeEnumMember::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool);
operator=(const SBTypeEnumMemberList &rhs) {
   if (this != &rhs) {
     m_opaque_up.reset(new TypeEnumMemberListImpl());
     for (uint32_t i = 0,
                   rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
          i < rhs_size; i++)
       Append(
           const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
   LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append,
                      (lldb::SBTypeEnumMember), enum_member);
 
   if (enum_member.IsValid())
     m_opaque_up->Append(enum_member.m_opaque_sp);

lldb/source/API/SBTypeFilter.cpp

 
 lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
   LLDB_RECORD_METHOD(lldb::SBTypeFilter &,
                      SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
   LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
                      rhs);
 
   if (!IsValid())
     return !rhs.IsValid();

lldb/source/API/SBTypeFormat.cpp

 
 lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
   LLDB_RECORD_METHOD(lldb::SBTypeFormat &,
                      SBTypeFormat, operator=,(const lldb::SBTypeFormat &), rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
   LLDB_RECORD_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &),
                      rhs);
 
   if (!IsValid())
     return !rhs.IsValid();

lldb/source/API/SBTypeNameSpecifier.cpp

 operator=(const lldb::SBTypeNameSpecifier &rhs) {
   LLDB_RECORD_METHOD(
       lldb::SBTypeNameSpecifier &,
       SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
   LLDB_RECORD_METHOD(
       bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs);
 
   if (!IsValid())
     return !rhs.IsValid();

lldb/source/API/SBTypeSummary.cpp

 lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
   LLDB_RECORD_METHOD(lldb::SBTypeSummary &,
                      SBTypeSummary, operator=,(const lldb::SBTypeSummary &),
                      rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
   LLDB_RECORD_METHOD(bool, SBTypeSummary, operator==,(lldb::SBTypeSummary &),
                      rhs);
 
   if (!IsValid())
     return !rhs.IsValid();

lldb/source/API/SBTypeSynthetic.cpp

 operator=(const lldb::SBTypeSynthetic &rhs) {
   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &,
                      SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &),
                      rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
   LLDB_RECORD_METHOD(
       bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs);
 
   if (!IsValid())
     return !rhs.IsValid();

lldb/source/API/SBUnixSignals.cpp

 
 const SBUnixSignals &SBUnixSignals::operator=(const SBUnixSignals &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBUnixSignals &,
                      SBUnixSignals, operator=,(const lldb::SBUnixSignals &),
                      rhs);
 
   if (this != &rhs)
     m_opaque_wp = rhs.m_opaque_wp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBUnixSignals::~SBUnixSignals() {}
 
 UnixSignalsSP SBUnixSignals::GetSP() const { return m_opaque_wp.lock(); }
 
 void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) {
   m_opaque_wp = signals_sp;

lldb/source/API/SBValue.cpp

 
 SBValue &SBValue::operator=(const SBValue &rhs) {
   LLDB_RECORD_METHOD(lldb::SBValue &,
                      SBValue, operator=,(const lldb::SBValue &), rhs);
 
   if (this != &rhs) {
     SetSP(rhs.m_opaque_sp);
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBValue::~SBValue() {}
 
 bool SBValue::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid);
   return this->operator bool();
 }

lldb/source/API/SBValueList.cpp

LLDB_RECORD_METHOD(const lldb::SBValueList &,
                      SBValueList, operator=,(const lldb::SBValueList &), rhs);
 
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new ValueListImpl(*rhs));
     else
       m_opaque_up.reset();
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); }
 
 ValueListImpl &SBValueList::operator*() { return *m_opaque_up; }
 
 const ValueListImpl *SBValueList::operator->() const {
   return m_opaque_up.get();

lldb/source/API/SBVariablesOptions.cpp

 SBVariablesOptions &SBVariablesOptions::
 operator=(const SBVariablesOptions &options) {
   LLDB_RECORD_METHOD(
       lldb::SBVariablesOptions &,
       SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &),
       options);
 
   m_opaque_up.reset(new VariablesOptionsImpl(options.ref()));
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBVariablesOptions::~SBVariablesOptions() = default;
 
 bool SBVariablesOptions::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
   return this->operator bool();
 }

lldb/source/API/SBWatchpoint.cpp

SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
   LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs);
 }
 
 const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
                      SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs);
 
   m_opaque_wp = rhs.m_opaque_wp;
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 SBWatchpoint::~SBWatchpoint() {}
 
 watch_id_t SBWatchpoint::GetID() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID);
 
 

lldb/source/Utility/ReproducerInstrumentation.cpp

Recorder::Recorder(Serializer &serializer, Registry &registry,
   }
 }
 
 Recorder::~Recorder() {
   assert(m_result_recorded && "Did you forget LLDB_RECORD_RESULT?");
   UpdateBoundary();
 }
 
+void Recorder::Log(unsigned id) {
+#ifndef LLDB_REPRO_INSTR_TRACE
+  LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API), "Recording {0}: {1}", id,
+           m_pretty_func);
+#else
+  llvm::errs() << "Recording " << id << ": " << m_pretty_func << "\n";
+#endif
+}
+
 bool lldb_private::repro::Recorder::g_global_boundary;

lldb/tools/lldb-instr/Instrument.cpp

bool VisitCXXMethodDecl(CXXMethodDecl *Decl) {
     // got inserted before an existing newline.
     SourceLocation InsertLoc = Lexer::getLocForEndOfToken(
         Body->getBeginLoc(), 0, MyRewriter.getSourceMgr(),
         MyRewriter.getLangOpts());
     MyRewriter.InsertTextAfter(InsertLoc, Macro);
 
     // If the function returns a class or struct, we need to wrap its return
     // statement(s).
-    if (!ShouldInsertDummy && ReturnType->isStructureOrClassType()) {
+    if (!ShouldInsertDummy && ReturnType->getPointeeCXXRecordDecl()) {
       SBReturnVisitor Visitor(MyRewriter);
       Visitor.TraverseDecl(Decl);
     }
 
     return true;
   }
 
 private:

lldb/unittests/Utility/ReproducerInstrumentationTest.cpp

 };
 
 class InstrumentedBar {
 public:
   /// Instrumented methods.
   /// {
   InstrumentedBar();
   InstrumentedFoo GetInstrumentedFoo();
+  InstrumentedFoo& GetInstrumentedFooRef();
+  InstrumentedFoo* GetInstrumentedFooPtr();
   void SetInstrumentedFoo(InstrumentedFoo *foo);
   void SetInstrumentedFoo(InstrumentedFoo &foo);
   void Validate();
   /// }
 
 private:
   bool m_get_instrumend_foo_called = false;
   InstrumentedFoo *m_foo_set_by_ptr = nullptr;

 
 InstrumentedFoo InstrumentedBar::GetInstrumentedFoo() {
   LLDB_RECORD_METHOD_NO_ARGS(InstrumentedFoo, InstrumentedBar,
                              GetInstrumentedFoo);
   m_get_instrumend_foo_called = true;
   return LLDB_RECORD_RESULT(InstrumentedFoo(0));
 }
 
+InstrumentedFoo& InstrumentedBar::GetInstrumentedFooRef() {
+  LLDB_RECORD_METHOD_NO_ARGS(InstrumentedFoo&, InstrumentedBar,
+                             GetInstrumentedFooRef);
+  InstrumentedFoo* foo = new InstrumentedFoo(0);
+  m_get_instrumend_foo_called = true;
+  return LLDB_RECORD_RESULT(*foo);
+}
+
+InstrumentedFoo* InstrumentedBar::GetInstrumentedFooPtr() {
+  LLDB_RECORD_METHOD_NO_ARGS(InstrumentedFoo*, InstrumentedBar,
+                             GetInstrumentedFooPtr);
+  InstrumentedFoo* foo = new InstrumentedFoo(0);
+  m_get_instrumend_foo_called = true;
+  return LLDB_RECORD_RESULT(foo);
+}
+
 void InstrumentedBar::SetInstrumentedFoo(InstrumentedFoo *foo) {
   LLDB_RECORD_METHOD(void, InstrumentedBar, SetInstrumentedFoo,
                      (InstrumentedFoo *), foo);
   m_foo_set_by_ptr = foo;
 }
 
 void InstrumentedBar::SetInstrumentedFoo(InstrumentedFoo &foo) {
   LLDB_RECORD_METHOD(void, InstrumentedBar, SetInstrumentedFoo,
TestingRegistry::TestingRegistry() {
   LLDB_REGISTER_METHOD_CONST(int, InstrumentedFoo, D, (const char *));
   LLDB_REGISTER_STATIC_METHOD(void, InstrumentedFoo, E, (double));
   LLDB_REGISTER_STATIC_METHOD(int, InstrumentedFoo, F, ());
   LLDB_REGISTER_METHOD(void, InstrumentedFoo, Validate, ());
 
   LLDB_REGISTER_CONSTRUCTOR(InstrumentedBar, ());
   LLDB_REGISTER_METHOD(InstrumentedFoo, InstrumentedBar, GetInstrumentedFoo,
                        ());
+  LLDB_REGISTER_METHOD(InstrumentedFoo&, InstrumentedBar, GetInstrumentedFooRef,
+                       ());
+  LLDB_REGISTER_METHOD(InstrumentedFoo*, InstrumentedBar, GetInstrumentedFooPtr,
+                       ());
   LLDB_REGISTER_METHOD(void, InstrumentedBar, SetInstrumentedFoo,
                        (InstrumentedFoo *));
   LLDB_REGISTER_METHOD(void, InstrumentedBar, SetInstrumentedFoo,
                        (InstrumentedFoo &));
   LLDB_REGISTER_METHOD(void, InstrumentedBar, Validate, ());
 }
 
 static const Pod p;
TEST(RecordReplayTest, InstrumentedBar) {
   std::string str;
   llvm::raw_string_ostream os(str);
   g_registry.emplace();
   g_serializer.emplace(os);
 
   {
     InstrumentedBar bar;
     InstrumentedFoo foo = bar.GetInstrumentedFoo();
+#if 0
+    InstrumentedFoo& foo_ref = bar.GetInstrumentedFooRef();
+    InstrumentedFoo* foo_ptr = bar.GetInstrumentedFooPtr();
+#endif
+
+    int b = 200;
+    float c = 300.3;
+    double e = 400.4;
+
+    foo.A(100);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("bar");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    bar.SetInstrumentedFoo(foo);
+    bar.SetInstrumentedFoo(&foo);
+    bar.Validate();
+  }
+
+  ClearObjects();
+
+  TestingRegistry registry;
+  registry.Replay(os.str());
+
+  ValidateObjects(1, 1);
+}
+
+TEST(RecordReplayTest, InstrumentedBarRef) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+  g_registry.emplace();
+  g_serializer.emplace(os);
+
+  {
+    InstrumentedBar bar;
+    InstrumentedFoo& foo = bar.GetInstrumentedFooRef();
+#if 0
+    InstrumentedFoo* foo_ptr = bar.GetInstrumentedFooPtr();
+#endif
+
+    int b = 200;
+    float c = 300.3;
+    double e = 400.4;
+
+    foo.A(100);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("bar");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    bar.SetInstrumentedFoo(foo);
+    bar.SetInstrumentedFoo(&foo);
+    bar.Validate();
+  }
+
+  ClearObjects();
+
+  TestingRegistry registry;
+  registry.Replay(os.str());
+
+  ValidateObjects(1, 1);
+}
+
+TEST(RecordReplayTest, InstrumentedBarPtr) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+  g_registry.emplace();
+  g_serializer.emplace(os);
+
+  {
+    InstrumentedBar bar;
+    InstrumentedFoo& foo = *(bar.GetInstrumentedFooPtr());
 
     int b = 200;
     float c = 300.3;
     double e = 400.4;
 
     foo.A(100);
     foo.B(b);
     foo.C(&c);