[openmp] Generalise function instantiation macro from dlwrap

[JonChesterfield]

Summary

Generalise the instantiation boilerplate for easier reuse elsewhere

Now compiles without <tuple>, i.e. on a GPU for potential use in D121467.
Splitting type into a separate parameter allows use with overloaded functions.

[JonChesterfield]

• apply refactor from D115980, removes typo-prone part

openmp/libomptarget/include/dlwrap.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef DLWRAP_H_INCLUDED
 #define DLWRAP_H_INCLUDED
 
 #include <array>
 #include <cstddef>
-#include <tuple>
-#include <type_traits>
+
+#include "make_function.h"
 
 // Where symbol is a function, these expand to some book keeping and an
 // implementation of that function
 #define DLWRAP(SYMBOL, ARITY) DLWRAP_IMPL(SYMBOL, ARITY)
 #define DLWRAP_INTERNAL(SYMBOL, ARITY) DLWRAP_INTERNAL_IMPL(SYMBOL, ARITY)
 
 // For example, given a prototype:
 // int foo(char, double);
 //
 // DLWRAP(foo, 2) expands to:
 //
 // namespace dlwrap {
-// struct foo_Trait : public dlwrap::trait<decltype(&foo)> {
-//   using T = dlwrap::trait<decltype(&foo)>;
+// struct foo_Trait {
+//   using T = trait<decltype(&foo)>;
 //   static T::FunctionType get() {
 //     constexpr size_t Index = getIndex();
 //     void *P = *dlwrap::pointer(Index);
 //     return reinterpret_cast<T::FunctionType>(P);
 //   }
 // };
 // }
 // int foo(char x0, double x1) { return dlwrap::foo_Trait::get()(x0, x1); }

 
 // DLWRAP_FINALIZE() implements the functions from DLWRAP_INITIALIZE
 #define DLWRAP_FINALIZE() DLWRAP_FINALIZE_IMPL()
 
 // Implementation details follow.
 
 namespace dlwrap {
 
-// Extract return / argument types from address of function symbol
-template <typename F> struct trait;
-template <typename R, typename... Ts> struct trait<R (*)(Ts...)> {
-  constexpr static const size_t nargs = sizeof...(Ts);
-  typedef R ReturnType;
-  template <size_t i> struct arg {
-    typedef typename std::tuple_element<i, std::tuple<Ts...>>::type type;
-  };
-
-  typedef R (*FunctionType)(Ts...);
-};
-
 namespace type {
 // Book keeping is by type specialization
 
 template <size_t S> struct count {
   static constexpr size_t N = count<S - 1>::N;
 };
 
 template <> struct count<0> { static constexpr size_t N = 0; };

 } // namespace type
 
 template <size_t N, size_t... Is>
 constexpr std::array<const char *, N> static getSymbolArray(
     std::index_sequence<Is...>) {
   return {{dlwrap::type::symbol<Is>::call()...}};
 }
 
-template <size_t Requested, size_t Required> constexpr void verboseAssert() {
-  static_assert(Requested == Required, "Arity Error");
-}
-
 } // namespace dlwrap
 
-#define DLWRAP_INSTANTIATE(SYM_DEF, SYM_USE, ARITY)                            \
-  DLWRAP_INSTANTIATE_##ARITY(SYM_DEF, SYM_USE,                                 \
-                             dlwrap::trait<decltype(&SYM_USE)>)
-
 #define DLWRAP_FINALIZE_IMPL()                                                 \
   static size_t dlwrap::size() { return DLWRAP_ID(); }                         \
   static const char *dlwrap::symbol(size_t i) {                                \
     static constexpr const std::array<const char *, DLWRAP_ID()>               \
         dlwrap_symbols = getSymbolArray<DLWRAP_ID()>(                          \
             std::make_index_sequence<DLWRAP_ID()>());                          \
     return dlwrap_symbols[i];                                                  \
   }                                                                            \
   static void **dlwrap::pointer(size_t i) {                                    \
     static std::array<void *, DLWRAP_ID()> dlwrap_pointers;                    \
     return &dlwrap_pointers.data()[i];                                         \
   }
 
 #define DLWRAP_COMMON(SYMBOL, ARITY)                                           \
   DLWRAP_INC();                                                                \
   DLWRAP_SYMBOL(SYMBOL, DLWRAP_ID() - 1);                                      \
   namespace dlwrap {                                                           \
-  struct SYMBOL##_Trait : public dlwrap::trait<decltype(&SYMBOL)> {            \
-    using T = dlwrap::trait<decltype(&SYMBOL)>;                                \
+  struct SYMBOL##_Trait {                                                      \
+    using T = llvm::make_function::trait<decltype(&SYMBOL)>;                   \
     static T::FunctionType get() {                                             \
-      verboseAssert<ARITY, trait<decltype(&SYMBOL)>::nargs>();                 \
+      llvm::make_function::verboseAssert<ARITY, T::nargs>();                   \
       constexpr size_t Index = DLWRAP_ID() - 1;                                \
       void *P = *dlwrap::pointer(Index);                                       \
       return reinterpret_cast<T::FunctionType>(P);                             \
     }                                                                          \
   };                                                                           \
   }
 
 #define DLWRAP_IMPL(SYMBOL, ARITY)                                             \
   DLWRAP_COMMON(SYMBOL, ARITY);                                                \
