[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

131

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

313

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

lldb/include/lldb/Utility/ReproducerInstrumentation.h

307

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?

646–652

superfluous semicolons

915–922

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

307

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

307

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

851–856

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

lldb/source/API/SBReproducerPrivate.h

68–73

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

105–109

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)...

1054

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

307

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

68–73

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

[labath]

lldb/include/lldb/Utility/ReproducerInstrumentation.h

307

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

68–73

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

 namespace lldb_private {
 namespace repro {
 
 class Reproducer;
 
 enum class ReproducerMode {
   Capture,
   Replay,
+  PassiveReplay,
   Off,
 };
 
 /// The provider defines an interface for generating files needed for
 /// reproducing.
 ///
 /// Different components will implement different providers.
 class ProviderBase {
private:
   bool m_done = false;
 
   /// Flag to auto generate a reproducer when it would otherwise be discarded.
   bool m_auto_generate = false;
 };
 
 class Loader final {
 public:
-  Loader(FileSpec root);
+  Loader(FileSpec root, bool passive = false);
 
   template <typename T> FileSpec GetFile() {
     if (!HasFile(T::file))
       return {};
 
     return GetRoot().CopyByAppendingPathComponent(T::file);
   }
 
   template <typename T> llvm::Expected<std::string> LoadBuffer() {
     FileSpec file = GetFile<typename T::Info>();
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer =
         llvm::vfs::getRealFileSystem()->getBufferForFile(file.GetPath());
     if (!buffer)
       return llvm::errorCodeToError(buffer.getError());
     return (*buffer)->getBuffer().str();
   }
 
   llvm::Error LoadIndex();
 
   const FileSpec &GetRoot() const { return m_root; }
 
+  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,
public:
 
   FileSpec GetReproducerPath() const;
 
   bool IsCapturing() { return static_cast<bool>(m_generator); };
   bool IsReplaying() { return static_cast<bool>(m_loader); };
 
 protected:
   llvm::Error SetCapture(llvm::Optional<FileSpec> root);
-  llvm::Error SetReplay(llvm::Optional<FileSpec> root);
+  llvm::Error SetReplay(llvm::Optional<FileSpec> root, bool passive = false);
 
 private:
   static llvm::Optional<Reproducer> &InstanceImpl();
 
   llvm::Optional<Generator> m_generator;
   llvm::Optional<Loader> m_loader;
 
   mutable std::mutex m_mutex;

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<(&Class::Method)>::doit,     \
+                         Signature const>::method<(&Class::Method)>::record,   \
              #Result, #Class, #Method, #Signature)
 
 #define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature)          \
-  R.Register(&invoke<Result(*) Signature>::method<(&Class::Method)>::doit,     \
+  R.Register(&invoke<Result(*) Signature>::method<(&Class::Method)>::record,   \
              #Result, #Class, #Method, #Signature)
 
 #define LLDB_REGISTER_CHAR_PTR_REDIRECT_STATIC(Result, Class, Method)          \
   R.Register(                                                                  \
-      &invoke<Result (*)(char *, size_t)>::method<(&Class::Method)>::doit,     \
-      &char_ptr_redirect<Result (*)(char *,                                    \
-                                    size_t)>::method<(&Class::Method)>::doit,  \
+      &invoke<Result (*)(char *, size_t)>::method<(&Class::Method)>::record,   \
+      &char_ptr_redirect<Result (*)(char *, size_t)>::method<(                 \
+          &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<(&Class::Method)>::doit,               \
+                         const>::method<(&Class::Method)>::record,             \
              &char_ptr_redirect<Result (Class::*)(char *, size_t)              \
-                                    const>::method<(&Class::Method)>::doit,    \
+                                    const>::method<(&Class::Method)>::record,  \
              #Result, #Class, #Method, "(char*, size_t");
 
-#define LLDB_CONSTRUCT_(T, ...)                                                \
-  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::construct<T>::doit, __VA_ARGS__);   \
-    _recorder.RecordResult(this, false);                                       \
-  }
+#define LLDB_CONSTRUCT_(T, Class, ...)                                         \
+  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);               \
+  lldb_private::repro::construct<T>::handle(LLDB_GET_INSTRUMENTATION_DATA(),   \
+                                            _recorder, Class, __VA_ARGS__);
 
 #define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...)                         \
-  LLDB_CONSTRUCT_(Class Signature, __VA_ARGS__)
+  LLDB_CONSTRUCT_(Class Signature, this, __VA_ARGS__)
 
 #define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)                                 \
-  LLDB_CONSTRUCT_(Class(), lldb_private::repro::EmptyArg())
+  LLDB_CONSTRUCT_(Class(), this, lldb_private::repro::EmptyArg())
 
 #define LLDB_RECORD_(T1, T2, ...)                                              \
   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::invoke<T1>::method<T2>::doit,       \
-                     __VA_ARGS__);                                             \
+    if (lldb_private::repro::Serializer *_serializer =                         \
+            _data.GetSerializer()) {                                           \
+      _recorder.Record(*_serializer, _data.GetRegistry(),                      \
+                       &lldb_private::repro::invoke<T1>::method<T2>::record,   \
+                       __VA_ARGS__);                                           \
+    } else if (lldb_private::repro::Deserializer *_deserializer =              \
+                   _data.GetDeserializer()) {                                  \
+      if (_recorder.ShouldCapture()) {                                         \
+        return lldb_private::repro::invoke<T1>::method<T2>::replay(            \
+            _recorder, *_deserializer, _data.GetRegistry());                   \
+      }                                                                        \
+    }                                                                          \
   }
 
 #define LLDB_RECORD_METHOD(Result, Class, Method, Signature, ...)              \
   LLDB_RECORD_(Result(Class::*) Signature, (&Class::Method), this, __VA_ARGS__)
 
 #define LLDB_RECORD_METHOD_CONST(Result, Class, Method, Signature, ...)        \
   LLDB_RECORD_(Result(Class::*) Signature const, (&Class::Method), this,       \
                __VA_ARGS__)

 #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, ...)               \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                           stringify_args(__VA_ARGS__));
+
 #define LLDB_RECORD_DUMMY_NO_ARGS(Result, Class, Method)                       \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);
 
 namespace lldb_private {
 namespace repro {
 
 template <class T>
 struct is_trivially_serializable

 /// AddObjectForIndex returns the corresponding object. If there is no object
 /// for the given index, a nullptr is returend. The latter is valid when custom
 /// replay code is in place and the actual object is ignored.
 class IndexToObject {
 public:
   /// Returns an object as a pointer for the given index or nullptr if not
   /// 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;
   }
 
   /// Get all objects sorted by their index.
   std::vector<void *> GetAllObjects() const;
 
 private:
   /// Helper method that does the actual lookup. The void* result is later cast
   /// by the caller.
template <typename T> T Deserialize() {
     T t = Read<T>(typename serializer_tag<T>::type());
 #ifdef LLDB_REPRO_INSTR_TRACE
     llvm::errs() << "Deserializing with " << LLVM_PRETTY_FUNCTION << " -> "
                  << stringify_args(t) << "\n";
 #endif
     return t;
   }
 
+  template <typename T> const T &HandleReplayResult(const T &t) {
+    unsigned result = Deserialize<unsigned>();
+    if (is_trivially_serializable<T>::value)
+      return t;
+    // We need to make a copy as the original object might go out of scope.
+    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(const T &t) {
+  template <typename T> T &HandleReplayResult(T &t) {
     unsigned result = Deserialize<unsigned>();
     if (is_trivially_serializable<T>::value)
-      return;
+      return 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(llvm::StringRef buffer);
 
   /// Replay functions from a deserializer.
   bool Replay(Deserializer &deserializer);
 
   /// 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 {
-    static Result doit(Class *c, Args... args) { return (c->*m)(args...); }
-  };
-};
-
-template <typename Result, typename... Args>
-struct invoke<Result (*)(Args...)> {
-  template <Result (*m)(Args...)> struct method {
-    static Result doit(Args... args) { return (*m)(args...); }
-  };
-};
-
-template <typename... Args> struct invoke<void (*)(Args...)> {
-  template <void (*m)(Args...)> struct method {
-    static void doit(Args... args) { return (*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) {
while (*t)
       Serialize(*t++);
   }
 
   /// Serialization stream.
   llvm::raw_ostream &m_stream;
 
   /// Mapping of objects to indices.
   ObjectToIndex m_tracker;
-};
+}; // namespace repro
 
 class InstrumentationData {
 public:
-  InstrumentationData() : m_serializer(nullptr), m_registry(nullptr){};
-  InstrumentationData(Serializer &serializer, Registry &registry)
-      : m_serializer(&serializer), 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;
+  }
+
+  static void Initialize(Serializer &serializer, Registry &registry);
+  static void Initialize(Deserializer &serializer, Registry &registry);
+  static InstrumentationData &Instance();
+
+protected:
+  friend llvm::optional_detail::OptionalStorage<InstrumentationData, true>;
+  friend llvm::Optional<InstrumentationData>;
+
+  InstrumentationData()
+      : m_serializer(nullptr), m_deserializer(nullptr), m_registry(nullptr) {}
+  InstrumentationData(Serializer &serializer, 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) {}
 
 private:
+  static llvm::Optional<InstrumentationData> &InstanceImpl();
+
   Serializer *m_serializer;
+  Deserializer *m_deserializer;
   Registry *m_registry;
 };
 
 struct EmptyArg {};
 
 /// 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
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, typename T>
+  Result Replay(Deserializer &deserializer, Registry &registry, uintptr_t addr,
+                bool update_boundary) {
+    unsigned actual_id = registry.GetID(addr);
+    unsigned id = deserializer.Deserialize<unsigned>();
+    registry.CheckID(id, actual_id);
+    return ReplayResult<Result>(
+        static_cast<DefaultReplayer<T> *>(registry.GetReplayer(id))
+            ->Replay(deserializer),
+        update_boundary);
+  }
+
+  void Replay(Deserializer &deserializer, Registry &registry, uintptr_t addr) {
+    unsigned actual_id = registry.GetID(addr);
+    unsigned id = deserializer.Deserialize<unsigned>();
+    registry.CheckID(id, actual_id);
+    registry.GetReplayer(id)->operator()(deserializer);
+  }
+
+  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, Class *c,
+                       const EmptyArg &) {
+    return handle(data, recorder, c);
+  }
+
+  static Class *handle(lldb_private::repro::InstrumentationData data,
+                       lldb_private::repro::Recorder &recorder, Class *c,
+                       Args... args) {
+    if (!data)
+      return nullptr;
+
+    if (Serializer *serializer = data.GetSerializer()) {
+      recorder.Record(*serializer, data.GetRegistry(), &record, args...);
+      recorder.RecordResult(c, false);
+    } else if (Deserializer *deserializer = data.GetDeserializer()) {
+      if (recorder.ShouldCapture()) {
+        replay(recorder, *deserializer, data.GetRegistry());
+      }
+    }
+
+    return nullptr;
+  }
+
+  static Class *record(Args... args) { return new Class(args...); }
+
+  static Class *replay(Recorder &recorder, Deserializer &deserializer,
+                       Registry &registry) {
+    return recorder.Replay<Class *, Class *(Args...)>(
+        deserializer, registry, uintptr_t(&record), 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) {
+      return recorder.Replay<Result, Result(Class *, Args...)>(
+          deserializer, registry, uintptr_t(&record), 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) {
+      recorder.Replay(deserializer, registry, uintptr_t(&record));
+    }
+  };
+};
+
+template <typename Result, typename Class, typename... Args>
+struct invoke<Result (Class::*)(Args...) const> {
+  template <Result (Class::*m)(Args...) const> struct method {
+    static Result record(Class *c, Args... args) { return (c->*m)(args...); }
+    static Result replay(Recorder &recorder, Deserializer &deserializer,
+                         Registry &registry) {
+      return recorder.Replay<Result, Result(Class *, Args...)>(
+          deserializer, registry, uintptr_t(&record), true);
+    }
+  };
+};
+
+template <typename Class, typename... Args>
+struct invoke<void (Class::*)(Args...) const> {
+  template <void (Class::*m)(Args...) const> struct method {
+    static void record(Class *c, Args... args) { return (c->*m)(args...); }
+    static void replay(Recorder &recorder, Deserializer &deserializer,
+                       Registry &registry) {
+      recorder.Replay(deserializer, registry, uintptr_t(&record));
+    }
+  };
+};
+
+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 Result record(Args... args) { return (*m)(args...); }
+    static Result replay(Recorder &recorder, Deserializer &deserializer,
+                         Registry &registry) {
+      return recorder.Replay<Result, Result(Args...)>(deserializer, registry,
+                                                      uintptr_t(&record), true);
+    }
+  };
+};
+
+template <typename... Args> struct invoke<void (*)(Args...)> {
+  template <void (*m)(Args...)> struct method {
+    static void record(Args... args) { return (*m)(args...); }
+    static void replay(Recorder &recorder, Deserializer &deserializer,
+                       Registry &registry) {
+      recorder.Replay(deserializer, registry, uintptr_t(&record));
+    }
+  };
+};
+
 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 {
-    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>
 struct char_ptr_redirect<Result (*)(char *, size_t)> {
   template <Result (*m)(char *, size_t)> struct method {
-    static Result doit(char *s, size_t l) {
+    static Result record(char *s, size_t l) {
       char *buffer = reinterpret_cast<char *>(calloc(l, sizeof(char)));
       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() {
   static std::string error;
   if (auto e = Reproducer::Initialize(ReproducerMode::Capture, llvm::None)) {
     error = llvm::toString(std::move(e));
     return error.c_str();
   }
+
+  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
+    auto &p = g->GetOrCreate<SBProvider>();
+    InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry());
+  }
+
   return nullptr;
 }
 
 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();
   }
+
+  if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
+    auto &p = g->GetOrCreate<SBProvider>();
+    InstrumentationData::Initialize(p.GetSerializer(), p.GetRegistry());
+  }
+
   return nullptr;
 }
 
 const char *SBReproducer::PassiveReplay(const char *path) {
   static std::string error;
-  if (auto e = Reproducer::Initialize(ReproducerMode::Replay, FileSpec(path))) {
+  if (auto e = Reproducer::Initialize(ReproducerMode::PassiveReplay,
+                                      FileSpec(path))) {
     error = llvm::toString(std::move(e));
     return error.c_str();
   }
+
+  if (auto *l = lldb_private::repro::Reproducer::Instance().GetLoader()) {
+    FileSpec file = l->GetFile<SBProvider::Info>();
+    auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
+    if (!error_or_file) {
+      error =
+          "unable to read SB API data: " + error_or_file.getError().message();
+      return error.c_str();
+    }
+    static ReplayData r(std::move(*error_or_file));
+    InstrumentationData::Initialize(r.GetDeserializer(), r.GetRegistry());
+  }
+
   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

 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/ReproducerInstrumentation.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 #define LLDB_GET_INSTRUMENTATION_DATA()                                        \
-  lldb_private::repro::GetInstrumentationData()
+  lldb_private::repro::InstrumentationData::Instance()
 
 namespace lldb_private {
 namespace repro {
 
 class SBRegistry : public Registry {
 public:
   SBRegistry();
 };

 
 private:
   std::error_code m_ec;
   llvm::raw_fd_ostream m_stream;
   Serializer m_serializer;
   SBRegistry m_registry;
 };
 
-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()};
-  }
+class ReplayData {
+public:
+  ReplayData(std::unique_ptr<llvm::MemoryBuffer> memory_buffer)
+      : m_memory_buffer(std::move(memory_buffer)), m_registry(),
+        m_deserializer(m_memory_buffer->getBuffer()) {}
+  Deserializer &GetDeserializer() { return m_deserializer; }
+  Registry &GetRegistry() { return m_registry; }
 
-  return {};
-}
+private:
+  std::unique_ptr<llvm::MemoryBuffer> m_memory_buffer;
+  SBRegistry m_registry;
+  Deserializer m_deserializer;
+};
 
 template <typename T> void RegisterMethods(Registry &R);
 
 } // namespace repro
 } // namespace lldb_private
 
 #endif

