[lldb/Reproducers] Support new replay mode: passive replay

[JDevlieghere]

Summary

Support inline replay as described in the RFC [1] on lldb-dev. This extends the LLDB_RECORD macros to re-invoke the current function with arguments deserialized from the reproducer. This relies on the function being called in the exact same order as during replay. It uses the same mechanism to toggle the API boundary as during recording, which guarantees that only boundary crossing calls are replayed.

Another major change is that before this patch we could ignore the result of an API call, because we only cared about the observable behavior. Now we need to be able to return the replayed result to the SWIG bindings.

We reuse a lot of the recording infrastructure, which can be a little confusing at first. I'm open to renaming these things in a future patch, but I refrained from doing so here to make it easier to review.

[1] http://lists.llvm.org/pipermail/lldb-dev/2020-April/016100.html

[labath]

I haven't looked at the code in details, but some of my high-level concerns are:

• the LLDB_RECORD_*** macros are getting rather long and repetitive. We should try to find a way to move some of that stuff into a regular function and keep the macros for the stuff that cannot be done elsewhere. I'm thinking that instead of:

lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                         stringify_args(__VA_ARGS__));        \
 if (lldb_private::repro::InstrumentationData _data =                         \
         LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
   if (lldb_private::repro::Serializer *_serializer =                         \
           _data.GetSerializer()) {                                           \
     _recorder.Record(*_serializer, _data.GetRegistry(),                      \
                      &lldb_private::repro::construct<Class Signature>::doit, \
                      __VA_ARGS__);                                           \
     _recorder.RecordResult(this, false);                                     \
   } else if (lldb_private::repro::Deserializer *_deserializer =              \
                  _data.GetDeserializer()) {                                  \
     if (_recorder.ShouldCapture()) {                                         \
       lldb_private::repro::replay_construct<Class Signature>::doit(          \
           _recorder, *_deserializer, _data.GetRegistry(),                    \
           LLVM_PRETTY_FUNCTION);                                             \
     }                                                                        \
   }                                                                          \
 }

we could have something like:

lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                          stringify_args(__VA_ARGS__));        \
if (lldb_private::repro::InstrumentationData _data = LLDB_GET_INSTRUMENTATION_DATA() /* is this needed? could the Recorder object tell us when replay is enabled? */) {
  lldb_private::repro::Record/*?*/<lldb_private::repro::construct<Class Signature>>(_recorder, _data/*?*/, anything_else_you_need, __VA_ARGS__)
}

and have the Record ( HandleAPI ?) function handle the details of what should happen in different reproducer modes. The above assumes that lldb_private::repro::construct becomes a class which has not one but two member functions -- basically the merge of the construct and replay_construct functions from the current patch, so that the Record function can select the right operation based on the current mode.

• the chopping of LLVM_PRETTY_FUNCTION in Registry::CheckSignature sounds sub-optimal. It feels like we should be able to obtain the "ids" of both "expected" and "actual" methods and compare those (and have the PRETTY_FUNCTION just be there for error reporting purposes).
• this functionality should have a unit test just like the existing ReproducerInstrumentation.cpp functionality. At that point it should be possible/reasonable to move this patch to the front of the patch set and have the SB wiring come after the underlying infrastructure is set up.

[JDevlieghere]

• Simplify LLDB_RECORD_CONSTRUCTOR macro. The other macros have return statements that need to be inlined in the caller for replay, and the boundary tracking needs to be updated right, so I'm not convinced the extra complexity is worth the deduplication.
• Use the replayer ID to check the signature.

I didn't get around to adding the unit tests yet. I noticed that this change breaks something and I'm still debugging it. I think it's specific to the unit test though, as the test suite isn't affected.

[JDevlieghere]

Add unit tests

[labath]

In D77602#1973804, @JDevlieghere wrote:

• Simplify LLDB_RECORD_CONSTRUCTOR macro. The other macros have return statements that need to be inlined in the caller for replay, and the boundary tracking needs to be updated right, so I'm not convinced the extra complexity is worth the deduplication.

Ok, so how about deduplicating at the macro level then? I.e. something like this:

#define RECORD_(Prototype, Method, ...) \
  do_stuff(invoke<Prototype>:: \
  doit<Method>::record, __VA_ARGS__)

#define RECORD(Result, Class, Method, Signature, ...) \
  RECORD_(Result(Class::*)Signature, &Class::Method, this, __VA_ARGS__)
#define RECORD_CONST(Result, Class, Method, Signature, ...) \
  RECORD_(Result(Class::*)Signature const, &Class::Method, this, __VA_ARGS__)
#define RECORD_NO_ARGS(Result, Class, Method) \
  RECORD_(Result(Class::*)(), &Class::Method, this)
#define RECORD_CONST_NO_ARGS(Result, Class, Method) \
  RECORD_(Result(Class::*)() const, &Class::Method, this)
#define RECORD_STATIC(Result, Class, Method, ...) \
  RECORD_(Result(*)Signature, &Class::Method, __VA_ARGS__)
#define RECORD_STATIC_NO_ARGS(Result, Class, Method) \
  RECORD_(Result(*)(), &Class::Method, 0)