-  DLWRAP_INSTANTIATE(SYMBOL, SYMBOL, ARITY)
+  MAKE_FUNCTION(SYMBOL, dlwrap::SYMBOL##_Trait::get(), decltype(&SYMBOL), ARITY)
 
 #define DLWRAP_INTERNAL_IMPL(SYMBOL, ARITY)                                    \
   DLWRAP_COMMON(SYMBOL, ARITY);                                                \
-  static DLWRAP_INSTANTIATE(dlwrap_##SYMBOL, SYMBOL, ARITY)
-
-#define DLWRAP_INSTANTIATE_0(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF() { return dlwrap::SYM_USE##_Trait::get()(); }
-#define DLWRAP_INSTANTIATE_1(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0);                                 \
-  }
-#define DLWRAP_INSTANTIATE_2(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1);                             \
-  }
-#define DLWRAP_INSTANTIATE_3(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1,                  \
-                        typename T::template arg<2>::type x2) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1, x2);                         \
-  }
-#define DLWRAP_INSTANTIATE_4(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1,                  \
-                        typename T::template arg<2>::type x2,                  \
-                        typename T::template arg<3>::type x3) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1, x2, x3);                     \
-  }
-#define DLWRAP_INSTANTIATE_5(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1,                  \
-                        typename T::template arg<2>::type x2,                  \
-                        typename T::template arg<3>::type x3,                  \
-                        typename T::template arg<4>::type x4) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1, x2, x3, x4);                 \
-  }
-#define DLWRAP_INSTANTIATE_6(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1,                  \
-                        typename T::template arg<2>::type x2,                  \
-                        typename T::template arg<3>::type x3,                  \
-                        typename T::template arg<4>::type x4,                  \
-                        typename T::template arg<5>::type x5) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1, x2, x3, x4, x5);             \
-  }
-
-#define DLWRAP_INSTANTIATE_7(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1,                  \
-                        typename T::template arg<2>::type x2,                  \
-                        typename T::template arg<3>::type x3,                  \
-                        typename T::template arg<4>::type x4,                  \
-                        typename T::template arg<5>::type x5,                  \
-                        typename T::template arg<6>::type x6) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1, x2, x3, x4, x5, x6);         \
-  }
-
-#define DLWRAP_INSTANTIATE_8(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1,                  \
-                        typename T::template arg<2>::type x2,                  \
-                        typename T::template arg<3>::type x3,                  \
-                        typename T::template arg<4>::type x4,                  \
-                        typename T::template arg<5>::type x5,                  \
-                        typename T::template arg<6>::type x6,                  \
-                        typename T::template arg<7>::type x7) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1, x2, x3, x4, x5, x6, x7);     \
-  }
-#define DLWRAP_INSTANTIATE_9(SYM_DEF, SYM_USE, T)                              \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1,                  \
-                        typename T::template arg<2>::type x2,                  \
-                        typename T::template arg<3>::type x3,                  \
-                        typename T::template arg<4>::type x4,                  \
-                        typename T::template arg<5>::type x5,                  \
-                        typename T::template arg<6>::type x6,                  \
-                        typename T::template arg<7>::type x7,                  \
-                        typename T::template arg<8>::type x8) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1, x2, x3, x4, x5, x6, x7, x8); \
-  }
-#define DLWRAP_INSTANTIATE_10(SYM_DEF, SYM_USE, T)                             \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1,                  \
-                        typename T::template arg<2>::type x2,                  \
-                        typename T::template arg<3>::type x3,                  \
-                        typename T::template arg<4>::type x4,                  \
-                        typename T::template arg<5>::type x5,                  \
-                        typename T::template arg<6>::type x6,                  \
-                        typename T::template arg<7>::type x7,                  \
-                        typename T::template arg<8>::type x8,                  \
-                        typename T::template arg<9>::type x9) {                \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1, x2, x3, x4, x5, x6, x7, x8,  \
-                                          x9);                                 \
-  }
-#define DLWRAP_INSTANTIATE_11(SYM_DEF, SYM_USE, T)                             \
-  T::ReturnType SYM_DEF(typename T::template arg<0>::type x0,                  \
-                        typename T::template arg<1>::type x1,                  \
-                        typename T::template arg<2>::type x2,                  \
-                        typename T::template arg<3>::type x3,                  \
-                        typename T::template arg<4>::type x4,                  \
-                        typename T::template arg<5>::type x5,                  \
-                        typename T::template arg<6>::type x6,                  \
-                        typename T::template arg<7>::type x7,                  \
-                        typename T::template arg<8>::type x8,                  \
-                        typename T::template arg<9>::type x9,                  \
-                        typename T::template arg<10>::type x10) {              \
-    return dlwrap::SYM_USE##_Trait::get()(x0, x1, x2, x3, x4, x5, x6, x7, x8,  \
-                                          x9, x10);                            \
-  }
+  static MAKE_FUNCTION(dlwrap_##SYMBOL, dlwrap::SYMBOL##_Trait::get(),         \
+                       decltype(&SYMBOL), ARITY)
 
 #endif