lldb/source/Utility/Reproducer.cpp

if (!root) {
       auto ec = sys::fs::create_directory(root->GetPath());
       if (ec)
         return make_error<StringError>("unable to create reproducer directory",
                                        ec);
     }
     return Instance().SetCapture(root);
   } break;
   case ReproducerMode::Replay:
-    return Instance().SetReplay(root);
+    return Instance().SetReplay(root, /*passive*/ false);
+  case ReproducerMode::PassiveReplay:
+    return Instance().SetReplay(root, /*passive*/ true);
   case ReproducerMode::Off:
     break;
   };
 
   return Error::success();
 }
 
 bool Reproducer::Initialized() { return InstanceImpl().operator bool(); }
if (!root) {
     m_generator.reset();
     return Error::success();
   }
 
   m_generator.emplace(*root);
   return Error::success();
 }
 
-llvm::Error Reproducer::SetReplay(llvm::Optional<FileSpec> root) {
+llvm::Error Reproducer::SetReplay(llvm::Optional<FileSpec> root, bool passive) {
   std::lock_guard<std::mutex> guard(m_mutex);
 
   if (root && m_generator)
     return make_error<StringError>(
         "cannot replay a reproducer when generating one",
         inconvertibleErrorCode());
 
   if (!root) {
     m_loader.reset();
     return Error::success();
   }
 
-  m_loader.emplace(*root);
+  m_loader.emplace(*root, passive);
   if (auto e = m_loader->LoadIndex())
     return e;
 
   return Error::success();
 }
 
 FileSpec Reproducer::GetReproducerPath() const {
   if (auto g = GetGenerator())
void Generator::AddProvidersToIndex() {
   files.reserve(m_providers.size());
   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) {}
+Loader::Loader(FileSpec root, bool passive)
+    : m_root(MakeAbsolute(std::move(root))), m_loaded(false),
+      m_passive_replay(passive) {}
 
 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();
Recorder::Recorder(llvm::StringRef pretty_func, std::string &&pretty_args)
   }
 }
 
 Recorder::~Recorder() {
   assert(m_result_recorded && "Did you forget LLDB_RECORD_RESULT?");
   UpdateBoundary();
 }
 