The idea is to make all (most?) macros call a common uber-macro which will contain the nontrivial logic. I believe the scheme above is sufficient to merge all (STATIC_)METHOD(_NO_ARGS) macro flavours. The only slightly non-obvious part is the handling of static no-argument methods. The idea is that the static methods will also pass through the invoke wrapper (although they wouldn't really need to), and that the wrapper for no-argument functions would get an extra bogus argument to keep the preprocessor happy. Then, the no-argument wrapper would get specialized to ignore the extra argument. (a different solution might be to pass std::make_tuple(__VA_ARGS__) or the like, and then unwrap the tuple in the wrapper)

I did not attempt to merge constructors into this flow too. Having two copies of this code (one for constructors, one for regular functions) may not be too bad. OTOH, it may be possible to handle those too with an extra argument or two...

(btw, it would probably be good to set up the macro logic in a separate patch, before implementing all the passive replay stuff)

lldb/source/API/SBReproducer.cpp

125

Is this right? calling a replay function from a Capture method looks a bit out of place. (And regardless of the answer, would it be possible to initialize this via the Loader constructor -- maybe from Reproducer::Initialize ?)

[JDevlieghere]

Rebase

[labath]

I think we're getting closer, though there is still some duplication that I'd like to eradicate.

lldb/include/lldb/Utility/Reproducer.h

312

Now it looks like nothing is calling this function...

lldb/include/lldb/Utility/ReproducerInstrumentation.h

396

What's up with the const_cast ? Should this maybe take a T &t argument and let T be deduced as const U when needed?

729–735

superfluous semicolons

957–964

All of these replay functions look very similar. Can they be factored into some method on the Recorder class or something. It looks like the only thing that really changes is uintptr_t ID of the method being replayed. That could be passed in as an extra argument.

[JDevlieghere]

Address Pavel's comments

[JDevlieghere]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

396

I need to decode the template instantiation error for the details, but we need to return a non-const T.

[labath]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

396

It would be good to at least know the reason for that, because const_casts smell..

893–898

are you sure that the lldb_private::repro::construct<Class(Args...)>:: qualifications are necessary here?

lldb/source/API/SBReproducerPrivate.h

80–85

Could this be done in the initialization code somewhere (inside Reproducer::Initialize, I guess)? We could avoid static variables and get better error handling that way...

lldb/unittests/Utility/ReproducerInstrumentationTest.cpp

91–95 ↗

(On Diff #257751)

This works only accidentally because the compiler NRVO-s the temporary object. But that's not guaranteed to happen and could cause the TestInstrumentationDataRAII destructor to run twice. The simplest way to ensure the behavior you want is to return a unique_ptr to a constructed object (as well as delete all copy operations)...

1044 ↗

(On Diff #257751)

Maybe an EXPECT_DEATH test case for what happens when the replayed function calls don't line up?

[JDevlieghere]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

396

The problem is that you cannot cannot bind a non-const lvalue reference of type T& to an rvalue of type T.

lldb/source/API/SBReproducerPrivate.h

80–85

Not if we want to keep the SBProvider in API instead of Utility.

[labath]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

396

The usual solution to that is to use "universal" references (<typename T> T &&t) plus careful sprinkling with std::forward. Would that work here?

Or a separate overload for const and non-const references?

lldb/source/API/SBReproducerPrivate.h

80–85

Right, of course.

Soo... do it one level higher then? Initialize the object in SBReproducer::(Passive)Replay, and use it from here?

[JDevlieghere]

• Remove const_cast
• Initialize instrumentation data in SBReproducer.cpp

[labath]

Looks good to me.

lldb/include/lldb/Utility/ReproducerInstrumentation.h

206–207

bad formatting ?

lldb/include/lldb/Utility/Reproducer.h

if (!buffer)
       return llvm::errorCodeToError(buffer.getError());
     return (*buffer)->getBuffer().str();
   }
 
   llvm::Error LoadIndex();
 
   const FileSpec &GetRoot() const { return m_root; }
 
+  void SetPassiveReplay(bool b) { m_passive_replay = b; }
+
+  bool IsPassiveReplay() const { return m_passive_replay; }
+
 private:
   bool HasFile(llvm::StringRef file);
 
   FileSpec m_root;
   std::vector<std::string> m_files;
   bool m_loaded;
+  bool m_passive_replay;
 };
 
 /// The reproducer enables clients to obtain access to the Generator and
 /// Loader.
 class Reproducer {
 public:
   static Reproducer &Instance();
   static llvm::Error Initialize(ReproducerMode mode,

lldb/include/lldb/Utility/ReproducerInstrumentation.h

 }
 
 // Define LLDB_REPRO_INSTR_TRACE to trace to stderr instead of LLDB's log
 // infrastructure. This is useful when you need to see traces before the logger
 // is initialized or enabled.
 // #define LLDB_REPRO_INSTR_TRACE
 
 #define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)                            \
-  R.Register<Class * Signature>(&construct<Class Signature>::doit, "", #Class, \
-                                #Class, #Signature)
+  R.Register<Class * Signature>(&construct<Class Signature>::record, "",       \
+                                #Class, #Class, #Signature)
 #define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)                 \
   R.Register(                                                                  \
-      &invoke<Result(Class::*) Signature>::method<(&Class::Method)>::doit,     \
+      &invoke<Result(Class::*) Signature>::method<(&Class::Method)>::record,   \
       #Result, #Class, #Method, #Signature)
 #define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)           \
   R.Register(&invoke<Result(Class::*) Signature const>::method_const<(         \
-                 &Class::Method)>::doit,                                       \
+                 &Class::Method)>::record,                                     \
              #Result, #Class, #Method, #Signature)
 #define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature)          \
-  R.Register<Result Signature>(                                                \
-      static_cast<Result(*) Signature>(&Class::Method), #Result, #Class,       \
-      #Method, #Signature)
+  R.Register(                                                                  \
+      &invoke<Result(*) Signature>::method_static<(&Class::Method)>::record,   \
+      #Result, #Class, #Method, #Signature)
 
 #define LLDB_REGISTER_CHAR_PTR_REDIRECT_STATIC(Result, Class, Method)          \
   {                                                                            \
-    static auto _redirect = [](char *s, size_t l) -> Result {                  \
-      return char_ptr_redirect_static<Result>(Class::Method, s, l);            \
-    };                                                                         \
-    R.Register<Result(char *, size_t)>(                                        \
-        static_cast<Result (*)(char *, size_t)>(&Class::Method), _redirect,    \
-        #Result, #Class, #Method, "(char*, size_t");                           \
+    R.Register(&invoke<Result (*)(char *, size_t)>::method_static<(            \
+                   &Class::Method)>::record,                                   \
+               &char_ptr_redirect<Result (*)(char *, size_t)>::method_static<( \
+                   &Class::Method)>::record,                                   \
+               #Result, #Class, #Method, "(char*, size_t");                    \
   }
 #define LLDB_REGISTER_CHAR_PTR_REDIRECT(Result, Class, Method)                 \
   {                                                                            \
     R.Register(&invoke<Result (Class::*)(char *, size_t)>::method<(            \
-                   &Class::Method)>::doit,                                     \
+                   &Class::Method)>::record,                                   \
                &char_ptr_redirect<Result (Class::*)(char *, size_t)>::method<( \
-                   &Class::Method)>::doit,                                     \
+                   &Class::Method)>::record,                                   \
                #Result, #Class, #Method, "(char*, size_t");                    \
   }
 #define LLDB_REGISTER_CHAR_PTR_REDIRECT_CONST(Result, Class, Method)           \
   {                                                                            \
     R.Register(                                                                \
         &invoke<Result (Class::*)(char *, size_t)                              \
-                    const>::method_const<(&Class::Method)>::doit,              \
+                    const>::method_const<(&Class::Method)>::record,            \
         &char_ptr_redirect<Result (Class::*)(char *, size_t)                   \
-                               const>::method_const<(&Class::Method)>::doit,   \
+                               const>::method_const<(&Class::Method)>::record, \
         #Result, #Class, #Method, "(char*, size_t");                           \
   }
 
 #define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...)                         \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(__VA_ARGS__));        \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::construct<Class Signature>::doit,   \
-                     __VA_ARGS__);                                             \
-    _recorder.RecordResult(this, false);                                       \
+  {                                                                            \
+    lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,              \
+                                            stringify_args(__VA_ARGS__));      \
+    lldb_private::repro::construct<Class Signature>::handle(                   \
+        LLDB_GET_INSTRUMENTATION_DATA(), _recorder, LLVM_PRETTY_FUNCTION,      \
+        this, __VA_ARGS__);                                                    \
   }
 
 #define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)                                 \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);               \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::construct<Class()>::doit);          \
-    _recorder.RecordResult(this, false);                                       \
+  {                                                                            \
+    lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);             \
+    lldb_private::repro::construct<Class()>::handle(                           \
+        LLDB_GET_INSTRUMENTATION_DATA(), _recorder, LLVM_PRETTY_FUNCTION,      \
+        this);                                                                 \
   }
 
 #define LLDB_RECORD_METHOD(Result, Class, Method, Signature, ...)              \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                           stringify_args(*this, __VA_ARGS__)); \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::invoke<Result(                      \
-                         Class::*) Signature>::method<(&Class::Method)>::doit, \
-                     this, __VA_ARGS__);                                       \
+    if (lldb_private::repro::Serializer *_serializer =                         \
+            _data.GetSerializer()) {                                           \
+      _recorder.Record(                                                        \
+          *_serializer, _data.GetRegistry(),                                   \
+          &lldb_private::repro::invoke<Result(Class::*) Signature>::method<(   \
+              &Class::Method)>::record,                                        \
+          this, __VA_ARGS__);                                                  \
+    } else if (lldb_private::repro::Deserializer *_deserializer =              \
+                   _data.GetDeserializer()) {                                  \
+      if (_recorder.ShouldCapture()) {                                         \
+        return lldb_private::repro::invoke<Result(Class::*) Signature>::       \
+            method<&Class::Method>::replay(_recorder, *_deserializer,          \
+                                           _data.GetRegistry(),                \
+                                           LLVM_PRETTY_FUNCTION);              \
+      }                                                                        \
+    }                                                                          \
   }
 
 #define LLDB_RECORD_METHOD_CONST(Result, Class, Method, Signature, ...)        \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                           stringify_args(*this, __VA_ARGS__)); \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(                                                          \
-        _data.GetSerializer(), _data.GetRegistry(),                            \
-        &lldb_private::repro::invoke<Result(                                   \
-            Class::*) Signature const>::method_const<(&Class::Method)>::doit,  \
-        this, __VA_ARGS__);                                                    \
+    if (lldb_private::repro::Serializer *_serializer =                         \
+            _data.GetSerializer()) {                                           \
+      _recorder.Record(                                                        \
+          *_serializer, _data.GetRegistry(),                                   \
+          &lldb_private::repro::invoke<Result(Class::*) Signature const>::     \
+              method_const<(&Class::Method)>::record,                          \
+          this, __VA_ARGS__);                                                  \
+    } else if (lldb_private::repro::Deserializer *_deserializer =              \
+                   _data.GetDeserializer()) {                                  \
+      if (_recorder.ShouldCapture()) {                                         \
+        return lldb_private::repro::invoke<Result(Class::*) Signature const>:: \
+            method_const<&Class::Method>::replay(_recorder, *_deserializer,    \
+                                                 _data.GetRegistry(),          \
+                                                 LLVM_PRETTY_FUNCTION);        \
+      }                                                                        \
+    }                                                                          \
   }
 
 #define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)                      \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                           stringify_args(*this));              \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::invoke<Result (                     \
-                         Class::*)()>::method<(&Class::Method)>::doit,         \
-                     this);                                                    \
+    if (lldb_private::repro::Serializer *_serializer =                         \
+            _data.GetSerializer()) {                                           \
+      _recorder.Record(*_serializer, _data.GetRegistry(),                      \
+                       &lldb_private::repro::invoke<Result (                   \
+                           Class::*)()>::method<(&Class::Method)>::record,     \
+                       this);                                                  \
+    } else if (lldb_private::repro::Deserializer *_deserializer =              \
+                   _data.GetDeserializer()) {                                  \
+      if (_recorder.ShouldCapture()) {                                         \
+        return lldb_private::repro::invoke<Result (Class::*)()>::method<       \
+            &Class::Method>::replay(_recorder, *_deserializer,                 \
+                                    _data.GetRegistry(),                       \
+                                    LLVM_PRETTY_FUNCTION);                     \
+      }                                                                        \
+    }                                                                          \
   }
 
 #define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)                \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                           stringify_args(*this));              \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(                                                          \
