[lldb/Reproducers] Simplify LLDB_RECORD macros

[JDevlieghere]

Summary

Redefine the LLDB_RECORD macros in terms of a common uber-macro to reduce code duplication across them.

[JDevlieghere]

Add a comment

[labath]

This looks even better than I hoped. I think this is a worthwhile simplification even without the followup patches. Just a couple of questions inline...

lldb/include/lldb/Utility/ReproducerInstrumentation.h

116–130

Could you merge these two in a similar way as well (not with the method macros, just with themselves)? I know that the constructors could be implemented as a function in the other patch, but I have a feeling it will be pretty confusing if two very similar functionalities were implemented in completely different ways...

132

idea: Should we standardize the name of the inner class and drop the Method argument?

749–752

Why the void overload? It looks like the templated version would work just fine for void too...

[JDevlieghere]

Address Pavel's code review feedback

[labath]

Very nice.

lldb/include/lldb/Utility/ReproducerInstrumentation.h

R.Register<Class * Signature>(&construct<Class Signature>::doit, "", #Class, \
                                 #Class, #Signature)
 
 #define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)                 \
   R.Register(                                                                  \
       &invoke<Result(Class::*) Signature>::method<(&Class::Method)>::doit,     \
       #Result, #Class, #Method, #Signature)
 
 #define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)           \
-  R.Register(&invoke<Result(Class::*) Signature const>::method_const<(         \
-                 &Class::Method)>::doit,                                       \
+  R.Register(&invoke<Result(Class::*)                                          \
+                         Signature const>::method<(&Class::Method)>::doit,     \
              #Result, #Class, #Method, #Signature)
 
 #define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature)          \
-  R.Register(                                                                  \
-      &invoke<Result(*) Signature>::method_static<(&Class::Method)>::doit,     \
+  R.Register(&invoke<Result(*) Signature>::method<(&Class::Method)>::doit,     \
              #Result, #Class, #Method, #Signature)
 
 #define LLDB_REGISTER_CHAR_PTR_REDIRECT_STATIC(Result, Class, Method)          \
-  R.Register(&invoke<Result (*)(char *, size_t)>::method_static<(              \
-                 &Class::Method)>::doit,                                       \
-             &char_ptr_redirect<Result (*)(char *, size_t)>::method_static<(   \
-                 &Class::Method)>::doit,                                       \
-             #Result, #Class, #Method, "(char*, size_t");
+  R.Register(                                                                  \
+      &invoke<Result (*)(char *, size_t)>::method<(&Class::Method)>::doit,     \
+      &char_ptr_redirect<Result (*)(char *,                                    \
+                                    size_t)>::method<(&Class::Method)>::doit,  \
 
 #define LLDB_REGISTER_CHAR_PTR_REDIRECT(Result, Class, Method)                 \
   R.Register(&invoke<Result (Class::*)(char *, size_t)>::method<(              \
                  &Class::Method)>::doit,                                       \
              &char_ptr_redirect<Result (Class::*)(char *, size_t)>::method<(   \
                  &Class::Method)>::doit,                                       \
              #Result, #Class, #Method, "(char*, size_t");
 
 #define LLDB_REGISTER_CHAR_PTR_REDIRECT_CONST(Result, Class, Method)           \
   R.Register(&invoke<Result (Class::*)(char *, size_t)                         \
-                         const>::method_const<(&Class::Method)>::doit,         \
-             &char_ptr_redirect<Result (Class::*)(                             \
-                 char *, size_t) const>::method_const<(&Class::Method)>::doit, \
+                         const>::method<(&Class::Method)>::doit,               \
+             &char_ptr_redirect<Result (Class::*)(char *, size_t)              \
+                                    const>::method<(&Class::Method)>::doit,    \
              #Result, #Class, #Method, "(char*, size_t");
 
-#define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...)                         \
+#define LLDB_CONSTRUCT_(T, ...)                                                \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                           stringify_args(__VA_ARGS__));        \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::construct<Class Signature>::doit,   \
-                     __VA_ARGS__);                                             \
+                     &lldb_private::repro::construct<T>::doit, __VA_ARGS__);   \
     _recorder.RecordResult(this, false);                                       \
   }
 
+#define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...)                         \
+  LLDB_CONSTRUCT_(Class Signature, __VA_ARGS__)
+
 #define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)                                 \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);               \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::construct<Class()>::doit);          \
-    _recorder.RecordResult(this, false);                                       \
-  }
+  LLDB_CONSTRUCT_(Class(), lldb_private::repro::EmptyArg())
 
-#define LLDB_RECORD_METHOD(Result, Class, Method, Signature, ...)              \
+#define LLDB_RECORD_(T1, T2, ...)                                              \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(*this, __VA_ARGS__)); \
+                                          stringify_args(__VA_ARGS__));        \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::invoke<Result(                      \
-                         Class::*) Signature>::method<(&Class::Method)>::doit, \
-                     this, __VA_ARGS__);                                       \
+                     &lldb_private::repro::invoke<T1>::method<T2>::doit,       \
+                     __VA_ARGS__);                                             \
   }
 
+#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_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(*this, __VA_ARGS__)); \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(                                                          \
-        _data.GetSerializer(), _data.GetRegistry(),                            \
-        &lldb_private::repro::invoke<Result(                                   \
-            Class::*) Signature const>::method_const<(&Class::Method)>::doit,  \
-        this, __VA_ARGS__);                                                    \
-  }
+  LLDB_RECORD_(Result(Class::*) Signature const, (&Class::Method), this,       \
+               __VA_ARGS__)
 
 #define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)                      \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(*this));              \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::invoke<Result (                     \
