[Reproducers] SBReproducer framework

[JDevlieghere]

Summary

To capture and replay SB API calls as part of the reproducer, we need a way to serialize and deserialize all function calls into the SB layer. The SBReproducer framework facilitates this. It transparently serializes and deserializes function calls and their arguments, including pointers and references. Most of the code is synthesized using templates, but it's possible to specify a custom deserialization function.

This patch only contains the framework.

For all the details refer to the RFC on the mailing list: http://lists.llvm.org/pipermail/lldb-dev/2019-January/014530.html

[JDevlieghere]

Prototype 2.0

[JDevlieghere]

Rebase on recent reproducer changes.

[JDevlieghere]

I split off the framework (this revision) and the addition of the macros (D57475).

I plan on updating the patch with tests, but I believe it's ready for review in the meantime.

[JDevlieghere]

Add unit testing for supporting classes

[labath]

I have a lot of comments. The two major ones are:

• i think the way you link the tests is in the UB territory. I explain this in detail in one of the inline comments.
• I believe that your unit tests (not just in this patch) focus too much on testing the behavior of a single method, even when that method does not have an easily observable results. For this you then often need to expose internals of the tested class to be able to test some effect of that method on the internal state. This not all bad (i've done it myself sometimes), and it's definitely better that not writing any unit tests. However, it's generally better to test the public interface of a method/class/entity, and in this case, I believe it should be possible. I'm imagining some tests like having a dummy class with a bunch of methods which are annotated with the SB_RECORD macros. Then, in the test you call the methods of this class with some arguments, have the repro framework serialize the calls to a (in-memory?) stream, and verify the contents of that stream. This will test a lot more code -- the (De)Serialize functions are just fancy ways of invoking memcpy, but if you take all of that together with the SB_RECORD, SB_REGISTER macros, it becomes some pretty deep magic that is interesting to test exhaustively (it's fine, but not really interesting to test that Deserialize<T*> and Deserialize<T&> do the right thing for each of the possible fundamental types.) And if you use the deserializer interface to read out the recorded traces (instead of comparing raw bytes), then you can avoid depending on the endianness of the values.

Conversely, you can write a trace file with the serializer interface, and then tell the replayer to invoke the mock class which will verify that it was called with the right arguments.

source/API/SBReproducer.cpp

2

I found it weird to have one cpp file implementing two headers (SBReproducer.h and SBReproducerPrivate.h). Can you split it into two files? (This will come out naturally, if we split this up into modules as I mention in one of the other comments.)

70

drop {} (that's what you seem to do elsewhere in this file).

source/API/SBReproducerPrivate.h

44 ↗

(On Diff #184644)

Why do you need to remove_const here? If T is const, then const will be added back by the return statement anyway. If T is not const, then remove_const is a noop.

65–69 ↗

(On Diff #184644)

replace by m_mapping.lookup(idx), at which point you can consider dropping this function entirely.

82–93 ↗

(On Diff #184644)

Just curious: What's the advantage of this over just declaring a bunch of Tag classes directly (struct PointerTag{}; struct ReferenceTag{}; ...)?

121 ↗

(On Diff #184644)

Instead of the m_offset variable, what do you think about just drop_fronting the appropriate amount of bytes when you are done with the? It doesn't look like you'll ever need to go back to an earlier point in the stream...

155–161 ↗

(On Diff #184644)

It sounds to me like this could be solved by passing the deserializer to the operator() of the SBReplayers instead of having it a member variable set by the constructor. This design also makes more sense to me, as theoretically there is no reason why all replay calls would have to come from the same deserializer object. You may even want to have a separate deserializer for each thread when you get around to replaying multithreaded recordings.

After this, it may even be possible to make the deserializer object be a local variable in the SBRegistry::Replay function.

167 ↗

(On Diff #184644)

I guess if we don't consider the recording to be "input" then we don't have to handle the case of not having enough bytes in the file extremely gracefully here, but it would still be nice to at least assert that we are not running off the end of the buffer here.

169 ↗

(On Diff #184644)

reinterpret_cast

182 ↗

(On Diff #184644)

Is this correct? I would expect the fundamental references to not go through this overload at all...

303 ↗

(On Diff #184644)

Shouldn't this call g then?

307–309 ↗

(On Diff #184644)

If you gave these more meaningful names, then the comments would be unneeded.

370 ↗

(On Diff #184644)

It looks like this id argument isn't really needed here, as the DoRegister function can just synthesize the id on its own. In fact, the m_id is probably not needed either, as you can just use m_sbreplayers.size()+1 or something.

371 ↗

(On Diff #184644)

assert(m_sbreplayers.find(RunID) == end()) to make sure our RunID magic didn't do something funny?

419–448 ↗

(On Diff #184644)

What's the threading scenario in which you expect this to be called? If multiple threads can call GetIndexForObject simultaneously (even if the objects differ), then I think you need to guard m_mapping with the mutex too, not just the integer variable.

BTW: The m_index can also just be m_mapping.size()+1

453 ↗

(On Diff #184644)

Is this default value used for anything? It don't see it being used, and it doesn't seem particularly useful anyway, as you'd just get a lot of binary junk on stdout.

482 ↗

(On Diff #184644)

Will this ever not be an infinite recursion? I am guessing this works because all fundamental types are picked up by the specific overloads below before this function is even invoked.

Maybe if you just inline the m_stream.write(reinterpret_cast<const char *>(&t), sizeof(Type)) thingy here, you can avoid having to define a special Serialize function for all fundamental types.

484 ↗

(On Diff #184644)

It looks like GetIndexForObject returns unsigned

562–563 ↗

(On Diff #184644)

If you wanted to make the updates to g_global_boundary thread-safe, this is not the way to achieve that. This is still going to be racy, so you should at least use the atomic compare-and-exchange operations. However, I don't believe this will still be right thing to do in the multithreaded case, so it may be best do just drop the atomicity until you implement proper threading support.

573–574 ↗

(On Diff #184644)

Move this to the constructor, and use llvm::Optional in the SB_RECORD macros?

This will also avoid having this class muck around with g_global_boundary when we are not recording.

578 ↗

(On Diff #184644)

Inconsistent braces around a single statement.

584–585 ↗

(On Diff #184644)

if you used the LLDB_LOG macro, you wouldn't have to rely on m_pretty_func being implicitly null terminated.

618–626 ↗

(On Diff #184644)

I'm wondering if we shouldn't embed some additional safeties here to make sure the result is always recorded when it should be. It seems to be this class should know whether it should expect an explicit RecordResult call (based on whether we called the void version of Record or not). So, we could have this class assert if we reached the destructor without recording anything, instead of silently recording zero. WDYT?

659 ↗

(On Diff #184644)

__PRETTY_FUNCTION__ is not portable. I think you want LLVM_PRETTY_FUNCTION here.

tools/driver/Driver.cpp

914–918

The driver should know whether it is replaying things or not, right? Can we have it call Replay only if replay mode has actually been requested?

unittests/API/CMakeLists.txt

4–12 ↗

(On Diff #184644)

Hmm.. I'm not sure this is going to work everywhere, but it's certainly going to be weird. liblldb is a shared library which deliberately firewalls all lldb_private symbols. So any reproducer symbols you defined there will not be accessible to your unit tests. I guess the reason include_directories trick kind of works is that most of the reproducer frameworks is implemented in the header, and including that header from the test will cause another copy of all of these symbols to be defined. However, I am still surprised that it does work, as you still have some chunks of this implemented in the cpp file. I guess you were just lucky to not need those symbols in the tests that you have written. Nonetheless, this is going into very murky waters, and I think the fact that you had to link in lldbHost and lldbCore in addition to liblldb (even though they are be included in there) demonstrates it.

I think the best way to address this is to move the core of the repro engine into some other library, which can be safely used from unit tests. After all, the core is not really tied to the SB API, and you could easily use it to record any other interface, if you needed to do that for whatever reason. I think this should go into the Utility module, as it doesn't have any other dependencies. I see that you're including FileSystem.h, but it looks like this is only used in the SetInputFileHandleRedirect function, which is not actually used anywhere! Even when it is used, I think it would make sense for it to live elsewhere, as this is not a part of the replay core, but rather how a particular api wants to replay a particular function signature.

unittests/API/SBReproducerTest.cpp

37–41 ↗

(On Diff #184644)

All of these buffers hard-code endiannes of integers and the representation of floats.

83–85 ↗

(On Diff #184644)

I find this behaviour confusing. Intuitively, I'd expect HasData(n) if buffer has at least n bytes of data left. So in this case I'd expect true in both calls. (In fact I'd probably expect HasData() to be a synonym for HasData(1)). It looks like you're only calling HasData in one place, and you're hardcoding 1 there, so maybe you just want an EOF() function?

[JDevlieghere]

In D56322#1380442, @labath wrote:

I have a lot of comments. The two major ones are:

• i think the way you link the tests is in the UB territory. I explain this in detail in one of the inline comments.

Thanks, you're right and your suggestion makes sense. Keep in mind that the registry's Init method needs to have access to the SB definitions though.

• I believe that your unit tests (not just in this patch) focus too much on testing the behavior of a single method, even when that method does not have an easily observable results. For this you then often need to expose internals of the tested class to be able to test some effect of that method on the internal state. This not all bad (i've done it myself sometimes), and it's definitely better that not writing any unit tests.

It's funny you mention this, maybe I misremember but I recall you commenting on a patch that the current reproducers test were too high level. Maybe we have different views on what unit tests are, but I strongly believe that it's import to tests small *units* of code. They may seem trivial today until someone to decides to refactor them tomorrow. Indeed, we're already planning to move some of this code around and these tests will give me a lot more confidence. This stuff is relatively tricky, hard to debug and easy to get wrong. I strongly believe it's important to have these kind of unit tests, but I also totally agree that they should not be the only tests. See my next comment for more on that :-)

However, it's generally better to test the public interface of a method/class/entity, and in this case, I believe it should be possible.

It's 100% my fault for not making this clearer, but all that is in the pipeline. I wasn't able to work on this as much as I would've wanted the last week so that might have given the wrong impression. Maybe I should've kept the title as WIP, but I didn't want to discourage people from looking at the framework while I was adding this tests. Maybe I should've done this in a separate patch.

I'm imagining some tests like having a dummy class with a bunch of methods which are annotated with the SB_RECORD macros. Then, in the test you call the methods of this class with some arguments, have the repro framework serialize the calls to a (in-memory?) stream, and verify the contents of that stream. This will test a lot more code -- the (De)Serialize functions are just fancy ways of invoking memcpy, but if you take all of that together with the SB_RECORD, SB_REGISTER macros, it becomes some pretty deep magic that is interesting to test exhaustively (it's fine, but not really interesting to test that Deserialize<T*> and Deserialize<T&> do the right thing for each of the possible fundamental types.) And if you use the deserializer interface to read out the recorded traces (instead of comparing raw bytes), then you can avoid depending on the endianness of the values.

Conversely, you can write a trace file with the serializer interface, and then tell the replayer to invoke the mock class which will verify that it was called with the right arguments.

This is very much what I'm planning to do. Coming back to my original point about testing smaller units, this is all great while it works, but it's going to be far from obvious as soon as this breaks. My hope is that if something fundamental breaks, one of the "obvious" unit test would catch it first.

[labath]

In D56322#1380996, @JDevlieghere wrote:

In D56322#1380442, @labath wrote:

I have a lot of comments. The two major ones are:

• i think the way you link the tests is in the UB territory. I explain this in detail in one of the inline comments.

Thanks, you're right and your suggestion makes sense. Keep in mind that the registry's Init method needs to have access to the SB definitions though.

Yes, in this world, the I guess the version of the registry in the utility folder would be just an abstract class which provides the building blocks to intercept "any" api. And the API folder would contain an instantiation of this class which intercepts the SB methods. (And tests would instantiate/subclass/whatever it to intercept the mock methods.)

• I believe that your unit tests (not just in this patch) focus too much on testing the behavior of a single method, even when that method does not have an easily observable results. For this you then often need to expose internals of the tested class to be able to test some effect of that method on the internal state. This not all bad (i've done it myself sometimes), and it's definitely better that not writing any unit tests.

It's funny you mention this, maybe I misremember but I recall you commenting on a patch that the current reproducers test were too high level. Maybe we have different views on what unit tests are, but I strongly believe that it's import to tests small *units* of code. They may seem trivial today until someone to decides to refactor them tomorrow. Indeed, we're already planning to move some of this code around and these tests will give me a lot more confidence. This stuff is relatively tricky, hard to debug and easy to get wrong. I strongly believe it's important to have these kind of unit tests, but I also totally agree that they should not be the only tests. See my next comment for more on that :-)

Yes, that is funny, and a bit ironic. :) Though I think we're on the same page here. My comment was more about the lack of higher-level (or, shall we call them middle-level?) tests, then the presence of these low-level ones. Lldb has a very big deficiency in low-level tests, so I'd rather have more (even if some end up being "change-detector tests") than less (and miss some opportunities to increase coverage) of them.

Bottom line: if you write some tests like the one I described previously, I am going to be _very_ happy. I have no problem with the existing tests staying, if you find them valuable. Just please make sure they work on big-endian platforms too. :)

[JDevlieghere]

Address Pavel's inline comments, modulo

• Fixing the ODR violation (should be easier to verify inline comments are addressed before moving the code).
• Fixing the endianness in the unit test (I originally considered ifdef'ing this, but that combined with the float-encoding made me reconsider).

source/API/SBReproducerPrivate.h

82–93 ↗

(On Diff #184644)

Mostly preference, but the structs are less code so I've simplified it.

121 ↗

(On Diff #184644)

We don't go back, but the buffer is the backing memory for deserialized c-strings.

182 ↗

(On Diff #184644)

Pretty sure, but please elaborate on why you think that.

453 ↗

(On Diff #184644)

I'm 100% sure it's needed because I got rid of it only to find out we couldn't do without it. I'm not entirely sure anymore, but I think we didn't know if the function was going to have a (useful) return value or not.

tools/driver/Driver.cpp

914–918

Replay will check if we're in replay mode, which I think is a more canonical way to check it. Happy to change this if you disagree.

[JDevlieghere]

In D56322#1381254, @labath wrote:

In D56322#1380996, @JDevlieghere wrote:

In D56322#1380442, @labath wrote:

I have a lot of comments. The two major ones are:

• i think the way you link the tests is in the UB territory. I explain this in detail in one of the inline comments.

Thanks, you're right and your suggestion makes sense. Keep in mind that the registry's Init method needs to have access to the SB definitions though.

Yes, in this world, the I guess the version of the registry in the utility folder would be just an abstract class which provides the building blocks to intercept "any" api. And the API folder would contain an instantiation of this class which intercepts the SB methods. (And tests would instantiate/subclass/whatever it to intercept the mock methods.)

• I believe that your unit tests (not just in this patch) focus too much on testing the behavior of a single method, even when that method does not have an easily observable results. For this you then often need to expose internals of the tested class to be able to test some effect of that method on the internal state. This not all bad (i've done it myself sometimes), and it's definitely better that not writing any unit tests.

It's funny you mention this, maybe I misremember but I recall you commenting on a patch that the current reproducers test were too high level. Maybe we have different views on what unit tests are, but I strongly believe that it's import to tests small *units* of code. They may seem trivial today until someone to decides to refactor them tomorrow. Indeed, we're already planning to move some of this code around and these tests will give me a lot more confidence. This stuff is relatively tricky, hard to debug and easy to get wrong. I strongly believe it's important to have these kind of unit tests, but I also totally agree that they should not be the only tests. See my next comment for more on that :-)

Yes, that is funny, and a bit ironic. :) Though I think we're on the same page here. My comment was more about the lack of higher-level (or, shall we call them middle-level?) tests, then the presence of these low-level ones. Lldb has a very big deficiency in low-level tests, so I'd rather have more (even if some end up being "change-detector tests") than less (and miss some opportunities to increase coverage) of them.

Great :-)

Bottom line: if you write some tests like the one I described previously, I am going to be _very_ happy. I have no problem with the existing tests staying, if you find them valuable. Just please make sure they work on big-endian platforms too. :)

Awesome, yeah I didn't consider the float encoding, I'll just do a roundtrip test.

[JDevlieghere]

• Move framework in Utility
• Update tests

[labath]

Thank you. I think this looks much better now.

It occurred to me that the (de)serializer classes are fully standalone. Since they already have a comprehensive test suite, do you think it would make sense to split them off into a separate patch, which can be committed separately?

include/lldb/API/SBReproducer.h

20

Should this be static?

include/lldb/Utility/ReproducerInstrumentation.h

290–291 ↗

(On Diff #184874)

Is this function necessary? It seems like the subclass could easily achieve this by just calling Register from its constructor. (I also don't see it being called anywhere).

294 ↗

(On Diff #184874)

How about having this function take a unique_ptr, and then store that unique_ptr in (e.g.) the m_ids map. It'd be nice not to leak _every_ object we create in this patch.

298 ↗

(On Diff #184874)

s/m_sbreplayers/m_replayers`

393 ↗

(On Diff #184874)

Since you don't support void *, maybe this should be llvm_unreachable, or =delete?

432 ↗

(On Diff #184874)

I guess I forgot to mention that LLDB_LOG uses the llvm::formatv syntax for substitutions (which is why it's able to handle llvm::StringRef, and non-null-terminated strings. So this would just be LLDB_LOG(log, "#{0} '{1}'", id, m_pretty_func).

source/API/SBReproducer.cpp

43–60

Unused functions.

source/API/SBReproducerPrivate.h

525–533 ↗

(On Diff #184825)

Instead of this function, could you just do the following:

• have the void version of Record automatically write the extra 0 (and set m_result_recorded to true)
• have the destructor assert(m_result_recorded)

I'm not 100% sure it would work, but it looks like it would be a lot simpler if it did.

121 ↗

(On Diff #184644)

Well, the buffer is a StringRef, so it doesn't really "back" anything :), but if you think this is more understandable then I can live with it.

182 ↗

(On Diff #184644)

I am referring to the comment in the method (the implementation seems fine). It says "If this is a reference to a fundamental type, ...", but fundamental types should go through the FundamentalReferenceTag overload, right?

453 ↗

(On Diff #184644)

I don't see how the default stream argument could have anything to do with whether a function has a return value. Are you sure you replied to the right comment?

source/Utility/ReproducerInstrumentation.cpp

47 ↗

(On Diff #184874)

(LLDB_LOG already checks for null-ness of the log argument)

tools/driver/Driver.cpp

914–918

I find it weird because my intuitive understanding of the api would be that Replay should return an error if the replay itself failed, and not simply because replay was never enabled in the first place. And it doesn't seem like the error path should be on the common case. If we wanted to have the canonical way to check this live on the other side of the API boundary, then we should have something like SBReproducer.GetMode. However, I don't think that's needed, as this should already known implicitly from the way the API is used:

SBInitializerOptions opt;
opt.SetOptionsForReplayMode(...);
if (!SBDebugger::Initialize(opt)) {
  puts("something went wrong during initialization");
  return -1;
}
// From this point on, we know we're in replay mode.
if (!SBReproducer.Replay()) {
  puts("Error running the reproducer");
  return -1;
}

unittests/Utility/ReproducerInstrumentationTest.cpp

37–41 ↗

(On Diff #184874)

It looks like HandleReplayResult is not covered by these tests. Since this is also the official public way to add objects to the internal index, maybe you could kill two birds with one stone and change the test which pokes at the internal object map to use HandleReplayResult instead.

[JDevlieghere]

In D56322#1382971, @labath wrote:

Thank you. I think this looks much better now.

It occurred to me that the (de)serializer classes are fully standalone. Since they already have a comprehensive test suite, do you think it would make sense to split them off into a separate patch, which can be committed separately?

Sure, makes sense to me, please see D57714

[JDevlieghere]

Add context

[JDevlieghere]

(I plan to add another test that deals with returning objects)

[labath]

Thank you. I like the new test, but see my comment about avoiding duplicating macros in the test. Besides returning objects, I can think of a couple of more interesting scenarios to cover:

• recursive calls (to exercise the g_global_boundary thingy)
• having two objects with identical this pointers (you can use placement new to guarantee that)
• calling the "custom" function during replay

unittests/Utility/ReproducerInstrumentationTest.cpp

60–62 ↗

(On Diff #185208)

googletest already has apis for this: EXPECT_FLOAT/DOUBLE_EQ or EXPECT_NEAR.

67–122 ↗

(On Diff #185208)

Since these macros are the actual "public" interface of the instrumentation framework, and they do contain non-trivial logic, I think it would be nice to test the real macros, instead of redefining them here. (It would also be nice to simply avoid duplicating code.)

Would something like this work:

• move the macros to ReproducerInstrumentation.h (maybe also rename to LLDB_RECORD_blah_blah).
• parameterize them on a macro for getting the instrumentation classes. So, something like:

#define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...)                           \
  if (InstrumentationData data = LLDB_GET_INSTRUMENTATION_DATA()) {  \
    lldb_private::repro::Recorder recorder(                                 \
        data.GetSerializer(),                   \
        data.GetRegistry(),                     \
        LLVM_PRETTY_FUNCTION);                                                 \
    sb_recorder.Record(&lldb_private::repro::construct<Class Signature>::doit, \
                       __VA_ARGS__);                                           \
    sb_recorder.RecordResult(this);                                            \
  }

where InstrumentationData is essentially std::pair<Serializer *, Registry *> with a suitable operator bool. Then the tests could define LLDB_GET_INSTRUMENTATION_DATA simply to InstrumentationData(&g_serializer, &g_registry) and the "real" code could do something like

#define LLDB_GET_INSTRUMENTATION_DATA lldb_private::repro::GetInstrumentationData()

InstrumentationData GetInstrumentationData() {
  auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator();
  if (!g) return {};
  auto &p = g->GetOrCreate<SBProvider>();
  return {p.GetSerializer(), p.GetRegistry();
}

143–148 ↗

(On Diff #185208)

This seems rather pointless, as you've just set the variables to those values. What are you testing here? The compiler?

384 ↗

(On Diff #185208)

Make g_serializer llvm:Optional, and then you can avoid needing it be copyable (I think making the Serializer class copyable is a bad idea for the same reason than making raw_ostream copyable would be a bad idea)

399–404 ↗

(On Diff #185208)

access variables via the class (InstrumentedFoo::g_a) to make it clear that they are static.

[labath]

unittests/Utility/ReproducerInstrumentationTest.cpp

399–404 ↗

(On Diff #185208)

Actually, what do you think about this pattern:

• have the variables be member variables
• add a Validate method to the InstrumentedFoo class. This method would also be instrumented, and it would check that the members are set to the correct value
• call the method during recording and it will be automatically called during replay. Then all you need to do in the test is check that Validate was called.

I am hoping that this will make things more manageable once you have multiple instrumented objects floating around in the test. Also, this would implicitly test that the replay framework calls the member functions on the right object (e.g., right now this would succeed if the framework just created a fresh new object for each call).

[labath]

I think we're very close. This batch of comments is just about small improvements to the tests. It looks like the Validate thingy wasn't such a clever idea, since the fact that the framework creates extra copies means that there are some unvalidated copies floating around. Still, I think it's worth it overall, because it tests the bahavior we want more closely than if we just went through global variables (however, do see my comments on the global variables to make sure that validation did indeed take place).

include/lldb/Utility/ReproducerInstrumentation.h

594–595 ↗

(On Diff #185431)

I guess this comment is no longer true. We should only ever create this object if we are recording.

source/API/SBReproducerPrivate.h

23 ↗

(On Diff #185431)

If it's all the same to you, i'd prefer to have this be a function-like macro (so just add () after the macro name here, and also add () to all macro "invocations").

61 ↗

(On Diff #185431)

inline (or move to .cpp)

unittests/Utility/ReproducerInstrumentationTest.cpp

50–52 ↗

(On Diff #185431)

I guess this is no longer used?

62 ↗

(On Diff #185431)

I think it's still important to independently check that Validate was called, IIUC, the framework never deletes the objects it creates, so this wouldn't actually check anything during the replay. Even if it did, this opens up the possibility that the Replay method decides to do absolutely nothing for some reason, in which case the test would still succeed. The idea for stashing the this pointer from the other comment could be reused for this purpose too.

443 ↗

(On Diff #185431)

destroy the old object before creating a new one in its place (foo->~InstrumentedFoo()).

455 ↗

(On Diff #185431)

A good thing to check here would be to make sure that the framework created actually created two instances of this object. As it stands now, if the framework just decided to keep calling methods on the original object, the test would probably still succeed. One way to achieve that would be to enhance the Validate method to stash the this pointer into an array somewhere. Then you could check that the array contains two elements (and that they are different).

479–480 ↗

(On Diff #185431)

Add a check that these two methods are called with the same object during replay. The methods could store the object pointer instead of just a plain flag, and then Validate could verify their equality.

[JDevlieghere]

Feedback Pavel.

[labath]

This looks good to me. Thank you for your patience.

lldb/source/Utility/ReproducerInstrumentation.cpp

91 ↗

(On Diff #185585)

old macro name in assert message

[JDevlieghere]

In D56322#1387357, @labath wrote:

This looks good to me. Thank you for your patience.

My pleasure, thank you for the thorough review!

[labath]

Btw, I've just noticed that the files you've added here still have the old license header.

[lebedev.ri]

In D56322#1389013, @labath wrote:

Btw, I've just noticed that the files you've added here still have the old license header.

Would be good to get at least an automatic Herald rule for this
I suspect there might be more occurrences of patches/diffs/commits with old license in the time to come.

include/lldb/API/SBReproducer.h

+//===-- SBReproducer.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_API_SBREPRODUCER_H
+#define LLDB_API_SBREPRODUCER_H
+
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Reproducer.h"
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/BinaryStreamWriter.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/YAMLTraits.h"
+
+#include <mutex>
+#include <string>
+#include <vector>
+
+#define SB_RECORD_NO_ARGS                                                      \
+  repro::SBRecorder sb_recorder;                                               \
+  if (auto *g = repro::Reproducer::Instance().GetGenerator()) {                \
+    repro::SBProvider &p = g->GetOrCreate<repro::SBProvider>();                \
+    sb_recorder.SetSerializer(&p.GetSerializer());                             \
+    sb_recorder.RecordCall(__PRETTY_FUNCTION__);                               \
+  }
+
+#define SB_RECORD(...)                                                         \
+  repro::SBRecorder sb_recorder;                                               \
+  if (auto *g = repro::Reproducer::Instance().GetGenerator()) {                \
+    repro::SBProvider &p = g->GetOrCreate<repro::SBProvider>();                \
+    sb_recorder.SetSerializer(&p.GetSerializer());                             \
+    sb_recorder.RecordCall(__PRETTY_FUNCTION__, __VA_ARGS__);                  \
+  }
+
+#define SB_RECORD_RETURN(t) sb_recorder.RecordReturn(t)
+
+namespace lldb {
+void GenerateReproducer();
+bool ReplayReproducer();
+} // namespace lldb
+
+namespace lldb_private {
+namespace repro {
+
+template <> const char *SBDeserializer::Read<const char *>();
+
+class SBRecorder {
+public:
+  SBRecorder() : m_serializer(nullptr), m_local_boundary(false) {
+    if (!g_global_boundary) {
+      g_global_boundary = true;
+      m_local_boundary = true;
+    }
+  }
+
+  ~SBRecorder() { UpdateBoundary(); }
+
+  void UpdateBoundary() {
+    if (m_local_boundary) {
+      g_global_boundary = false;
+    }
+  }
+
+  template <typename... Ts>
+  void RecordCall(const char *name, const Ts &... args) {
+    if (!ShouldCapture() || !ShouldSerialize()) {
+      return;
+    }
+    m_serializer->Serialize(name);
+    m_serializer->Serialize(args...);
+  }
+
+  template <typename T> const T &RecordReturn(const T &t) {
+    UpdateBoundary();
+    if (!ShouldCapture() || !ShouldSerialize()) {
+      return t;
+    }
+    m_serializer->Serialize(t);
+    return t;
+  }
+
+  void SetSerializer(SBSerializer *serializer) { m_serializer = serializer; }
+
+private:
+  bool ShouldCapture() { return m_local_boundary; }
+  bool ShouldSerialize() { return m_serializer != nullptr; }
+
+  SBSerializer *m_serializer;
+  bool m_local_boundary;
+
+  static thread_local std::atomic<bool> g_global_boundary;
+};
+
+class SBReplayer {
+public:
+  SBReplayer() {}
+
+  void Init();
+
+  llvm::Error Replay() {
+    repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
+    if (!loader) {
+      return llvm::make_error<llvm::StringError>(
+          "Cannot replay when not in replay mode.",
+          llvm::inconvertibleErrorCode());
+    }
+
+    llvm::Optional<ProviderInfo> info = loader->GetProviderInfo("sbapi");
+    if (!info) {
+      return llvm::make_error<llvm::StringError>(
+          "No SB API provider info available to replay.",
+          llvm::inconvertibleErrorCode());
+    }
+
+    FileSpec file(loader->GetRoot());
+    file.AppendPathComponent(info->files.front());
+
+    auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
+    if (auto err = error_or_file.getError())
+      return llvm::errorCodeToError(err);
+
+    SBDeserializer deserializer((*error_or_file)->getBuffer());
+    while (deserializer.HasData()) {
+      llvm::StringRef f(deserializer.Read<const char *>());
+      if (f.empty())
+        break;
+      if (m_functions.find(f) == m_functions.end()) {
+        llvm::outs() << "Could not find function for '" << f << "' ("
+                     << f.size() << ")\n";
+        break;
+      }
+      m_functions[f](deserializer);
+    }
+
+    return llvm::Error::success();
+  }
+
+private:
+  SBIndexToObject m_index_to_object;
+  llvm::StringMap<std::function<void(SBDeserializer &)>> m_functions;
+};
+
+class SBProvider : public Provider<SBProvider> {
+public:
+  SBProvider(const FileSpec &directory)
+      : Provider(directory),
+        m_stream(directory.CopyByAppendingPathComponent("sbapi.bin").GetPath(),
+                 m_ec, llvm::sys::fs::OpenFlags::F_None),
+        m_serializer(m_stream) {
+    m_info.name = "sbapi";
+    m_info.files.push_back("sbapi.bin");
+  }
+
+  SBSerializer &GetSerializer() { return m_serializer; }
+
+  static char ID;
+
+private:
+  std::error_code m_ec;
+  llvm::raw_fd_ostream m_stream;
+  SBSerializer m_serializer;
+};
+
+} // namespace repro
+} // namespace lldb_private
+
+#endif

include/lldb/Utility/Reproducer.h

public:
   // Returns the class ID for the dynamic type of this Provider instance.
   virtual const void *DynamicClassID() const = 0;
 
 protected:
   ProviderBase(const FileSpec &root) : m_root(root) {}
 
   /// Every provider keeps track of its own files.
   ProviderInfo m_info;
+
 private:
   /// Every provider knows where to dump its potential files.
   FileSpec m_root;
 
   virtual void anchor();
   static char ID;
 };
 
private:
   static llvm::Optional<Reproducer> &InstanceImpl();
 
   llvm::Optional<Generator> m_generator;
   llvm::Optional<Loader> m_loader;
 
   mutable std::mutex m_mutex;
 };
 
+class SBObjectToIndex {
+public:
+  SBObjectToIndex() : m_index(0) {}
+
+  template <typename T> unsigned GetIndexForObject(T *t) {
+    return GetIndexForObjectImpl((void *)t);
+  }
+
+private:
+  unsigned GetIndexForObjectImpl(void *object);
+  unsigned Increment();
+
+  unsigned m_index;
+  std::mutex m_mutex;
+  llvm::DenseMap<void *, unsigned> m_mapping;
+};
+
+class SBIndexToObject {
+public:
+  template <typename T> T *GetObjectForIndex(int index) {
+    void *object = GetObjectForIndexImpl(index);
+    return static_cast<T *>(object);
+  }
+
+  template <typename T> void AddObjectForIndex(int index, T *object) {
+    AddObjectForIndexImpl(index, static_cast<void *>(object));
+  }
+
+  template <typename T> void AddObjectForIndex(int index, T &object) {
+    AddObjectForIndexImpl(index, static_cast<void *>(&object));
+  }
+
+private:
+  void *GetObjectForIndexImpl(int index);
+  void AddObjectForIndexImpl(int index, void *object);
+
+  llvm::DenseMap<unsigned, void *> m_mapping;
+};
+
+class SBSerializer {
+public:
+  SBSerializer(llvm::raw_ostream &stream) : m_stream(stream) {}
+
+  void Serialize() {}
+
+  template <typename T, typename... Ts>
+  void Serialize(const T &t, const Ts &... ts) {
+    Write(t);
+    Serialize(ts...);
+  }
+
+private:
+  template <typename T> void Write(T *t) {
+    int idx = m_tracker.GetIndexForObject(t);
+    Write(idx);
+  }
+
+  template <typename T> void Write(T &t) {
+    int idx = m_tracker.GetIndexForObject(&t);
+    Write(idx);
+  }
+
+  void Write(std::string t);
+  void Write(const char *t);
+
+#define SB_SERIALIZER_POD(Type)                                                \
+  void Write(Type t) {                                                         \
+    m_stream.write(reinterpret_cast<const char *>(&t), sizeof(Type));          \
+  }
+
+  SB_SERIALIZER_POD(bool);
+  SB_SERIALIZER_POD(char);
+  SB_SERIALIZER_POD(double);
+  SB_SERIALIZER_POD(float);
+  SB_SERIALIZER_POD(int);
+  SB_SERIALIZER_POD(long long);
+  SB_SERIALIZER_POD(long);
+  SB_SERIALIZER_POD(short);
+  SB_SERIALIZER_POD(unsigned char);
+  SB_SERIALIZER_POD(unsigned int);
+  SB_SERIALIZER_POD(unsigned long long);
+  SB_SERIALIZER_POD(unsigned long);
+  SB_SERIALIZER_POD(unsigned short);
+
+private:
+  llvm::raw_ostream &m_stream;
+  SBObjectToIndex m_tracker;
+};
+
+class SBDeserializer {
+public:
+  SBDeserializer(llvm::StringRef buffer) : m_buffer(buffer), m_offset(0) {}
+
+  template <typename T> T Read() {
+    T t;
+    std::memcpy((char *)&t, &m_buffer.data()[m_offset], sizeof(t));
+    m_offset += sizeof(t);
+    return t;
+  }
+
+  bool HasData(int offset = 0);
+
+private:
+  llvm::StringRef m_buffer;
+  uint32_t m_offset;
+};
+
+template <> const char *SBDeserializer::Read<const char *>();
+
 } // namespace repro
 } // namespace lldb_private
 
 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(lldb_private::repro::ProviderInfo)
 
 namespace llvm {
 namespace yaml {
 

source/API/CMakeLists.txt

add_lldb_library(liblldb SHARED
   SBTypeNameSpecifier.cpp
   SBTypeSummary.cpp
   SBTypeSynthetic.cpp
   SBValue.cpp
   SBValueList.cpp
   SBVariablesOptions.cpp
   SBWatchpoint.cpp
   SBUnixSignals.cpp
+  SBReproducer.cpp
   SystemInitializerFull.cpp
   ${lldb_python_wrapper}
 
   LINK_LIBS
     lldbBase
     lldbBreakpoint
     lldbCore
     lldbDataFormatters

source/API/SBCommandInterpreter.cpp

 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExecutionContext.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
+#include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBTarget.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
+  SB_RECORD(this);
   m_opaque_up.reset(new CommandInterpreterRunOptions());
 }
 
 SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
 
 bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
+  SB_RECORD(this);
   return m_opaque_up->GetStopOnContinue();
 }
 
 void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
+  SB_RECORD(this, stop_on_continue);
   m_opaque_up->SetStopOnContinue(stop_on_continue);
 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnError() const {
+  SB_RECORD(this);
   return m_opaque_up->GetStopOnError();
 }
 
 void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
+  SB_RECORD(this, stop_on_error);
   m_opaque_up->SetStopOnError(stop_on_error);
 }
 
 bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
+  SB_RECORD(this);
   return m_opaque_up->GetStopOnCrash();
 }
 
 void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
+  SB_RECORD(this, stop_on_crash);
   m_opaque_up->SetStopOnCrash(stop_on_crash);
 }
 
 bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
+  SB_RECORD(this);
   return m_opaque_up->GetEchoCommands();
 }
 
 void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
+  SB_RECORD(this, echo_commands);
   m_opaque_up->SetEchoCommands(echo_commands);
 }
 
 bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
+  SB_RECORD(this);
   return m_opaque_up->GetEchoCommentCommands();
 }
 
 void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
+  SB_RECORD(this, echo);
   m_opaque_up->SetEchoCommentCommands(echo);
 }
 
 bool SBCommandInterpreterRunOptions::GetPrintResults() const {
+  SB_RECORD(this);
   return m_opaque_up->GetPrintResults();
 }
 
 void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
+  SB_RECORD(this, print_results);
   m_opaque_up->SetPrintResults(print_results);
 }
 
 bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
+  SB_RECORD(this);
   return m_opaque_up->GetAddToHistory();
 }
 
 void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
+  SB_RECORD(this, add_to_history);
   m_opaque_up->SetAddToHistory(add_to_history);
 }
 
 lldb_private::CommandInterpreterRunOptions *
 SBCommandInterpreterRunOptions::get() const {
   return m_opaque_up.get();
 }
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     sb_return.Release();
     return ret;
   }
   std::shared_ptr<lldb::SBCommandPluginInterface> m_backend;
 };
 
 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
     : m_opaque_ptr(interpreter) {
+  SB_RECORD(this, interpreter);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBCommandInterpreter::SBCommandInterpreter (interpreter=%p)"
                 " => SBCommandInterpreter(%p)",
                 static_cast<void *>(interpreter),
                 static_cast<void *>(m_opaque_ptr));
 }
 
 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
-    : m_opaque_ptr(rhs.m_opaque_ptr) {}
+    : m_opaque_ptr(rhs.m_opaque_ptr) {
+  SB_RECORD(this, rhs);
+}
 
 SBCommandInterpreter::~SBCommandInterpreter() = default;
 
 const SBCommandInterpreter &SBCommandInterpreter::
 operator=(const SBCommandInterpreter &rhs) {
+  SB_RECORD(this, rhs);
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }
 
-bool SBCommandInterpreter::IsValid() const { return m_opaque_ptr != nullptr; }
+bool SBCommandInterpreter::IsValid() const {
+  SB_RECORD(this);
+  return m_opaque_ptr != nullptr;
+}
 
 bool SBCommandInterpreter::CommandExists(const char *cmd) {
+  SB_RECORD(this);
   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd)
                                           : false);
 }
 
 bool SBCommandInterpreter::AliasExists(const char *cmd) {
+  SB_RECORD(this, cmd);
   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
                                           : false);
 }
 
 bool SBCommandInterpreter::IsActive() {
+  SB_RECORD(this);
   return (IsValid() ? m_opaque_ptr->IsActive() : false);
 }
 
 bool SBCommandInterpreter::WasInterrupted() const {
+  SB_RECORD(this);
   return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
 }
 
 const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
+  SB_RECORD(this, ch);
   return (IsValid()
               ? m_opaque_ptr->GetDebugger()
                     .GetTopIOHandlerControlSequence(ch)
                     .GetCString()
               : nullptr);
 }
 
 lldb::ReturnStatus
 SBCommandInterpreter::HandleCommand(const char *command_line,
                                     SBCommandReturnObject &result,
                                     bool add_to_history) {
+  SB_RECORD(this, command_line, result, add_to_history);
   SBExecutionContext sb_exe_ctx;
   return HandleCommand(command_line, sb_exe_ctx, result, add_to_history);
 }
 
 lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
     const char *command_line, SBExecutionContext &override_context,
     SBCommandReturnObject &result, bool add_to_history) {
+  SB_RECORD(this, command_line, result, add_to_history);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", "
                 "SBCommandReturnObject(%p), add_to_history=%i)",
                 static_cast<void *>(m_opaque_ptr), command_line,
                 static_cast<void *>(result.get()), add_to_history);
 
lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
 
   return result.GetStatus();
 }
 
 void SBCommandInterpreter::HandleCommandsFromFile(
     lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
     lldb::SBCommandInterpreterRunOptions &options,
     lldb::SBCommandReturnObject result) {
+  SB_RECORD(this, file, override_context, options, result);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log) {
     SBStream s;
     file.GetDescription(s);
     log->Printf("SBCommandInterpreter(%p)::HandleCommandsFromFile "
                 "(file=\"%s\", SBCommandReturnObject(%p))",
                 static_cast<void *>(m_opaque_ptr), s.GetData(),
void SBCommandInterpreter::HandleCommandsFromFile(
 
   m_opaque_ptr->HandleCommandsFromFile(tmp_spec, ctx_ptr, options.ref(),
                                        result.ref());
 }
 
 int SBCommandInterpreter::HandleCompletion(
     const char *current_line, const char *cursor, const char *last_char,
     int match_start_point, int max_return_elements, SBStringList &matches) {
+  SB_RECORD(this, current_line, cursor, last_char, match_start_point,
+            max_return_elements, matches);
   SBStringList dummy_descriptions;
   return HandleCompletionWithDescriptions(
       current_line, cursor, last_char, match_start_point, max_return_elements,
       matches, dummy_descriptions);
 }
 
 int SBCommandInterpreter::HandleCompletionWithDescriptions(
     const char *current_line, const char *cursor, const char *last_char,
int SBCommandInterpreter::HandleCompletionWithDescriptions(
 
   return num_completions;
 }
 
 int SBCommandInterpreter::HandleCompletionWithDescriptions(
     const char *current_line, uint32_t cursor_pos, int match_start_point,
     int max_return_elements, SBStringList &matches,
     SBStringList &descriptions) {
+  SB_RECORD(this, current_line, cursor_pos, match_start_point,
+            max_return_elements, matches);
   const char *cursor = current_line + cursor_pos;
   const char *last_char = current_line + strlen(current_line);
   return HandleCompletionWithDescriptions(
       current_line, cursor, last_char, match_start_point, max_return_elements,
       matches, descriptions);
 }
 
 int SBCommandInterpreter::HandleCompletion(const char *current_line,
                                            uint32_t cursor_pos,
                                            int match_start_point,
                                            int max_return_elements,
                                            lldb::SBStringList &matches) {
+  SB_RECORD(this, current_line, cursor_pos, match_start_point,
+            max_return_elements, matches);
   const char *cursor = current_line + cursor_pos;
   const char *last_char = current_line + strlen(current_line);
   return HandleCompletion(current_line, cursor, last_char, match_start_point,
                           max_return_elements, matches);
 }
 
 bool SBCommandInterpreter::HasCommands() {
+  SB_RECORD(this);
   return (IsValid() ? m_opaque_ptr->HasCommands() : false);
 }
 
 bool SBCommandInterpreter::HasAliases() {
+  SB_RECORD(this);
   return (IsValid() ? m_opaque_ptr->HasAliases() : false);
 }
 
 bool SBCommandInterpreter::HasAliasOptions() {
+  SB_RECORD(this);
   return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
 }
 
 SBProcess SBCommandInterpreter::GetProcess() {
+  SB_RECORD(this);
   SBProcess sb_process;
   ProcessSP process_sp;
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     if (target_sp) {
       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
       process_sp = target_sp->GetProcessSP();
       sb_process.SetSP(process_sp);
     }
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBCommandInterpreter(%p)::GetProcess () => SBProcess(%p)",
                 static_cast<void *>(m_opaque_ptr),
                 static_cast<void *>(process_sp.get()));
 
   return sb_process;
 }
 
 SBDebugger SBCommandInterpreter::GetDebugger() {
+  SB_RECORD(this);
   SBDebugger sb_debugger;
   if (IsValid())
     sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBCommandInterpreter(%p)::GetDebugger () => SBDebugger(%p)",
                 static_cast<void *>(m_opaque_ptr),
                 static_cast<void *>(sb_debugger.get()));
 
   return sb_debugger;
 }
 
 bool SBCommandInterpreter::GetPromptOnQuit() {
+  SB_RECORD(this);
   return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
 }
 
 void SBCommandInterpreter::SetPromptOnQuit(bool b) {
+  SB_RECORD(this, b);
   if (IsValid())
     m_opaque_ptr->SetPromptOnQuit(b);
 }
 
 void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
+  SB_RECORD(this, allow);
   if (m_opaque_ptr)
     m_opaque_ptr->AllowExitCodeOnQuit(allow);
 }
 
 bool SBCommandInterpreter::HasCustomQuitExitCode() {
+  SB_RECORD(this);
   bool exited = false;
   if (m_opaque_ptr)
     m_opaque_ptr->GetQuitExitCode(exited);
   return exited;
 }
 
 int SBCommandInterpreter::GetQuitStatus() {
+  SB_RECORD(this);
   bool exited = false;
   return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
 }
 
 void SBCommandInterpreter::ResolveCommand(const char *command_line,
                                           SBCommandReturnObject &result) {
+  SB_RECORD(this, command_line, result);
   result.Clear();
   if (command_line && IsValid()) {
     m_opaque_ptr->ResolveCommand(command_line, result.ref());
   } else {
     result->AppendError(
         "SBCommandInterpreter or the command line is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
 }
 
-CommandInterpreter *SBCommandInterpreter::get() { return m_opaque_ptr; }
+CommandInterpreter *SBCommandInterpreter::get() {
+  SB_RECORD(this);
+  return m_opaque_ptr;
+}
 
 CommandInterpreter &SBCommandInterpreter::ref() {
+  SB_RECORD(this);
   assert(m_opaque_ptr);
   return *m_opaque_ptr;
 }
 
 void SBCommandInterpreter::reset(
     lldb_private::CommandInterpreter *interpreter) {
+  SB_RECORD(this);
   m_opaque_ptr = interpreter;
 }
 
 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
     SBCommandReturnObject &result) {
+  SB_RECORD(this, result);
   result.Clear();
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFile(false, result.ref());
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf("SBCommandInterpreter(%p)::SourceInitFileInHomeDirectory "
                 "(&SBCommandReturnObject(%p))",
                 static_cast<void *>(m_opaque_ptr),
                 static_cast<void *>(result.get()));
 }
 
 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
     SBCommandReturnObject &result) {
+  SB_RECORD(this, result);
   result.Clear();
   if (IsValid()) {
     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFile(true, result.ref());
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf(
         "SBCommandInterpreter(%p)::SourceInitFileInCurrentWorkingDirectory "
         "(&SBCommandReturnObject(%p))",
         static_cast<void *>(m_opaque_ptr), static_cast<void *>(result.get()));
 }
 
 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
+  SB_RECORD(this);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBBroadcaster broadcaster(m_opaque_ptr, false);
 
   if (log)
     log->Printf(
         "SBCommandInterpreter(%p)::GetBroadcaster() => SBBroadcaster(%p)",
         static_cast<void *>(m_opaque_ptr),
         static_cast<void *>(broadcaster.get()));
 
   return broadcaster;
 }
 
 const char *SBCommandInterpreter::GetBroadcasterClass() {
+  SB_RECORD_NO_ARGS;
   return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
 }
 
 const char *SBCommandInterpreter::GetArgumentTypeAsCString(
     const lldb::CommandArgumentType arg_type) {
+  SB_RECORD(arg_type);
   return CommandObject::GetArgumentTypeAsCString(arg_type);
 }
 
 const char *SBCommandInterpreter::GetArgumentDescriptionAsCString(
     const lldb::CommandArgumentType arg_type) {
+  SB_RECORD(arg_type);
   return CommandObject::GetArgumentDescriptionAsCString(arg_type);
 }
 
 bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
     const lldb::SBEvent &event) {
+  SB_RECORD(event);
   return event.GetBroadcasterClass() ==
          SBCommandInterpreter::GetBroadcasterClass();
 }
 
 bool SBCommandInterpreter::SetCommandOverrideCallback(
     const char *command_name, lldb::CommandOverrideCallback callback,
     void *baton) {
+  SB_RECORD(this, command_name, callback, baton);
   if (command_name && command_name[0] && IsValid()) {
     llvm::StringRef command_name_str = command_name;
     CommandObject *cmd_obj =
         m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
     if (cmd_obj) {
       assert(command_name_str.empty());
       cmd_obj->SetOverrideCallback(callback, baton);
       return true;
     }
   }
   return false;
 }
 
 lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
                                                           const char *help) {
+  SB_RECORD(this, name, help);
   CommandObjectMultiword *new_command =
       new CommandObjectMultiword(*m_opaque_ptr, name, help);
   new_command->SetRemovable(true);
   lldb::CommandObjectSP new_command_sp(new_command);
   if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();
 }
 
 lldb::SBCommand SBCommandInterpreter::AddCommand(
     const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
+  SB_RECORD(this, name, impl, help);
   lldb::CommandObjectSP new_command_sp;
   new_command_sp.reset(new CommandPluginInterfaceImplementation(
       *m_opaque_ptr, name, impl, help));
 
   if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();
 }
 
 lldb::SBCommand
 SBCommandInterpreter::AddCommand(const char *name,
                                  lldb::SBCommandPluginInterface *impl,
                                  const char *help, const char *syntax) {
+  SB_RECORD(this, name, impl, help, syntax);
   lldb::CommandObjectSP new_command_sp;
   new_command_sp.reset(new CommandPluginInterfaceImplementation(
       *m_opaque_ptr, name, impl, help, syntax));
 
   if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();

source/API/SBCommandReturnObject.cpp

 //===-- SBCommandReturnObject.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBError.h"
+#include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBCommandReturnObject::SBCommandReturnObject()
-    : m_opaque_ap(new CommandReturnObject()) {}
+    : m_opaque_ap(new CommandReturnObject()) {
+  SB_RECORD(this);
+}
 
 SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs)
     : m_opaque_ap() {
+  SB_RECORD(this, rhs);
   if (rhs.m_opaque_ap)
     m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap));
 }
 
 SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr)
-    : m_opaque_ap(ptr) {}
+    : m_opaque_ap(ptr) {
+  SB_RECORD(this, ptr);
+}
 
 SBCommandReturnObject::~SBCommandReturnObject() = default;
 
 CommandReturnObject *SBCommandReturnObject::Release() {
+  SB_RECORD(this);
   return m_opaque_ap.release();
 }
 
 const SBCommandReturnObject &SBCommandReturnObject::
 operator=(const SBCommandReturnObject &rhs) {
+  SB_RECORD(this, rhs);
   if (this != &rhs) {
     if (rhs.m_opaque_ap)
       m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap));
     else
       m_opaque_ap.reset();
   }
   return *this;
 }
 
-bool SBCommandReturnObject::IsValid() const { return m_opaque_ap != nullptr; }
+bool SBCommandReturnObject::IsValid() const {
+  SB_RECORD(this);
+  return m_opaque_ap != nullptr;
+}
 
 const char *SBCommandReturnObject::GetOutput() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (m_opaque_ap) {
     llvm::StringRef output = m_opaque_ap->GetOutputData();
     ConstString result(output.empty() ? llvm::StringRef("") : output);
 

source/API/SBDebugger.cpp

 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
+#include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBSourceManager.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/API/SBTypeCategory.h"
 #include "lldb/API/SBTypeFilter.h"
SBError SBInputReader::Initialize(
     void *, lldb::InputReaderGranularity, char const *, char const *, bool) {
   return SBError();
 }
 
 void SBInputReader::SetIsDone(bool) {}
 
 bool SBInputReader::IsActive() const { return false; }
 
-SBDebugger::SBDebugger() = default;
+SBDebugger::SBDebugger() { SB_RECORD(this); }
 
 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
-    : m_opaque_sp(debugger_sp) {}
+    : m_opaque_sp(debugger_sp) {
+  SB_RECORD(this);
+}
 
-SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
+SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
+  SB_RECORD(this, rhs);
+}
 
 SBDebugger::~SBDebugger() = default;
 
 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
+  SB_RECORD(this, rhs);
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
   return *this;
 }
 
 void SBDebugger::Initialize() {
   SBInitializerOptions options;
void SBDebugger::Clear() {
 
   if (m_opaque_sp)
     m_opaque_sp->ClearIOHandlers();
 
   m_opaque_sp.reset();
 }
 
 SBDebugger SBDebugger::Create() {
-  return SBDebugger::Create(false, nullptr, nullptr);
+  SB_RECORD_NO_ARGS;
+  return SB_RECORD_RETURN(SBDebugger::Create(false, nullptr, nullptr));
 }
 
 SBDebugger SBDebugger::Create(bool source_init_files) {
-  return SBDebugger::Create(source_init_files, nullptr, nullptr);
+  SB_RECORD(source_init_files);
+  return SB_RECORD_RETURN(
+      SBDebugger::Create(source_init_files, nullptr, nullptr));
 }
 
 SBDebugger SBDebugger::Create(bool source_init_files,
                               lldb::LogOutputCallback callback, void *baton)
 
 {
+  SB_RECORD(source_init_files, callback, baton);
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBDebugger debugger;
 
   // Currently we have issues if this function is called simultaneously on two
   // different threads. The issues mainly revolve around the fact that the
   // lldb_private::FormatManager uses global collections and having two threads
   // parsing the .lldbinit files can cause mayhem. So to get around this for
if (source_init_files) {
     interp.get()->SkipLLDBInitFiles(false);
     interp.get()->SkipAppInitFiles(false);
     SBCommandReturnObject result;
     interp.SourceInitFileInHomeDirectory(result);
   } else {
     interp.get()->SkipLLDBInitFiles(true);
     interp.get()->SkipAppInitFiles(true);
   }
-  return debugger;
+  return SB_RECORD_RETURN(debugger);
 }
 
 void SBDebugger::Destroy(SBDebugger &debugger) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log) {
     SBStream sstr;
     debugger.GetDescription(sstr);
void SBDebugger::MemoryPressureDetected() {
   if (log) {
     log->Printf("SBDebugger::MemoryPressureDetected (), mandatory = %d",
                 mandatory);
   }
 
   ModuleList::RemoveOrphanSharedModules(mandatory);
 }
 
-bool SBDebugger::IsValid() const { return m_opaque_sp.get() != nullptr; }
+bool SBDebugger::IsValid() const {
+  SB_RECORD(this);
+  return m_opaque_sp.get() != nullptr;
+}
 
 void SBDebugger::SetAsync(bool b) {
+  SB_RECORD(this, b);
   if (m_opaque_sp)
     m_opaque_sp->SetAsyncExecution(b);
 }
 
 bool SBDebugger::GetAsync() {
+  SB_RECORD(this);
   return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
 }
 
 void SBDebugger::SkipLLDBInitFiles(bool b) {
+  SB_RECORD(this, b);
   if (m_opaque_sp)
     m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
 }
 
 void SBDebugger::SkipAppInitFiles(bool b) {
+  SB_RECORD(this, b);
   if (m_opaque_sp)
     m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
 }
 
 // Shouldn't really be settable after initialization as this could cause lots
 // of problems; don't want users trying to switch modes in the middle of a
 // debugging session.
 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
+  SB_RECORD(this, fh, transfer_ownership);
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf(
         "SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)",
         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
         transfer_ownership);
 
   if (m_opaque_sp)
     m_opaque_sp->SetInputFileHandle(fh, transfer_ownership);
 }
 
 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
+  SB_RECORD(this, fh, transfer_ownership);
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf(
         "SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)",
         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
         transfer_ownership);
 
   if (m_opaque_sp)
     m_opaque_sp->SetOutputFileHandle(fh, transfer_ownership);
 }
 
 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
+  SB_RECORD(this, fh, transfer_ownership);
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)
     log->Printf(
         "SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)",
         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
         transfer_ownership);
 
   if (m_opaque_sp)
     m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
 }
 
 FILE *SBDebugger::GetInputFileHandle() {
+  SB_RECORD(this);
   if (m_opaque_sp) {
     StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
     if (stream_file_sp)
       return stream_file_sp->GetFile().GetStream();
   }
   return nullptr;
 }
 
 FILE *SBDebugger::GetOutputFileHandle() {
+  SB_RECORD(this);
   if (m_opaque_sp) {
     StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
     if (stream_file_sp)
       return stream_file_sp->GetFile().GetStream();
   }
   return nullptr;
 }
 
 FILE *SBDebugger::GetErrorFileHandle() {
+  SB_RECORD(this);
   if (m_opaque_sp) {
     StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
     if (stream_file_sp)
       return stream_file_sp->GetFile().GetStream();
   }
   return nullptr;
 }
 
 void SBDebugger::SaveInputTerminalState() {
+  SB_RECORD(this);
   if (m_opaque_sp)
     m_opaque_sp->SaveInputTerminalState();
 }
 
 void SBDebugger::RestoreInputTerminalState() {
+  SB_RECORD(this);
   if (m_opaque_sp)
     m_opaque_sp->RestoreInputTerminalState();
 }
+
 SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
+  SB_RECORD(this);
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBCommandInterpreter sb_interpreter;
   if (m_opaque_sp)
     sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
 
   if (log)
     log->Printf(
         "SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
         static_cast<void *>(m_opaque_sp.get()),
         static_cast<void *>(sb_interpreter.get()));
 
-  return sb_interpreter;
+  return SB_RECORD_RETURN(sb_interpreter);
 }
 
 void SBDebugger::HandleCommand(const char *command) {
+  SB_RECORD(this, command);
   if (m_opaque_sp) {
     TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 
     SBCommandInterpreter sb_interpreter(GetCommandInterpreter());
     SBCommandReturnObject result;
void SBDebugger::DispatchInputEndOfFile() {
   if (m_opaque_sp)
     m_opaque_sp->DispatchInputEndOfFile();
 }
 
 void SBDebugger::PushInputReader(SBInputReader &reader) {}
 
 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
                                        bool spawn_thread) {
+  SB_RECORD(this, auto_handle_events, spawn_thread);
   if (m_opaque_sp) {
     CommandInterpreterRunOptions options;
 
     m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
         auto_handle_events, spawn_thread, options);
   }
 }
 
 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
                                        bool spawn_thread,
                                        SBCommandInterpreterRunOptions &options,
                                        int &num_errors, bool &quit_requested,
                                        bool &stopped_for_crash)
 
 {
+  SB_RECORD(this, auto_handle_events, spawn_thread, options, num_errors,
+            quit_requested, stopped_for_crash);
   if (m_opaque_sp) {
     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
     interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
                                  options.ref());
     num_errors = interp.GetNumErrors();
     quit_requested = interp.GetQuitRequested();
     stopped_for_crash = interp.GetStoppedForCrash();
   }

source/API/SBFileSpec.cpp

 //===-- SBFileSpec.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <inttypes.h>
 #include <limits.h>
 
 #include "lldb/API/SBFileSpec.h"
+#include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/SmallString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBFileSpec::SBFileSpec() : m_opaque_ap(new lldb_private::FileSpec()) {}
+SBFileSpec::SBFileSpec() : m_opaque_ap(new lldb_private::FileSpec()) {
+  SB_RECORD(this);
+}
 
 SBFileSpec::SBFileSpec(const SBFileSpec &rhs)
-    : m_opaque_ap(new lldb_private::FileSpec(*rhs.m_opaque_ap)) {}
+    : m_opaque_ap(new lldb_private::FileSpec(*rhs.m_opaque_ap)) {
+  SB_RECORD(this, rhs);
+}
 
 SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec)
-    : m_opaque_ap(new lldb_private::FileSpec(fspec)) {}
+    : m_opaque_ap(new lldb_private::FileSpec(fspec)) {
+  SB_RECORD(this, fspec);
+}
 
 // Deprecated!!!
 SBFileSpec::SBFileSpec(const char *path) : m_opaque_ap(new FileSpec(path)) {
+  SB_RECORD(this, path);
   FileSystem::Instance().Resolve(*m_opaque_ap);
 }
 
 SBFileSpec::SBFileSpec(const char *path, bool resolve)
     : m_opaque_ap(new FileSpec(path)) {
+  SB_RECORD(this, path, resolve);
   if (resolve)
     FileSystem::Instance().Resolve(*m_opaque_ap);
 }
 
 SBFileSpec::~SBFileSpec() {}
 
 const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
+  SB_RECORD(this, rhs);
   if (this != &rhs)
     *m_opaque_ap = *rhs.m_opaque_ap;
-  return *this;
+  return SB_RECORD_RETURN(*this);
 }
 
-bool SBFileSpec::IsValid() const { return m_opaque_ap->operator bool(); }
+bool SBFileSpec::IsValid() const {
+  SB_RECORD(this);
+  return m_opaque_ap->operator bool();
+}
 
 bool SBFileSpec::Exists() const {
+  SB_RECORD(this);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool result = FileSystem::Instance().Exists(*m_opaque_ap);
 
   if (log)
     log->Printf("SBFileSpec(%p)::Exists () => %s",
                 static_cast<void *>(m_opaque_ap.get()),
                 (result ? "true" : "false"));
 
   return result;
 }
 
 bool SBFileSpec::ResolveExecutableLocation() {
+  SB_RECORD(this);
   return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_ap);
 }
 
 int SBFileSpec::ResolvePath(const char *src_path, char *dst_path,
                             size_t dst_len) {
+  SB_RECORD(src_path, dst_path, dst_len);
   llvm::SmallString<64> result(src_path);
   FileSystem::Instance().Resolve(result);
   ::snprintf(dst_path, dst_len, "%s", result.c_str());
   return std::min(dst_len - 1, result.size());
 }
 
 const char *SBFileSpec::GetFilename() const {
+  SB_RECORD(this);
   const char *s = m_opaque_ap->GetFilename().AsCString();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (s)
       log->Printf("SBFileSpec(%p)::GetFilename () => \"%s\"",
                   static_cast<void *>(m_opaque_ap.get()), s);
     else
       log->Printf("SBFileSpec(%p)::GetFilename () => NULL",
                   static_cast<void *>(m_opaque_ap.get()));
   }
 
   return s;
 }
 
 const char *SBFileSpec::GetDirectory() const {
+  SB_RECORD(this);
   FileSpec directory{*m_opaque_ap};
   directory.GetFilename().Clear();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log) {
     if (directory)
       log->Printf("SBFileSpec(%p)::GetDirectory () => \"%s\"",
                   static_cast<void *>(m_opaque_ap.get()),
                   directory.GetCString());
     else
       log->Printf("SBFileSpec(%p)::GetDirectory () => NULL",
                   static_cast<void *>(m_opaque_ap.get()));
   }
   return directory.GetCString();
 }
 
 void SBFileSpec::SetFilename(const char *filename) {
+  SB_RECORD(this, filename);
   if (filename && filename[0])
     m_opaque_ap->GetFilename().SetCString(filename);
   else
     m_opaque_ap->GetFilename().Clear();
 }
 
 void SBFileSpec::SetDirectory(const char *directory) {
+  SB_RECORD(this, directory);
   if (directory && directory[0])
     m_opaque_ap->GetDirectory().SetCString(directory);
   else
     m_opaque_ap->GetDirectory().Clear();
 }
 
 uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const {
+  SB_RECORD(this, dst_path, dst_len);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   uint32_t result = m_opaque_ap->GetPath(dst_path, dst_len);
 
   if (log)
     log->Printf("SBFileSpec(%p)::GetPath (dst_path=\"%.*s\", dst_len=%" PRIu64
                 ") => %u",
                 static_cast<void *>(m_opaque_ap.get()), result, dst_path,
                 static_cast<uint64_t>(dst_len), result);
 
   if (result == 0 && dst_path && dst_len > 0)
     *dst_path = '\0';
   return result;
 }
 
 const lldb_private::FileSpec *SBFileSpec::operator->() const {
+  SB_RECORD(this);
   return m_opaque_ap.get();
 }
 
 const lldb_private::FileSpec *SBFileSpec::get() const {
+  SB_RECORD(this);
   return m_opaque_ap.get();
 }
 
 const lldb_private::FileSpec &SBFileSpec::operator*() const {
+  SB_RECORD(this);
   return *m_opaque_ap;
 }
 
-const lldb_private::FileSpec &SBFileSpec::ref() const { return *m_opaque_ap; }
+const lldb_private::FileSpec &SBFileSpec::ref() const {
+  SB_RECORD(this);
+  return *m_opaque_ap;
+}
 
 void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) {
+  SB_RECORD(this, fs);
   *m_opaque_ap = fs;
 }
 
 bool SBFileSpec::GetDescription(SBStream &description) const {
+  SB_RECORD(this, description);
   Stream &strm = description.ref();
   char path[PATH_MAX];
   if (m_opaque_ap->GetPath(path, sizeof(path)))
     strm.PutCString(path);
   return true;
 }
 
 void SBFileSpec::AppendPathComponent(const char *fn) {
+  SB_RECORD(this, fn);
   m_opaque_ap->AppendPathComponent(fn);
 }

source/API/SBHostOS.cpp

 //===-- SBHostOS.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_DISABLE_PYTHON
 #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
 #endif
 
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBHostOS.h"
+#include "lldb/API/SBReproducer.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
#endif
   }
 
   SBFileSpec sb_fspec;
   sb_fspec.SetFileSpec(fspec);
   return sb_fspec;
 }
 
 SBFileSpec SBHostOS::GetUserHomeDirectory() {
+  SB_RECORD_NO_ARGS;
   SBFileSpec sb_fspec;
 
   llvm::SmallString<64> home_dir_path;
   llvm::sys::path::home_directory(home_dir_path);
   FileSpec homedir(home_dir_path.c_str());
   FileSystem::Instance().Resolve(homedir);
 
   sb_fspec.SetFileSpec(homedir);
-  return sb_fspec;
+
+  return SB_RECORD_RETURN(sb_fspec);
 }
 
 lldb::thread_t SBHostOS::ThreadCreate(const char *name,
                                       lldb::thread_func_t thread_function,
                                       void *thread_arg, SBError *error_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (log)

source/API/SBReproducer.cpp

+//===-- SBReproducer.cpp ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/API/SBReproducer.h"
+#include "lldb/API/LLDB.h"
+
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Utility/FileSpec.h"
+
+using namespace lldb;
+using namespace lldb_private::repro;
+using namespace lldb_private;
+using namespace llvm;
+
+static FileSpec GetCommandFile() {
+  repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
+  if (!loader) {
+    return {};
+  }
+
+  auto provider_info = loader->GetProviderInfo("command-interpreter");
+  if (!provider_info) {
+    return {};
+  }
+
+  if (provider_info->files.empty()) {
+    return {};
+  }
+
+  return loader->GetRoot().CopyByAppendingPathComponent(
+      provider_info->files.front());
+}
+
+template <typename T>
+T *ReadObject(SBDeserializer &s, SBIndexToObject &index_to_object) {
+  return index_to_object.GetObjectForIndex<T>(s.Read<int>());
+}
+
+#define SB_REGISTER(function, implementation)                                  \
+  {                                                                            \
+    m_functions[function] = [&](SBDeserializer &s) { implementation };         \
+  }
+
+void SBReplayer::Init() {
+  SB_REGISTER("lldb::SBFileSpec::SBFileSpec(const char *, bool)", {
+    auto t = s.Read<int>(); // this
+    auto a = s.Read<const char *>();
+    auto b = s.Read<bool>();
+    auto x = new SBFileSpec(a, b);
+    m_index_to_object.AddObjectForIndex(t, x);
+  });
+
+  SB_REGISTER("lldb::SBFileSpec::SBFileSpec(const char *)", {
+    auto t = s.Read<int>(); // this
+    auto a = s.Read<const char *>();
+    auto x = new SBFileSpec(a);
+    m_index_to_object.AddObjectForIndex(t, x);
+  });
+
+  SB_REGISTER("static lldb::SBFileSpec lldb::SBHostOS::GetUserHomeDirectory()",
+              {
+                auto r = s.Read<int>(); // return
+                auto x = new SBFileSpec(SBHostOS::GetUserHomeDirectory());
+                m_index_to_object.AddObjectForIndex(r, x);
+              });
+
+  SB_REGISTER("void lldb::SBFileSpec::AppendPathComponent(const char *)", {
+    auto a = ReadObject<SBFileSpec>(s, m_index_to_object);
+    auto b = s.Read<const char *>();
+    a->AppendPathComponent(b);
+  });
+
+  SB_REGISTER("lldb::SBFileSpec::SBFileSpec(const lldb::SBFileSpec &)", {
+    auto t = s.Read<int>(); // this
+    auto a = m_index_to_object.GetObjectForIndex<SBFileSpec>(s.Read<int>());
+    auto x = new SBFileSpec(*a);
+    m_index_to_object.AddObjectForIndex(t, x);
+  });
+
+  SB_REGISTER("bool lldb::SBFileSpec::Exists() const", {
+    auto a = m_index_to_object.GetObjectForIndex<SBFileSpec>(s.Read<int>());
+    a->Exists();
+  });
+
+  SB_REGISTER("lldb::SBCommandInterpreterRunOptions::"
+              "SBCommandInterpreterRunOptions()",
+              {
+                auto t = s.Read<int>(); // this
+                auto x = new SBCommandInterpreterRunOptions();
+                m_index_to_object.AddObjectForIndex(t, x);
+              });
+
+  SB_REGISTER(
+      "void lldb::SBCommandInterpreterRunOptions::SetStopOnError(bool)", {
+        auto t =
+            m_index_to_object.GetObjectForIndex<SBCommandInterpreterRunOptions>(
+                s.Read<int>());
+        auto a = s.Read<bool>();
+        t->SetStopOnError(a);
+      });
+
+  SB_REGISTER(
+      "void lldb::SBCommandInterpreterRunOptions::SetStopOnCrash(bool)", {
+        auto t =
+            m_index_to_object.GetObjectForIndex<SBCommandInterpreterRunOptions>(
+                s.Read<int>());
+        auto a = s.Read<bool>();
+        t->SetStopOnCrash(a);
+      });
+
+  SB_REGISTER("lldb::SBCommandInterpreter::SBCommandInterpreter(lldb_private::"
+              "CommandInterpreter *)",
+              {
+                auto t = s.Read<int>();
+                auto a =
+                    m_index_to_object.GetObjectForIndex<CommandInterpreter>(
+                        s.Read<int>());
+                auto x = new SBCommandInterpreter(a);
+                m_index_to_object.AddObjectForIndex(t, x);
+              });
+
+  SB_REGISTER("bool lldb::SBCommandInterpreter::IsValid() const", {
+    auto t = m_index_to_object.GetObjectForIndex<SBCommandInterpreter>(
+        s.Read<int>()); // this
+    t->IsValid();
+  });
+
+  SB_REGISTER("lldb::SBDebugger::SBDebugger()", {
+    auto t = s.Read<int>();
+    auto x = new SBDebugger();
+    m_index_to_object.AddObjectForIndex(t, x);
+  });
+
+  SB_REGISTER("static lldb::SBDebugger lldb::SBDebugger::Create(bool)", {
+    auto a = s.Read<bool>();
+    auto r = s.Read<int>();
+    auto x = new SBDebugger(SBDebugger::Create(a));
+    m_index_to_object.AddObjectForIndex(r, x);
+  });
+
+  SB_REGISTER("lldb::SBDebugger::SBDebugger(const lldb::SBDebugger &)", {
+    auto t = s.Read<int>(); // this
+    auto a = m_index_to_object.GetObjectForIndex<SBDebugger>(s.Read<int>());
+    auto x = new SBDebugger(*a);
+    m_index_to_object.AddObjectForIndex(t, x);
+  });
+
+  SB_REGISTER(
+      "lldb::SBCommandInterpreter lldb::SBDebugger::GetCommandInterpreter()", {
+        auto t = m_index_to_object.GetObjectForIndex<SBDebugger>(
+            s.Read<int>()); // this
+        auto r = s.Read<int>();
+        auto x = new SBCommandInterpreter(t->GetCommandInterpreter());
+        m_index_to_object.AddObjectForIndex(r, x);
+      });
+
+  SB_REGISTER("void "
+              "lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory(lldb::"
+              "SBCommandReturnObject &)",
+              {
+                auto t =
+                    m_index_to_object.GetObjectForIndex<SBCommandInterpreter>(
+                        s.Read<int>()); // this
+                auto a =
+                    m_index_to_object.GetObjectForIndex<SBCommandReturnObject>(
+                        s.Read<int>());
+                t->SourceInitFileInHomeDirectory(*a);
+              });
+
+  SB_REGISTER("lldb::SBCommandReturnObject::SBCommandReturnObject()", {
+    auto t = s.Read<int>(); // this
+    auto x = new SBCommandReturnObject();
+    m_index_to_object.AddObjectForIndex(t, x);
+  });
+
+  SB_REGISTER("lldb::SBCommandInterpreter::SBCommandInterpreter(const "
+              "lldb::SBCommandInterpreter &)",
+              {
+                auto t = s.Read<int>(); // this
+                auto a =
+                    m_index_to_object.GetObjectForIndex<SBCommandInterpreter>(
+                        s.Read<int>());
+                auto x = new SBCommandInterpreter(*a);
+                m_index_to_object.AddObjectForIndex(t, x);
+              });
+
+  SB_REGISTER("void lldb::SBCommandInterpreter::AllowExitCodeOnQuit(bool)", {
+    auto t = m_index_to_object.GetObjectForIndex<SBCommandInterpreter>(
+        s.Read<int>()); // this
+    auto a = s.Read<bool>();
+    t->AllowExitCodeOnQuit(a);
+  });
+
+  SB_REGISTER(
+      "lldb::SBDebugger &lldb::SBDebugger::operator=(const lldb::SBDebugger &)",
+      {
+        auto t = s.Read<int>(); // this
+        auto a = m_index_to_object.GetObjectForIndex<SBDebugger>(s.Read<int>());
+        auto x = new SBDebugger(*a);
+        m_index_to_object.AddObjectForIndex(t, x);
+      });
+
+  SB_REGISTER("int lldb::SBCommandInterpreter::GetQuitStatus()", {
+    auto t = m_index_to_object.GetObjectForIndex<SBCommandInterpreter>(
+        s.Read<int>()); // this
+    t->GetQuitStatus();
+  });
+
+  SB_REGISTER("void lldb::SBDebugger::SkipLLDBInitFiles(bool)", {
+    auto t =
+        m_index_to_object.GetObjectForIndex<SBDebugger>(s.Read<int>()); // this
+    auto a = s.Read<bool>();
+    t->SkipLLDBInitFiles(a);
+  });
+
+  SB_REGISTER("void lldb::SBDebugger::SkipAppInitFiles(bool)", {
+    auto t =
+        m_index_to_object.GetObjectForIndex<SBDebugger>(s.Read<int>()); // this
+    auto a = s.Read<bool>();
+    t->SkipAppInitFiles(a);
+  });
+
+  SB_REGISTER("bool lldb::SBDebugger::GetAsync()", {
+    auto t =
+        m_index_to_object.GetObjectForIndex<SBDebugger>(s.Read<int>()); // this
+    t->GetAsync();
+  });
+
+  SB_REGISTER("void lldb::SBDebugger::SetAsync(bool)", {
+    auto t =
+        m_index_to_object.GetObjectForIndex<SBDebugger>(s.Read<int>()); // this
+    auto a = s.Read<bool>();
+    t->SetAsync(a);
+  });
+
+  SB_REGISTER(
+      "void lldb::SBDebugger::RunCommandInterpreter(bool, bool, "
+      "lldb::SBCommandInterpreterRunOptions &, int &, bool &, bool &)",
+      {
+        auto t = m_index_to_object.GetObjectForIndex<SBDebugger>(
+            s.Read<int>()); // this
+        auto a = s.Read<bool>();
+        auto b = s.Read<bool>();
+        auto c =
+            m_index_to_object.GetObjectForIndex<SBCommandInterpreterRunOptions>(
+                s.Read<int>());
+        auto d = s.Read<int>();
+        auto e = s.Read<bool>();
+        auto f = s.Read<bool>();
+        t->RunCommandInterpreter(a, b, *c, d, e, f);
+      });
+
+  SB_REGISTER("void lldb::SBDebugger::SetErrorFileHandle(FILE *, bool)", {
+    s.Read<int>(); // this
+    s.Read<int>();
+    s.Read<bool>();
+
+    // Do nothing.
+  });
+
+  SB_REGISTER("void lldb::SBDebugger::SetOutputFileHandle(FILE *, bool)", {
+    s.Read<int>(); // this
+    s.Read<int>();
+    s.Read<bool>();
+
+    // Do nothing.
+  });
+
+  SB_REGISTER("void lldb::SBDebugger::SetInputFileHandle(FILE *, bool)", {
+    auto t =
+        m_index_to_object.GetObjectForIndex<SBDebugger>(s.Read<int>()); // this
+    s.Read<int>();
+    s.Read<bool>();
+
+    FileSpec fs = GetCommandFile();
+    if (!fs)
+      return;
+
+    FILE *f = FileSystem::Instance().Fopen(fs.GetPath().c_str(), "r");
+    if (f == nullptr)
+      return;
+    t->SetInputFileHandle(f, true);
+  });
+
+  llvm::outs() << "Registered " << m_functions.size() << " functions\n";
+}
+
+namespace lldb {
+void GenerateReproducer() {
+  if (auto *g = Reproducer::Instance().GetGenerator()) {
+    g->Keep();
+  }
+}
+
+bool ReplayReproducer() {
+  if (auto *g = Reproducer::Instance().GetLoader()) {
+    SBReplayer replayer;
+    replayer.Init();
+    if (auto e = replayer.Replay()) {
+      llvm::outs() << toString(std::move(e)) << '\n';
+    }
+    return true;
+  }
+  return false;
+}
+} // namespace lldb
+
+char SBProvider::ID = 0;
+thread_local std::atomic<bool> SBRecorder::g_global_boundary;

source/Utility/Reproducer.cpp

llvm::Optional<ProviderInfo> Loader::GetProviderInfo(StringRef name) {
 
   auto it = m_provider_info.find(name);
   if (it == m_provider_info.end())
     return llvm::None;
 
   return it->second;
 }
 
+unsigned SBObjectToIndex::GetIndexForObjectImpl(void *object) {
+  auto it = m_mapping.find(object);
+  if (it == m_mapping.end())
+    m_mapping[object] = Increment();
+  return m_mapping[object];
+}
+
+unsigned SBObjectToIndex::Increment() {
+  std::lock_guard<std::mutex> guard(m_mutex);
+  return ++m_index;
+}
+
+void *SBIndexToObject::GetObjectForIndexImpl(int index) {
+  auto it = m_mapping.find(index);
+  if (it == m_mapping.end()) {
+    return nullptr;
+  }
+  return m_mapping[index];
+}
+
+void SBIndexToObject::AddObjectForIndexImpl(int index, void *object) {
+  if (index == -1)
+    return;
+  m_mapping[index] = object;
+}
+
+void SBSerializer::Write(std::string t) { Write(t.c_str()); }
+
+void SBSerializer::Write(const char *t) {
+  m_stream << t;
+  m_stream.write(0x0);
+}
+
+bool SBDeserializer::HasData(int offset) {
+  return m_offset + offset < m_buffer.size();
+}
+
+template <> const char *SBDeserializer::Read<const char *>() {
+  auto pos = m_buffer.find('\0', m_offset);
+  if (pos == llvm::StringRef::npos)
+    return nullptr;
+  size_t begin = m_offset;
+  m_offset = pos + 1;
+  return m_buffer.data() + begin;
+}
+
 void ProviderBase::anchor() {}
 char ProviderBase::ID = 0;

tools/driver/Driver.cpp

 //===-- Driver.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBLanguageRuntime.h"
+#include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
SBError Driver::ProcessArgs(const opt::InputArgList &args, bool &exiting) {
   if (args.hasArg(OPT_batch)) {
     m_option_data.m_batch = true;
   }
 
   if (auto *arg = args.getLastArg(OPT_core)) {
     auto arg_value = arg->getValue();
     SBFileSpec file(arg_value);
     if (!file.Exists()) {
+      GenerateReproducer();
       error.SetErrorStringWithFormat(
           "file specified in --core (-c) option doesn't exist: '%s'",
           arg_value);
       return error;
     }
     m_option_data.m_core_file = arg_value;
   }
 
#endif
 
   SBError error = SBDebugger::Initialize(options);
   if (error.Fail()) {
     WithColor::error() << "initialization failed: " << error.GetCString()
                        << '\n';
     return 1;
   }
 
   SBHostOS::ThreadCreated("<lldb.driver.main-thread>");
 
   signal(SIGINT, sigint_handler);
 #if !defined(_MSC_VER)
   signal(SIGPIPE, SIG_IGN);
   signal(SIGWINCH, sigwinch_handler);
   signal(SIGTSTP, sigtstp_handler);
   signal(SIGCONT, sigcont_handler);
 #endif
 
+  if (ReplayReproducer())
+    return 0;
+
   int exit_code = 0;
   // Create a scope for driver so that the driver object will destroy itself
   // before SBDebugger::Terminate() is called.
   {
     Driver driver;
 
     bool exiting = false;
     SBError error(driver.ProcessArgs(input_args, exiting));