-        _data.GetSerializer(), _data.GetRegistry(),                            \
-        &lldb_private::repro::invoke<Result (                                  \
-            Class::*)() const>::method_const<(&Class::Method)>::doit,          \
-        this);                                                                 \
+    if (lldb_private::repro::Serializer *_serializer =                         \
+            _data.GetSerializer()) {                                           \
+      _recorder.Record(                                                        \
+          *_serializer, _data.GetRegistry(),                                   \
+          &lldb_private::repro::invoke<Result (                                \
+              Class::*)() const>::method_const<(&Class::Method)>::record,      \
+          this);                                                               \
+    } else if (lldb_private::repro::Deserializer *_deserializer =              \
+                   _data.GetDeserializer()) {                                  \
+      if (_recorder.ShouldCapture()) {                                         \
+        return lldb_private::repro::invoke<Result (Class::*)() const>::        \
+            method_const<(&Class::Method)>::replay(_recorder, *_deserializer,  \
+                                                   _data.GetRegistry(),        \
+                                                   LLVM_PRETTY_FUNCTION);      \
+      }                                                                        \
+    }                                                                          \
   }
 
 #define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature, ...)       \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                           stringify_args(__VA_ARGS__));        \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     static_cast<Result(*) Signature>(&Class::Method),         \