openmp/libomptarget/include/make_function.h

+//------ make_function.h - Helper for creating function wrappers -- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines a macro, MAKE_FUNCTION, that factors out boilerplate from wrappers
+//
+// Example, implement ldexp as a call to ldexp_gpu
+// double ldexp(double, int);
+// double ldexp_gpu(double, int);
+// MAKE_FUNCTION(ldexp, ldexp_gpu, decltype(&ldexp), 2)
+//
+// expands to, with some type indirection noise elided here,
+//
+// double ldexp(double x0, int x1)
+// {
+//   static_assert(2 == ldexp::nargs); // can check arity but not infer it
+//   return ldexp_gpu(x0, x1);
+// }
+//
+// Essentially instantiates a forwarding template as externally named functions
+// template <typename R, typename... Ts>
+// R func(Ts... ts) {
+//   return other(ts...);
+// }
+//
+// Does not require C or C++ headers to be available, e.g. on freestanding gpu
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _OMPTARGET_MAKE_FUNCTION_H_INCLUDED
+#define _OMPTARGET_MAKE_FUNCTION_H_INCLUDED
+
+// Define a function symbol as using a call to another function symbol
+// where argument and return types are inferred from WITH_TYPE to allow
+// disambiguation with overloaded functions or passing decltype(&SYMBOL)
+
+// The primary purpose is to factor out the argument type declaration
+// repetition from function wrappers.
+#define MAKE_FUNCTION(DEFINE_SYMBOL, USING_SYMBOL, WITH_TYPE, ARITY)           \
+  MAKE_FUNCTION_IMPL(DEFINE_SYMBOL, USING_SYMBOL, WITH_TYPE, ARITY)
+
+#if !__has_builtin(__type_pack_element)
+// Uses either this builtin or an implementation of std::tuple_element
+#include <tuple>
+#endif
+
+namespace llvm {
+namespace make_function {
+
+template <unsigned long Requested, unsigned long Required>
+constexpr bool verboseAssert() {
+  static_assert(Requested == Required, "Arity Error");
+  return Requested == Required;
+}
+
+template <typename F> struct trait;
+template <typename R, typename... Ts> struct trait<R (*)(Ts...)> {
+  constexpr static const auto nargs = sizeof...(Ts);
+  typedef R ReturnType;
+  template </*size_t*/ decltype(sizeof(int)) I> struct arg {
+    static_assert(I < nargs, "Argument index out of range");
+#if __has_builtin(__type_pack_element)
+    using type = __type_pack_element<I, Ts...>;
+#else
+    typedef typename std::tuple_element<I, std::tuple<Ts...>>::type type;
+#endif
+  };
+  typedef R (*FunctionType)(Ts...);
+};
+
+} // namespace make_function
+} // namespace llvm
+
+// Convert type to trait and dispatch to matching arity
+#define MAKE_FUNCTION_IMPL(SYM_DEF, SYM_USE, WITH_TYPE, ARITY)                 \
+  MAKE_FUNCTION_IMPL_WITH_TRAIT(SYM_DEF, SYM_USE,                              \
+                                llvm::make_function::trait<WITH_TYPE>, ARITY)
+
+#define MAKE_FUNCTION_IMPL_WITH_TRAIT(SYM_DEF, SYM_USE, T, ARITY)              \
+  T::ReturnType SYM_DEF(MAKE_FUNCTION_PARAMETERS_DISPATCH(ARITY, T)) {         \
+    llvm::make_function::verboseAssert<ARITY, T::nargs>();                     \
+    return SYM_USE(MAKE_FUNCTION_ARGUMENTS_DISPATCH(ARITY));                   \
+  }
+
+// Instantiate function parameters or argument based on traits object and arity.
+
+// Emit sequence of x0, x1, ..., x(ARITY-1)
+#define MAKE_FUNCTION_ARGUMENTS_DISPATCH(ARITY)                                \
+  MAKE_FUNCTION_ARGUMENTS_##ARITY()
+// Emit sequence of type0 x0, type1 x1, ..., type(ARITY-1) x(ARITY-1)
+#define MAKE_FUNCTION_PARAMETERS_DISPATCH(ARITY, T)                            \
+  MAKE_FUNCTION_PARAMETERS_##ARITY(T)
+
+// Base cases
+#define MAKE_FUNCTION_PARAMETERS_0(T) void
+#define MAKE_FUNCTION_ARGUMENTS_0()
+
+#define MAKE_FUNCTION_PARAMETERS_1(T) typename T::template arg<0>::type x0
+#define MAKE_FUNCTION_ARGUMENTS_1() x0
+
+// The sequential instantiations below were generated to avoid typos:
+#if 0
+// clang-format off
+echo 'for i in range(2, 12):  print(f"""
+#define MAKE_FUNCTION_ARGUMENTS_{i}() MAKE_FUNCTION_ARGUMENTS_{i-1}(), x{i-1}
+#define MAKE_FUNCTION_PARAMETERS_{i}(T)                                     \\
+  MAKE_FUNCTION_PARAMETERS_{i-1}(T), typename T::template arg<{i-1}>::type x{i-1}""")' | python3
+// clang-format on
+#endif
+
+#define MAKE_FUNCTION_ARGUMENTS_2() MAKE_FUNCTION_ARGUMENTS_1(), x1
+#define MAKE_FUNCTION_PARAMETERS_2(T)                                          \
+  MAKE_FUNCTION_PARAMETERS_1(T), typename T::template arg<1>::type x1
+
+#define MAKE_FUNCTION_ARGUMENTS_3() MAKE_FUNCTION_ARGUMENTS_2(), x2
+#define MAKE_FUNCTION_PARAMETERS_3(T)                                          \
+  MAKE_FUNCTION_PARAMETERS_2(T), typename T::template arg<2>::type x2
+
+#define MAKE_FUNCTION_ARGUMENTS_4() MAKE_FUNCTION_ARGUMENTS_3(), x3
+#define MAKE_FUNCTION_PARAMETERS_4(T)                                          \
+  MAKE_FUNCTION_PARAMETERS_3(T), typename T::template arg<3>::type x3
+
+#define MAKE_FUNCTION_ARGUMENTS_5() MAKE_FUNCTION_ARGUMENTS_4(), x4
+#define MAKE_FUNCTION_PARAMETERS_5(T)                                          \
+  MAKE_FUNCTION_PARAMETERS_4(T), typename T::template arg<4>::type x4
+
+#define MAKE_FUNCTION_ARGUMENTS_6() MAKE_FUNCTION_ARGUMENTS_5(), x5
+#define MAKE_FUNCTION_PARAMETERS_6(T)                                          \
+  MAKE_FUNCTION_PARAMETERS_5(T), typename T::template arg<5>::type x5
+
+#define MAKE_FUNCTION_ARGUMENTS_7() MAKE_FUNCTION_ARGUMENTS_6(), x6
+#define MAKE_FUNCTION_PARAMETERS_7(T)                                          \
+  MAKE_FUNCTION_PARAMETERS_6(T), typename T::template arg<6>::type x6
+
+#define MAKE_FUNCTION_ARGUMENTS_8() MAKE_FUNCTION_ARGUMENTS_7(), x7
+#define MAKE_FUNCTION_PARAMETERS_8(T)                                          \
+  MAKE_FUNCTION_PARAMETERS_7(T), typename T::template arg<7>::type x7
+
+#define MAKE_FUNCTION_ARGUMENTS_9() MAKE_FUNCTION_ARGUMENTS_8(), x8
+#define MAKE_FUNCTION_PARAMETERS_9(T)                                          \
+  MAKE_FUNCTION_PARAMETERS_8(T), typename T::template arg<8>::type x8
+
+#define MAKE_FUNCTION_ARGUMENTS_10() MAKE_FUNCTION_ARGUMENTS_9(), x9
+#define MAKE_FUNCTION_PARAMETERS_10(T)                                         \
+  MAKE_FUNCTION_PARAMETERS_9(T), typename T::template arg<9>::type x9
+
+#define MAKE_FUNCTION_ARGUMENTS_11() MAKE_FUNCTION_ARGUMENTS_10(), x10
+#define MAKE_FUNCTION_PARAMETERS_11(T)                                         \
+  MAKE_FUNCTION_PARAMETERS_10(T), typename T::template arg<10>::type x10
+
+#endif