diff --git a/openmp/libomptarget/include/dlwrap.h b/openmp/libomptarget/include/dlwrap.h --- a/openmp/libomptarget/include/dlwrap.h +++ b/openmp/libomptarget/include/dlwrap.h @@ -43,8 +43,8 @@ #include #include -#include -#include + +#include "make_function.h" // Where symbol is a function, these expand to some book keeping and an // implementation of that function @@ -57,8 +57,8 @@ // DLWRAP(foo, 2) expands to: // // namespace dlwrap { -// struct foo_Trait : public dlwrap::trait { -// using T = dlwrap::trait; +// struct foo_Trait { +// using T = trait; // static T::FunctionType get() { // constexpr size_t Index = getIndex(); // void *P = *dlwrap::pointer(Index); @@ -88,18 +88,6 @@ namespace dlwrap { -// Extract return / argument types from address of function symbol -template struct trait; -template struct trait { - constexpr static const size_t nargs = sizeof...(Ts); - typedef R ReturnType; - template struct arg { - typedef typename std::tuple_element>::type type; - }; - - typedef R (*FunctionType)(Ts...); -}; - namespace type { // Book keeping is by type specialization @@ -131,16 +119,8 @@ return {{dlwrap::type::symbol::call()...}}; } -template 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) - #define DLWRAP_FINALIZE_IMPL() \ static size_t dlwrap::size() { return DLWRAP_ID(); } \ static const char *dlwrap::symbol(size_t i) { \ @@ -158,10 +138,10 @@ DLWRAP_INC(); \ DLWRAP_SYMBOL(SYMBOL, DLWRAP_ID() - 1); \ namespace dlwrap { \ - struct SYMBOL##_Trait : public dlwrap::trait { \ - using T = dlwrap::trait; \ + struct SYMBOL##_Trait { \ + using T = llvm::make_function::trait; \ static T::FunctionType get() { \ - verboseAssert::nargs>(); \ + llvm::make_function::verboseAssert(); \ constexpr size_t Index = DLWRAP_ID() - 1; \ void *P = *dlwrap::pointer(Index); \ return reinterpret_cast(P); \ @@ -171,116 +151,11 @@ #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 diff --git a/openmp/libomptarget/include/make_function.h b/openmp/libomptarget/include/make_function.h new file mode 100644 --- /dev/null +++ b/openmp/libomptarget/include/make_function.h @@ -0,0 +1,155 @@ +//------ 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 +// 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 +#endif + +namespace llvm { +namespace make_function { + +template +constexpr bool verboseAssert() { + static_assert(Requested == Required, "Arity Error"); + return Requested == Required; +} + +template struct trait; +template struct trait { + constexpr static const auto nargs = sizeof...(Ts); + typedef R ReturnType; + template struct arg { + static_assert(I < nargs, "Argument index out of range"); +#if __has_builtin(__type_pack_element) + using type = __type_pack_element; +#else + typedef typename std::tuple_element>::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, 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(); \ + 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