-                     __VA_ARGS__);                                             \
+    if (lldb_private::repro::Serializer *_serializer =                         \
+            _data.GetSerializer()) {                                           \
+      _recorder.Record(                                                        \
+          *_serializer, _data.GetRegistry(),                                   \
+          lldb_private::repro::invoke<Result(*) Signature>::method_static<(    \
+              &Class::Method)>::record,                                        \
+          __VA_ARGS__);                                                        \
+    } else if (lldb_private::repro::Deserializer *_deserializer =              \
+                   _data.GetDeserializer()) {                                  \
+      if (_recorder.ShouldCapture()) {                                         \
+        return lldb_private::repro::invoke<Result(*) Signature>::              \
+            method_static<(&Class::Method)>::replay(_recorder, *_deserializer, \
+                                                    _data.GetRegistry(),       \
+                                                    LLVM_PRETTY_FUNCTION);     \
+      }                                                                        \
+    }                                                                          \
   }
 
 #define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method)               \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);               \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     static_cast<Result (*)()>(&Class::Method));               \
+    if (lldb_private::repro::Serializer *_serializer =                         \
+            _data.GetSerializer()) {                                           \
+      _recorder.Record(                                                        \
+          *_serializer, _data.GetRegistry(),                                   \
+          lldb_private::repro::invoke<Result (*)()>::method_static<(           \
+              &Class::Method)>::record);                                       \
+    } else if (lldb_private::repro::Deserializer *_deserializer =              \
+                   _data.GetDeserializer()) {                                  \
+      if (_recorder.ShouldCapture()) {                                         \
+        return lldb_private::repro::invoke<Result (*)()>::method_static<(      \
+            &Class::Method)>::replay(_recorder, *_deserializer,                \
+                                     _data.GetRegistry(),                      \
+                                     LLVM_PRETTY_FUNCTION);                    \
+      }                                                                        \
+    }                                                                          \
   }
 
 #define LLDB_RECORD_RESULT(Result) _recorder.RecordResult(Result, true);
 
 /// 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, ...)               \
public:
   /// present in the map.
   template <typename T> T *GetObjectForIndex(unsigned idx) {
     assert(idx != 0 && "Cannot get object for sentinel");
     void *object = GetObjectForIndexImpl(idx);
     return static_cast<T *>(object);
   }
 
   /// Adds a pointer to an object to the mapping for the given index.