+void InstrumentationData::Initialize(Serializer &serializer,
+                                     Registry &registry) {
+  InstanceImpl().emplace(serializer, registry);
+}
+
+void InstrumentationData::Initialize(Deserializer &deserializer,
+                                     Registry &registry) {
+  InstanceImpl().emplace(deserializer, registry);
+}
+
+InstrumentationData &InstrumentationData::Instance() {
+  if (!InstanceImpl())
+    InstanceImpl().emplace();
+  return *InstanceImpl();
+}
+
+llvm::Optional<InstrumentationData> &InstrumentationData::InstanceImpl() {
+  static llvm::Optional<InstrumentationData> g_instrumentation_data;
+  return g_instrumentation_data;
+}
+
 bool lldb_private::repro::Recorder::g_global_boundary;

lldb/unittests/Utility/ReproducerInstrumentationTest.cpp

 
 class TestingRegistry : public Registry {
 public:
   TestingRegistry();
 };
 
 static llvm::Optional<TestingRegistry> g_registry;
 static llvm::Optional<Serializer> g_serializer;
+static llvm::Optional<Deserializer> g_deserializer;
 
-inline InstrumentationData GetTestInstrumentationData() {
+class TestInstrumentationData : public InstrumentationData {
+public:
+  TestInstrumentationData() : InstrumentationData() {}
+  TestInstrumentationData(Serializer &serializer, Registry &registry)
+      : InstrumentationData(serializer, registry) {}
+  TestInstrumentationData(Deserializer &deserializer, Registry &registry)
+      : InstrumentationData(deserializer, registry) {}
+};
+
+inline TestInstrumentationData GetTestInstrumentationData() {
+  assert(!(g_serializer && g_deserializer));
   if (g_serializer)
-    return InstrumentationData(*g_serializer, *g_registry);
-  return InstrumentationData();
+    return TestInstrumentationData(*g_serializer, *g_registry);
+  if (g_deserializer)
+    return TestInstrumentationData(*g_deserializer, *g_registry);
+  return TestInstrumentationData();
 }
 
 class TestInstrumentationDataRAII {
-public:
+private:
   TestInstrumentationDataRAII(llvm::raw_string_ostream &os) {
     g_registry.emplace();
     g_serializer.emplace(os);
+    g_deserializer.reset();
   }
 
-  ~TestInstrumentationDataRAII() {
+  TestInstrumentationDataRAII(llvm::StringRef buffer) {
+    g_registry.emplace();
+    g_serializer.reset();
+    g_deserializer.emplace(buffer);
+  }
+
+  friend std::unique_ptr<TestInstrumentationDataRAII>
+  std::make_unique<TestInstrumentationDataRAII>(llvm::raw_string_ostream &os);
+  friend std::unique_ptr<TestInstrumentationDataRAII>
+  std::make_unique<TestInstrumentationDataRAII>(llvm::StringRef &buffer);
+
+public:
+  ~TestInstrumentationDataRAII() { Reset(); }
+
+  void Reset() {
     g_registry.reset();
     g_serializer.reset();
+    g_deserializer.reset();
+  }
+
+  static std::unique_ptr<TestInstrumentationDataRAII>
+  GetRecordingData(llvm::raw_string_ostream &os) {
+    return std::make_unique<TestInstrumentationDataRAII>(os);
+  }
+
+  static std::unique_ptr<TestInstrumentationDataRAII>
+  GetReplayData(llvm::StringRef buffer) {
+    return std::make_unique<TestInstrumentationDataRAII>(buffer);
   }
 };
 
 #define LLDB_GET_INSTRUMENTATION_DATA() GetTestInstrumentationData()
 
 enum class Class {
   Foo,
   Bar,

 public:
   InstrumentedFoo() = default;
   /// Instrumented methods.
   /// {
   InstrumentedFoo(int i);
   InstrumentedFoo(const InstrumentedFoo &foo);
   InstrumentedFoo &operator=(const InstrumentedFoo &foo);
   void A(int a);
+  int GetA();
   void B(int &b) const;
+  int &GetB();
   int C(float *c);
+  float GetC();
   int D(const char *d) const;
+  void GetD(char *buffer, size_t length);
   static void E(double e);
+  double GetE();
   static int F();
+  bool GetF();
   void Validate() override;
   //// }
   virtual bool IsA(Class c) override { return c == Class::Foo; }
 
 private:
   int m_a = 0;
   mutable int m_b = 0;
   float m_c = 0;

 }
 
 void InstrumentedFoo::A(int a) {
   LLDB_RECORD_METHOD(void, InstrumentedFoo, A, (int), a);
   B(a);
   m_a = a;
 }
 
+int InstrumentedFoo::GetA() {
+  LLDB_RECORD_METHOD_NO_ARGS(int, InstrumentedFoo, GetA);
+
+  return m_a;
+}
+
 void InstrumentedFoo::B(int &b) const {
   LLDB_RECORD_METHOD_CONST(void, InstrumentedFoo, B, (int &), b);
   m_called++;
   m_b = b;
 }
 
+int &InstrumentedFoo::GetB() {
+  LLDB_RECORD_METHOD_NO_ARGS(int &, InstrumentedFoo, GetB);
+
+  return m_b;
+}
+
 int InstrumentedFoo::C(float *c) {
   LLDB_RECORD_METHOD(int, InstrumentedFoo, C, (float *), c);
   m_c = *c;
   return 1;
 }
 
+float InstrumentedFoo::GetC() {
+  LLDB_RECORD_METHOD_NO_ARGS(float, InstrumentedFoo, GetC);
+
+  return m_c;
+}
+
 int InstrumentedFoo::D(const char *d) const {
   LLDB_RECORD_METHOD_CONST(int, InstrumentedFoo, D, (const char *), d);
   m_d = std::string(d);
   return 2;
 }
 
+void InstrumentedFoo::GetD(char *buffer, size_t length) {
+  LLDB_RECORD_METHOD(void, InstrumentedFoo, GetD, (char *, size_t), buffer,
+                     length);
+  ::snprintf(buffer, length, "%s", m_d.c_str());
+}
+
 void InstrumentedFoo::E(double e) {
   LLDB_RECORD_STATIC_METHOD(void, InstrumentedFoo, E, (double), e);
   g_e = e;
 }
 
+double InstrumentedFoo::GetE() {
+  LLDB_RECORD_METHOD_NO_ARGS(double, InstrumentedFoo, GetE);
+
+  return g_e;
+}
+
 int InstrumentedFoo::F() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(int, InstrumentedFoo, F);
   g_f = true;
   return 3;
 }
 
+bool InstrumentedFoo::GetF() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, InstrumentedFoo, GetF);
+
+  return g_f;
+}
+
 void InstrumentedFoo::Validate() {
   LLDB_RECORD_METHOD_NO_ARGS(void, InstrumentedFoo, Validate);
   EXPECT_EQ(m_a, 100);
   EXPECT_EQ(m_b, 200);
   EXPECT_NEAR(m_c, 300.3, 0.01);
   EXPECT_EQ(m_d, "bar");
   EXPECT_NEAR(g_e, 400.4, 0.01);
   EXPECT_EQ(g_f, true);
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, ());
+  LLDB_REGISTER_METHOD(int, InstrumentedFoo, GetA, ());
+  LLDB_REGISTER_METHOD(int &, InstrumentedFoo, GetB, ());
+  LLDB_REGISTER_METHOD(float, InstrumentedFoo, GetC, ());
+  LLDB_REGISTER_METHOD(void, InstrumentedFoo, GetD, (char *, size_t));
+  LLDB_REGISTER_METHOD(double, InstrumentedFoo, GetE, ());
+  LLDB_REGISTER_METHOD(bool, InstrumentedFoo, GetF, ());
 }
 
 static const Pod p;
 
 TEST(IndexToObjectTest, ObjectForIndex) {
   IndexToObject index_to_object;
   Foo foo;
   Bar bar;
TEST(SerializationRountripTest, SerializeDeserializeObjectReference) {
   EXPECT_EQ(bar, deserializer.Deserialize<Bar &>());
 }
 
 TEST(RecordReplayTest, InstrumentedFoo) {
   std::string str;
   llvm::raw_string_ostream os(str);
 
   {
-    TestInstrumentationDataRAII data(os);
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
 
     int b = 200;
     float c = 300.3f;
     double e = 400.4;
 
     InstrumentedFoo foo(0);
     foo.A(100);
     foo.B(b);
ValidateObjects(deserializer.GetAllObjects(),
                   {{Class::Foo, Validator::valid}});
 }
 
 TEST(RecordReplayTest, InstrumentedFooSameThis) {
   std::string str;
   llvm::raw_string_ostream os(str);
 
   {
-    TestInstrumentationDataRAII data(os);
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
 
     int b = 200;
     float c = 300.3f;
     double e = 400.4;
 
     InstrumentedFoo *foo = new InstrumentedFoo(0);
     foo->A(100);
     foo->B(b);
ValidateObjects(deserializer.GetAllObjects(),
                   {{Class::Foo, Validator::valid}});
 }
 
 TEST(RecordReplayTest, InstrumentedBar) {
   std::string str;
   llvm::raw_string_ostream os(str);
 
   {
-    TestInstrumentationDataRAII data(os);
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
 
     InstrumentedBar bar;
     InstrumentedFoo foo = bar.GetInstrumentedFoo();
 
     int b = 200;
     float c = 300.3f;
     double e = 400.4;
 
ValidateObjects(
       });
 }
 
 TEST(RecordReplayTest, InstrumentedBarRef) {
   std::string str;
   llvm::raw_string_ostream os(str);
 
   {
-    TestInstrumentationDataRAII data(os);
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
 
     InstrumentedBar bar;
     InstrumentedFoo &foo = bar.GetInstrumentedFooRef();
 
     int b = 200;
     float c = 300.3f;
     double e = 400.4;
 
ValidateObjects(
       {{Class::Bar, Validator::valid}, {Class::Foo, Validator::valid}});
 }
 
 TEST(RecordReplayTest, InstrumentedBarPtr) {
   std::string str;
   llvm::raw_string_ostream os(str);
 
   {
-    TestInstrumentationDataRAII data(os);
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
 
     InstrumentedBar bar;
     InstrumentedFoo &foo = *(bar.GetInstrumentedFooPtr());
 
     int b = 200;
     float c = 300.3f;
     double e = 400.4;
 
TEST(RecordReplayTest, InstrumentedBarPtr) {
   TestingRegistry registry;
   Deserializer deserializer(os.str());
   registry.Replay(deserializer);
 
   ValidateObjects(
       deserializer.GetAllObjects(),
       {{Class::Bar, Validator::valid}, {Class::Foo, Validator::valid}});
 }
+
+TEST(PassiveReplayTest, InstrumentedFoo) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+
+  {
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
+
+    int b = 200;
+    float c = 300.3f;
+    double e = 400.4;
+
+    InstrumentedFoo foo(0);
+    foo.A(100);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("bar");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    EXPECT_EQ(foo.GetB(), 200);
+    EXPECT_NEAR(foo.GetC(), 300.3, 0.01);
+    EXPECT_NEAR(foo.GetE(), 400.4, 0.01);
+    EXPECT_EQ(foo.GetF(), true);
+  }
+
+  std::string buffer = os.str();
+
+  {
+    auto data = TestInstrumentationDataRAII::GetReplayData(buffer);
+
+    int b = 999;
+    float c = 999.9f;
+    double e = 999.9;
+
+    InstrumentedFoo foo(9);
+    foo.A(999);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("999");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    EXPECT_EQ(foo.GetB(), 200);
+    EXPECT_NEAR(foo.GetC(), 300.3, 0.01);
+    EXPECT_NEAR(foo.GetE(), 400.4, 0.01);
+    EXPECT_EQ(foo.GetF(), true);
+  }
+}
+
+TEST(PassiveReplayTest, InstrumentedFooInvalid) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+
+  {
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
+
+    int b = 200;
+    float c = 300.3f;
+    double e = 400.4;
+
+    InstrumentedFoo foo(0);
+    foo.A(100);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("bar");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    EXPECT_EQ(foo.GetB(), 200);
+    EXPECT_NEAR(foo.GetC(), 300.3, 0.01);
+    EXPECT_NEAR(foo.GetE(), 400.4, 0.01);
+    EXPECT_EQ(foo.GetF(), true);
+  }
+
+  std::string buffer = os.str();
+
+  {
+    auto data = TestInstrumentationDataRAII::GetReplayData(buffer);
+
+    int b = 999;
+    float c = 999.9f;
+    double e = 999.9;
+
+    InstrumentedFoo foo(9);
+    foo.A(999);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("999");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    // Detect divergence.
+    EXPECT_DEATH(foo.GetA(), "");
+  }
+}
+
+TEST(PassiveReplayTest, InstrumentedBar) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+
+  {
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
+
+    InstrumentedBar bar;
+    InstrumentedFoo foo = bar.GetInstrumentedFoo();
+
+    int b = 200;
+    float c = 300.3f;
+    double e = 400.4;
+
+    foo.A(100);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("bar");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    EXPECT_EQ(foo.GetB(), 200);
+    EXPECT_NEAR(foo.GetC(), 300.3, 0.01);
+    EXPECT_NEAR(foo.GetE(), 400.4, 0.01);
+    EXPECT_EQ(foo.GetF(), true);
+
+    bar.SetInstrumentedFoo(foo);
+    bar.SetInstrumentedFoo(&foo);
+    bar.Validate();
+  }
+
+  std::string buffer = os.str();
+
+  {
+    auto data = TestInstrumentationDataRAII::GetReplayData(buffer);
+
+    InstrumentedBar bar;
+    InstrumentedFoo foo = bar.GetInstrumentedFoo();
+
+    int b = 99;
+    float c = 999.9f;
+    double e = 999.9;
+
+    foo.A(999);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("999");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    EXPECT_EQ(foo.GetB(), 200);
+    EXPECT_NEAR(foo.GetC(), 300.3, 0.01);
+    EXPECT_NEAR(foo.GetE(), 400.4, 0.01);
+    EXPECT_EQ(foo.GetF(), true);
+
+    bar.SetInstrumentedFoo(foo);
+    bar.SetInstrumentedFoo(&foo);
+    bar.Validate();
+  }
+}
+
+TEST(PassiveReplayTest, InstrumentedBarRef) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+
+  {
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
+
+    InstrumentedBar bar;
+    InstrumentedFoo &foo = bar.GetInstrumentedFooRef();
+
+    int b = 200;
+    float c = 300.3f;
+    double e = 400.4;
+
+    foo.A(100);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("bar");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    EXPECT_EQ(foo.GetB(), 200);
+    EXPECT_NEAR(foo.GetC(), 300.3, 0.01);
+    EXPECT_NEAR(foo.GetE(), 400.4, 0.01);
+    EXPECT_EQ(foo.GetF(), true);
+
+    bar.SetInstrumentedFoo(foo);
+    bar.SetInstrumentedFoo(&foo);
+    bar.Validate();
+  }
+
+  std::string buffer = os.str();
+
+  {
+    auto data = TestInstrumentationDataRAII::GetReplayData(buffer);
+
+    InstrumentedBar bar;
+    InstrumentedFoo &foo = bar.GetInstrumentedFooRef();
+
+    int b = 99;
+    float c = 999.9f;
+    double e = 999.9;
+
+    foo.A(999);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("999");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    EXPECT_EQ(foo.GetB(), 200);
+    EXPECT_NEAR(foo.GetC(), 300.3, 0.01);
+    EXPECT_NEAR(foo.GetE(), 400.4, 0.01);
+    EXPECT_EQ(foo.GetF(), true);
+
+    bar.SetInstrumentedFoo(foo);
+    bar.SetInstrumentedFoo(&foo);
+    bar.Validate();
+  }
+}
+
+TEST(PassiveReplayTest, InstrumentedBarPtr) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+
+  {
+    auto data = TestInstrumentationDataRAII::GetRecordingData(os);
+
+    InstrumentedBar bar;
+    InstrumentedFoo &foo = *(bar.GetInstrumentedFooPtr());
+
+    int b = 200;
+    float c = 300.3f;
+    double e = 400.4;
+
+    foo.A(100);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("bar");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    EXPECT_EQ(foo.GetB(), 200);
+    EXPECT_NEAR(foo.GetC(), 300.3, 0.01);
+    EXPECT_NEAR(foo.GetE(), 400.4, 0.01);
+    EXPECT_EQ(foo.GetF(), true);
+
+    bar.SetInstrumentedFoo(foo);
+    bar.SetInstrumentedFoo(&foo);
+    bar.Validate();
+  }
+
+  std::string buffer = os.str();
+
+  {
+    auto data = TestInstrumentationDataRAII::GetReplayData(buffer);
+
+    InstrumentedBar bar;
+    InstrumentedFoo &foo = *(bar.GetInstrumentedFooPtr());
+
+    int b = 99;
+    float c = 999.9f;
+    double e = 999.9;
+
+    foo.A(999);
+    foo.B(b);
+    foo.C(&c);
+    foo.D("999");
+    InstrumentedFoo::E(e);
+    InstrumentedFoo::F();
+    foo.Validate();
+
+    EXPECT_EQ(foo.GetA(), 100);
+    EXPECT_EQ(foo.GetB(), 200);
+    EXPECT_NEAR(foo.GetC(), 300.3, 0.01);
+    EXPECT_NEAR(foo.GetE(), 400.4, 0.01);
+    EXPECT_EQ(foo.GetF(), true);
+
+    bar.SetInstrumentedFoo(foo);
+    bar.SetInstrumentedFoo(&foo);
+    bar.Validate();
+  }
+}