-                         Class::*)()>::method<(&Class::Method)>::doit,         \
-                     this);                                                    \
-  }
+  LLDB_RECORD_(Result (Class::*)(), (&Class::Method), this)
 
 #define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)                \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(*this));              \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(                                                          \
-        _data.GetSerializer(), _data.GetRegistry(),                            \
-        &lldb_private::repro::invoke<Result (                                  \
-            Class::*)() const>::method_const<(&Class::Method)>::doit,          \
-        this);                                                                 \
-  }
+  LLDB_RECORD_(Result (Class::*)() const, (&Class::Method), this)
 
 #define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature, ...)       \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(__VA_ARGS__));        \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(                                                          \
-        _data.GetSerializer(), _data.GetRegistry(),                            \
-        lldb_private::repro::invoke<Result(*) Signature>::method_static<(      \
-            &Class::Method)>::doit,                                            \
-        __VA_ARGS__);                                                          \
-  }
+  LLDB_RECORD_(Result(*) Signature, (&Class::Method), __VA_ARGS__)
 
 #define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method)               \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);               \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     lldb_private::repro::invoke<Result (*)()>::method_static< \
-                         (&Class::Method)>::doit);                             \
-  }
+  LLDB_RECORD_(Result (*)(), (&Class::Method), lldb_private::repro::EmptyArg())
 
 #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,                \

 struct invoke<Result (Class::*)(Args...)> {
   template <Result (Class::*m)(Args...)> struct method {
     static Result doit(Class *c, Args... args) { return (c->*m)(args...); }
   };
 };
 
 template <typename Result, typename Class, typename... Args>
 struct invoke<Result (Class::*)(Args...) const> {
-  template <Result (Class::*m)(Args...) const> struct method_const {
+  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 {
+  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 {
+  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...); }
public:
 
   operator bool() { return m_serializer != nullptr && m_registry != nullptr; }
 
 private:
   Serializer *m_serializer;
   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
 /// the API layer, and another API function is called, it doesn't need to be
 /// recorded.
 ///
 /// When a call is recored, its result is always recorded as well, even if the
 /// function returns a void. For functions that return by value, RecordResult
#endif
     serializer.SerializeAll(id);
     serializer.SerializeAll(args...);
 
     // Record result.
     serializer.SerializeAll(0);
     m_result_recorded = true;
   }
 
+  /// Specializations for the no-argument methods. These are passed an empty
+  /// dummy argument so the same variadic macro can be used. These methods
+  /// strip the arguments before forwarding them.
+  template <typename Result>
+  void Record(Serializer &serializer, Registry &registry, Result (*f)(),
+              const EmptyArg &arg) {
+    Record(serializer, registry, f);
+  }
+
   /// Record the result of a function call.
   template <typename Result>
   Result RecordResult(Result &&r, bool update_boundary) {
     // When recording the result from the LLDB_RECORD_RESULT macro, we need to
     // update the boundary so we capture the copy constructor. However, when
     // called to record the this pointer of the (copy) constructor, the
     // boundary should not be toggled, because it is called from the
     // LLDB_RECORD_CONSTRUCTOR macro, which might be followed by other API
     // calls.
     if (update_boundary)
       UpdateBoundary();
     if (m_serializer && ShouldCapture()) {
       assert(!m_result_recorded);
#endif
 
   /// Whether we're currently across the API boundary.
   static bool g_global_boundary;
 };
 
 template <typename Signature> struct char_ptr_redirect;
 template <typename Result, typename Class>
 struct char_ptr_redirect<Result (Class::*)(char *, size_t) const> {
-  template <Result (Class::*m)(char *, size_t) const> struct method_const {
+  template <Result (Class::*m)(char *, size_t) const> struct method {
     static Result doit(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) {
       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 {
+  template <Result (*m)(char *, size_t)> struct method {
     static Result doit(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