-  template <typename T> void AddObjectForIndex(unsigned idx, T *object) {
+  template <typename T> T *AddObjectForIndex(unsigned idx, T *object) {
     AddObjectForIndexImpl(
         idx, static_cast<void *>(
                  const_cast<typename std::remove_const<T>::type *>(object)));
+    return object;
   }
 
   /// Adds a reference to an object to the mapping for the given index.
-  template <typename T> void AddObjectForIndex(unsigned idx, T &object) {
+  template <typename T> T &AddObjectForIndex(unsigned idx, T &object) {
     AddObjectForIndexImpl(
         idx, static_cast<void *>(
                  const_cast<typename std::remove_const<T>::type *>(&object)));
+    return object;
   }
 
 private:
   /// Helper method that does the actual lookup. The void* result is later cast
   /// by the caller.
   void *GetObjectForIndexImpl(unsigned idx);
 
   /// Helper method that does the actual insertion.

 #ifdef LLDB_REPRO_INSTR_TRACE
     llvm::errs() << "Deserializing with " << LLVM_PRETTY_FUNCTION << " -> "
                  << stringify_args(t) << "\n";
 #endif
     return t;
   }
 
   /// Store the returned value in the index-to-object mapping.
-  template <typename T> void HandleReplayResult(const T &t) {
+  template <typename T> T &HandleReplayResult(const T &t) {
     unsigned result = Deserialize<unsigned>();
     if (is_trivially_serializable<T>::value)
-      return;
+      return const_cast<T &>(t);
     // We need to make a copy as the original object might go out of scope.
-    m_index_to_object.AddObjectForIndex(result, new T(t));
+    return *m_index_to_object.AddObjectForIndex(result, new T(t));
   }
 
   /// Store the returned value in the index-to-object mapping.
-  template <typename T> void HandleReplayResult(T *t) {
+  template <typename T> T *HandleReplayResult(T *t) {
     unsigned result = Deserialize<unsigned>();
     if (is_trivially_serializable<T>::value)
-      return;
-    m_index_to_object.AddObjectForIndex(result, t);
+      return t;
+    return m_index_to_object.AddObjectForIndex(result, t);
   }
 
   /// All returned types are recorded, even when the function returns a void.
   /// The latter requires special handling.
   void HandleReplayResultVoid() {
     unsigned result = Deserialize<unsigned>();
     assert(result == 0);
     (void)result;

 
 /// The default replayer deserializes the arguments and calls the function.
 template <typename Signature> struct DefaultReplayer;
 template <typename Result, typename... Args>
 struct DefaultReplayer<Result(Args...)> : public Replayer {
   DefaultReplayer(Result (*f)(Args...)) : Replayer(), f(f) {}
 
   void operator()(Deserializer &deserializer) const override {
-    deserializer.HandleReplayResult(
+    Replay(deserializer);
+  }
+
+  Result Replay(Deserializer &deserializer) const {
+    return deserializer.HandleReplayResult(
         DeserializationHelper<Args...>::template deserialized<Result>::doit(
             deserializer, f));
   }
 
   Result (*f)(Args...);
 };
 
 /// Partial specialization for function returning a void type. It ignores the
 /// (absent) return value.
 template <typename... Args>
 struct DefaultReplayer<void(Args...)> : public Replayer {
   DefaultReplayer(void (*f)(Args...)) : Replayer(), f(f) {}
 
   void operator()(Deserializer &deserializer) const override {
+    Replay(deserializer);
+  }
+
+  void Replay(Deserializer &deserializer) const {
     DeserializationHelper<Args...>::template deserialized<void>::doit(
         deserializer, f);
     deserializer.HandleReplayResultVoid();
   }
 
   void (*f)(Args...);
 };
 
public:
   bool Replay(const FileSpec &file);
 
   /// Replay functions from a buffer.
   bool Replay(llvm::StringRef buffer);
 
   /// Returns the ID for a given function address.
   unsigned GetID(uintptr_t addr);
 
+  /// Get the replayer matching the given ID.
+  Replayer *GetReplayer(unsigned id);
+
+  std::string GetSignature(unsigned id);
+
+  void CheckID(unsigned expected, unsigned actual);
+
 protected:
   /// Register the given replayer for a function (and the ID mapping).
   void DoRegister(uintptr_t RunID, std::unique_ptr<Replayer> replayer,
                   SignatureStr signature);
 
 private:
-  std::string GetSignature(unsigned id);
-  Replayer *GetReplayer(unsigned id);
-
   /// Mapping of function addresses to replayers and their ID.
   std::map<uintptr_t, std::pair<std::unique_ptr<Replayer>, unsigned>>
       m_replayers;
 
   /// Mapping of IDs to replayer instances.
   std::map<unsigned, std::pair<Replayer *, SignatureStr>> m_ids;
 };
 
-/// To be used as the "Runtime ID" of a constructor. It also invokes the
-/// constructor when called.
-template <typename Signature> struct construct;
-template <typename Class, typename... Args> struct construct<Class(Args...)> {
-  static Class *doit(Args... args) { return new Class(args...); }
-};
-
-/// To be used as the "Runtime ID" of a member function. It also invokes the
-/// member function when called.
-template <typename Signature> struct invoke;
-template <typename Result, typename Class, typename... Args>
-struct invoke<Result (Class::*)(Args...)> {
-  template <Result (Class::*m)(Args...)> struct method {
-    static Result doit(Class *c, Args... args) { return (c->*m)(args...); }
-  };
-};
-
-template <typename Result, typename Class, typename... Args>
-struct invoke<Result (Class::*)(Args...) const> {
-  template <Result (Class::*m)(Args...) const> struct method_const {
-    static Result doit(Class *c, Args... args) { return (c->*m)(args...); }
-  };
-};
-
-template <typename Class, typename... Args>
-struct invoke<void (Class::*)(Args...)> {
-  template <void (Class::*m)(Args...)> struct method {
-    static void doit(Class *c, Args... args) { (c->*m)(args...); }
-  };
-};
-
 /// Maps an object to an index for serialization. Indices are unique and
 /// incremented for every new object.
 ///
 /// Indices start at 1 in order to differentiate with an invalid index (0) in
 /// the serialized buffer.
 class ObjectToIndex {
 public:
   template <typename T> unsigned GetIndexForObject(T *t) {
#endif
   llvm::raw_ostream &m_stream;
 
   /// Mapping of objects to indices.
   ObjectToIndex m_tracker;
 };
 
 class InstrumentationData {
 public:
-  InstrumentationData() : m_serializer(nullptr), m_registry(nullptr){};
+  InstrumentationData()
+      : m_serializer(nullptr), m_deserializer(nullptr), m_registry(nullptr){};
   InstrumentationData(Serializer &serializer, Registry &registry)
-      : m_serializer(&serializer), m_registry(&registry){};
+      : m_serializer(&serializer), m_deserializer(nullptr),
+        m_registry(&registry){};
+  InstrumentationData(Deserializer &deserializer, Registry &registry)
+      : m_serializer(nullptr), m_deserializer(&deserializer),
+        m_registry(&registry){};
 
-  Serializer &GetSerializer() { return *m_serializer; }
+  Serializer *GetSerializer() { return m_serializer; }
+  Deserializer *GetDeserializer() { return m_deserializer; }
   Registry &GetRegistry() { return *m_registry; }
 
-  operator bool() { return m_serializer != nullptr && m_registry != nullptr; }
+  operator bool() {
+    return (m_serializer != nullptr || m_deserializer != nullptr) &&
+           m_registry != nullptr;
+  }
 
 private:
   Serializer *m_serializer;
+  Deserializer *m_deserializer;
   Registry *m_registry;
 };
 
 /// RAII object that records function invocations and their return value.
 ///
 /// API calls are only captured when the API boundary is crossed. Once we're in
 /// the API layer, and another API function is called, it doesn't need to be
 /// recorded.
Result RecordResult(Result &&r, bool update_boundary) {
     if (m_serializer && ShouldCapture()) {
       assert(!m_result_recorded);
       m_serializer->SerializeAll(r);
       m_result_recorded = true;
     }
     return std::forward<Result>(r);
   }
 
+  template <typename Result>
+  Result ReplayResult(Result &&r, bool update_boundary) {
+    if (update_boundary)
+      UpdateBoundary();
+    return std::forward<Result>(r);
+  }
+
+  bool ShouldCapture() { return m_local_boundary; }
+
 private:
+  template <typename T> friend struct replay;
   void UpdateBoundary() {
     if (m_local_boundary)
       g_global_boundary = false;
   }
 
-  bool ShouldCapture() { return m_local_boundary; }
-
 #ifdef LLDB_REPRO_INSTR_TRACE
   void Log(unsigned id) {
     llvm::errs() << "Recording " << id << ": " << m_pretty_func << " ("
                  << m_pretty_args << ")\n";
   }
 #endif
 
   Serializer *m_serializer;
 
   /// Pretty function for logging.
   llvm::StringRef m_pretty_func;
   std::string m_pretty_args;
 
   /// Whether this function call was the one crossing the API boundary.
   bool m_local_boundary;
 
   /// Whether the return value was recorded explicitly.
   bool m_result_recorded;
 
   /// Whether we're currently across the API boundary.
   static bool g_global_boundary;
 };
 
+/// To be used as the "Runtime ID" of a constructor. It also invokes the
+/// constructor when called.
+template <typename Signature> struct construct;
+template <typename Class, typename... Args> struct construct<Class(Args...)> {
+  static Class *handle(lldb_private::repro::InstrumentationData data,
+                       lldb_private::repro::Recorder &recorder,
+                       llvm::StringRef signature, Class *c, Args... args) {
+    if (!data)
+      return nullptr;
+
+    if (Serializer *serializer = data.GetSerializer()) {
+      recorder.Record(*serializer, data.GetRegistry(),
+                      &lldb_private::repro::construct<Class(Args...)>::record,
+                      args...);
+      recorder.RecordResult(c, false);
+    } else if (Deserializer *deserializer = data.GetDeserializer()) {
+      if (recorder.ShouldCapture()) {
+        lldb_private::repro::construct<Class(Args...)>::replay(
+            recorder, *deserializer, data.GetRegistry(), signature);
+      }
+    }
+
+    return nullptr;
+  }
+
+  static Class *record(Args... args) { return new Class(args...); }
+
+  static Class *replay(Recorder &recorder, Deserializer &deserializer,
+                       Registry &registry, llvm::StringRef signature) {
+    unsigned actual_id = registry.GetID(uintptr_t(&record));
+    unsigned id = deserializer.Deserialize<unsigned>();
+    registry.CheckID(id, actual_id);
+    return recorder.ReplayResult(
+        static_cast<DefaultReplayer<Class *(Args...)> *>(
+            registry.GetReplayer(id))
+            ->Replay(deserializer),
+        false);
+  }
+};
+
+/// To be used as the "Runtime ID" of a member function. It also invokes the
+/// member function when called.
+template <typename Signature> struct invoke;
+template <typename Result, typename Class, typename... Args>
+struct invoke<Result (Class::*)(Args...)> {
+  template <Result (Class::*m)(Args...)> struct method {
+    static Result record(Class *c, Args... args) { return (c->*m)(args...); }
+
+    static Result replay(Recorder &recorder, Deserializer &deserializer,
+                         Registry &registry, llvm::StringRef signature) {
+      unsigned actual_id = registry.GetID(uintptr_t(&record));
+      unsigned id = deserializer.Deserialize<unsigned>();
+      registry.CheckID(id, actual_id);
+      return recorder.ReplayResult<Result>(
+          static_cast<DefaultReplayer<Result(Class *, Args...)> *>(
+              registry.GetReplayer(id))
+              ->Replay(deserializer),
+          true);
+    }
+  };
+};
+
+template <typename Class, typename... Args>
+struct invoke<void (Class::*)(Args...)> {
+  template <void (Class::*m)(Args...)> struct method {
+    static void record(Class *c, Args... args) { (c->*m)(args...); }
+    static void replay(Recorder &recorder, Deserializer &deserializer,
+                       Registry &registry, llvm::StringRef signature) {
+      unsigned actual_id = registry.GetID(uintptr_t(&record));
+      unsigned id = deserializer.Deserialize<unsigned>();
+      registry.CheckID(id, actual_id);
+      registry.GetReplayer(id)->operator()(deserializer);
+    }
+  };
+};
+
+template <typename Result, typename Class, typename... Args>
+struct invoke<Result (Class::*)(Args...) const> {
+  template <Result (Class::*m)(Args...) const> struct method_const {
+    static Result record(Class *c, Args... args) { return (c->*m)(args...); }
+    static Result replay(Recorder &recorder, Deserializer &deserializer,
+                         Registry &registry, llvm::StringRef signature) {
+      unsigned actual_id = registry.GetID(uintptr_t(&record));
+      unsigned id = deserializer.Deserialize<unsigned>();
+      registry.CheckID(id, actual_id);
+      return recorder.ReplayResult<Result>(
+          static_cast<DefaultReplayer<Result(Class *, Args...)> *>(
+              registry.GetReplayer(id))
+              ->Replay(deserializer),
+          true);
+    }
+  };
+};
+
+template <typename Class, typename... Args>
+struct invoke<void (Class::*)(Args...) const> {
+  template <void (Class::*m)(Args...) const> struct method_const {
+    static void record(Class *c, Args... args) { return (c->*m)(args...); }
+    static void replay(Recorder &recorder, Deserializer &deserializer,
+                       Registry &registry, llvm::StringRef signature) {
+      unsigned actual_id = registry.GetID(uintptr_t(&record));
+      unsigned id = deserializer.Deserialize<unsigned>();
+      registry.CheckID(id, actual_id);
+      registry.GetReplayer(id)->operator()(deserializer);
+    }
+  };
+};
+
+template <typename Signature> struct replay;
+
+template <typename Result, typename Class, typename... Args>
+struct replay<Result (Class::*)(Args...)> {
+  template <Result (Class::*m)(Args...)> struct method {};
+};
+
+template <typename Result, typename... Args>
+struct invoke<Result (*)(Args...)> {
+  template <Result (*m)(Args...)> struct method_static {
+    static Result record(Args... args) { return (*m)(args...); }
+    static Result replay(Recorder &recorder, Deserializer &deserializer,
+                         Registry &registry, llvm::StringRef signature) {
+      unsigned actual_id = registry.GetID(uintptr_t(&record));
+      unsigned id = deserializer.Deserialize<unsigned>();
+      registry.CheckID(id, actual_id);
+      return recorder.ReplayResult<Result>(
+          static_cast<DefaultReplayer<Result(Args...)> *>(
+              registry.GetReplayer(id))
+              ->Replay(deserializer),
+          true);
+    }
+  };
+};
+
+template <typename... Args> struct invoke<void (*)(Args...)> {
+  template <void (*m)(Args...)> struct method_static {
+    static void record(Args... args) { return (*m)(args...); }
+    static void replay(Recorder &recorder, Deserializer &deserializer,
+                       Registry &registry, llvm::StringRef signature) {
+      unsigned actual_id = registry.GetID(uintptr_t(&record));
+      unsigned id = deserializer.Deserialize<unsigned>();
+      registry.CheckID(id, actual_id);
+      registry.GetReplayer(id)->operator()(deserializer);
+    }
+  };
+};
+
 template <typename Signature> struct char_ptr_redirect;
 template <typename Result, typename Class>
 struct char_ptr_redirect<Result (Class::*)(char *, size_t) const> {
   template <Result (Class::*m)(char *, size_t) const> struct method_const {
-    static Result doit(Class *c, char *s, size_t l) {
+    static Result record(Class *c, char *s, size_t l) {
       char *buffer = reinterpret_cast<char *>(calloc(l, sizeof(char)));
       return (c->*m)(buffer, l);
     }
   };
 };
 template <typename Result, typename Class>
 struct char_ptr_redirect<Result (Class::*)(char *, size_t)> {
   template <Result (Class::*m)(char *, size_t)> struct method {
-    static Result doit(Class *c, char *s, size_t l) {
+    static Result record(Class *c, char *s, size_t l) {
       char *buffer = reinterpret_cast<char *>(calloc(l, sizeof(char)));
       return (c->*m)(buffer, l);
     }
   };
 };
-
 template <typename Result>
-Result char_ptr_redirect_static(Result (*f)(char *, size_t), char *s,
-                                size_t l) {
+struct char_ptr_redirect<Result (*)(char *, size_t)> {
+  template <Result (*m)(char *, size_t)> struct method_static {
+    static Result record(char *s, size_t l) {
       char *buffer = reinterpret_cast<char *>(calloc(l, sizeof(char)));
-  return f(buffer, l);
+      return (*m)(buffer, l);
     }
+  };
+};
 
 } // namespace repro
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_REPRODUCERINSTRUMENTATION_H

lldb/source/API/SBDebugger.cpp

 }
 
 static SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); }
 
 static SBError SetFileRedirect(SBDebugger *, FileSP file) { return SBError(); }
 
 template <> void RegisterMethods<SBDebugger>(Registry &R) {
   // Custom implementation.
-  R.Register(&invoke<void (SBDebugger::*)(
-                 FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
+  R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method<
+                 &SBDebugger::SetErrorFileHandle>::record,
              &SetFileHandleRedirect);
-  R.Register(&invoke<void (SBDebugger::*)(
-                 FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
+  R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method<
+                 &SBDebugger::SetOutputFileHandle>::record,
              &SetFileHandleRedirect);
 
   R.Register(&invoke<SBError (SBDebugger::*)(
-                 SBFile)>::method<&SBDebugger::SetInputFile>::doit,
+                 SBFile)>::method<&SBDebugger::SetInputFile>::record,
              &SetFileRedirect);
   R.Register(&invoke<SBError (SBDebugger::*)(
-                 SBFile)>::method<&SBDebugger::SetOutputFile>::doit,
+                 SBFile)>::method<&SBDebugger::SetOutputFile>::record,
              &SetFileRedirect);
   R.Register(&invoke<SBError (SBDebugger::*)(
-                 SBFile)>::method<&SBDebugger::SetErrorFile>::doit,
+                 SBFile)>::method<&SBDebugger::SetErrorFile>::record,
              &SetFileRedirect);
 
   R.Register(&invoke<SBError (SBDebugger::*)(
-                 FileSP)>::method<&SBDebugger::SetInputFile>::doit,
+                 FileSP)>::method<&SBDebugger::SetInputFile>::record,
              &SetFileRedirect);
   R.Register(&invoke<SBError (SBDebugger::*)(
-                 FileSP)>::method<&SBDebugger::SetOutputFile>::doit,
+                 FileSP)>::method<&SBDebugger::SetOutputFile>::record,
              &SetFileRedirect);
   R.Register(&invoke<SBError (SBDebugger::*)(
-                 FileSP)>::method<&SBDebugger::SetErrorFile>::doit,
+                 FileSP)>::method<&SBDebugger::SetErrorFile>::record,
              &SetFileRedirect);
 
   LLDB_REGISTER_CHAR_PTR_REDIRECT_STATIC(bool, SBDebugger,
                                          GetDefaultArchitecture);
 
   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));

lldb/source/API/SBReproducer.cpp

 const char *SBReproducer::Capture(const char *path) {
   static std::string error;
   if (auto e =
           Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) {
     error = llvm::toString(std::move(e));
     return error.c_str();
   }
   return nullptr;
 }
 
 const char *SBReproducer::PassiveReplay(const char *path) {
   static std::string error;
   if (auto e = Reproducer::Initialize(ReproducerMode::Replay, FileSpec(path))) {
     error = llvm::toString(std::move(e));
     return error.c_str();
   }
+  repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
+  loader->SetAPIReplay(true);
   return nullptr;
 }
 
 const char *SBReproducer::Replay(const char *path) {
   return SBReproducer::Replay(path, false);
 }
 
 const char *SBReproducer::Replay(const char *path, bool skip_version_check) {

lldb/source/API/SBReproducerPrivate.h

 
 private:
   std::error_code m_ec;
   llvm::raw_fd_ostream m_stream;
   Serializer m_serializer;
   SBRegistry m_registry;
 };
 
+class ReplayData {
+public:
+  ReplayData(llvm::StringRef buffer) : m_registry(), m_deserializer(buffer) {}
+  Deserializer &GetDeserializer() { return m_deserializer; }
+  Registry &GetRegistry() { return m_registry; }
+
+private:
+  SBRegistry m_registry;
+  Deserializer m_deserializer;
+};
+
 inline InstrumentationData GetInstrumentationData() {
   if (!lldb_private::repro::Reproducer::Initialized())
     return {};
 
   if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
     auto &p = g->GetOrCreate<SBProvider>();
     return {p.GetSerializer(), p.GetRegistry()};
   }
 
+  if (auto *l = lldb_private::repro::Reproducer::Instance().GetLoader()) {
+    if (l->IsPassiveReplay()) {
+      FileSpec file = l->GetFile<SBProvider::Info>();
+      static auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
+      if (!error_or_file)
+        return {};
+      static ReplayData r((*error_or_file)->getBuffer());
+      return {r.GetDeserializer(), r.GetRegistry()};
+    }
+  }
+
   return {};
 }
 
 template <typename T> void RegisterMethods(Registry &R);
 
 } // namespace repro
 } // namespace lldb_private
 
 #endif

lldb/source/Utility/Reproducer.cpp

void Generator::AddProvidersToIndex() {
   for (auto &provider : m_providers) {
     files.emplace_back(provider.second->GetFile());
   }
 
   yout << files;
 }
 
 Loader::Loader(FileSpec root)
-    : m_root(MakeAbsolute(std::move(root))), m_loaded(false) {}
+    : m_root(MakeAbsolute(std::move(root))), m_loaded(false),
+      m_passive_replay(false) {}
 
 llvm::Error Loader::LoadIndex() {
   if (m_loaded)
     return llvm::Error::success();
 
   FileSpec index = m_root.CopyByAppendingPathComponent("index.yaml");
 
   auto error_or_file = MemoryBuffer::getFile(index.GetPath());

lldb/source/Utility/ReproducerInstrumentation.cpp

 //===-- ReproducerInstrumentation.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/ReproducerInstrumentation.h"
 #include "lldb/Utility/Reproducer.h"
-#include <thread>
 #include <stdio.h>
 #include <stdlib.h>
+#include <thread>
 
 using namespace lldb_private;
 using namespace lldb_private::repro;
 
 void *IndexToObject::GetObjectForIndexImpl(unsigned idx) {
   return m_mapping.lookup(idx);
 }
 
#else
     llvm::errs() << "Replaying " << id << ": " << GetSignature(id) << "\n";
 #endif
 
     GetReplayer(id)->operator()(deserializer);
   }
 
   // Add a small artificial delay to ensure that all asynchronous events have
   // completed before we exit.
-  std::this_thread::sleep_for (std::chrono::milliseconds(100));
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
   return true;
 }
 
 void Registry::DoRegister(uintptr_t RunID, std::unique_ptr<Replayer> replayer,
                           SignatureStr signature) {
   const unsigned id = m_replayers.size() + 1;
   assert(m_replayers.find(RunID) == m_replayers.end());
   m_replayers[RunID] = std::make_pair(std::move(replayer), id);
   m_ids[id] =
       std::make_pair(m_replayers[RunID].first.get(), std::move(signature));
 }
 
 unsigned Registry::GetID(uintptr_t addr) {
   unsigned id = m_replayers[addr].second;
   assert(id != 0 && "Forgot to add function to registry?");
   return id;
 }
 
 std::string Registry::GetSignature(unsigned id) {
   assert(m_ids.count(id) != 0 && "ID not in registry");
   return m_ids[id].second.ToString();
 }
 
+void Registry::CheckID(unsigned expected, unsigned actual) {
+  if (expected != actual) {
+    llvm::errs() << "Reproducer expected signature " << expected << ": '"
+                 << GetSignature(expected) << "'\n";
+    llvm::errs() << "Reproducer actual signature " << actual << ": '"
+                 << GetSignature(actual) << "'\n";
+    llvm::report_fatal_error(
+        "Detected reproducer replay divergence. Refusing to continue.");
+  }
+
+#ifdef LLDB_REPRO_INSTR_TRACE
+  llvm::errs() << "Replaying " << actual << ": " << GetSignature(actual)
+               << "\n";
+#endif
+}
+
 Replayer *Registry::GetReplayer(unsigned id) {
   assert(m_ids.count(id) != 0 && "ID not in registry");
   return m_ids[id].first;
 }
 
 std::string Registry::SignatureStr::ToString() const {
   return (result + (result.empty() ? "" : " ") + scope + "::" + name + args)
       .str();