This is an archive of the discontinued LLVM Phabricator instance.

Differential D121499

[openmp] Generalise function instantiation macro from dlwrap
Needs ReviewPublic

Authored by JonChesterfield on Mar 11 2022, 3:57 PM.

Details

Reviewers
jhuber6
jdoerfert
tianshilei1992
ye-luo
ronlieb
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.

Diff Detail

Revision Contents

PathSize
openmp/
libomptarget/
include/
145 lines
203 lines

Diff 414766

openmp/libomptarget/include/dlwrap.h

Show All 37 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef DLWRAP_H_INCLUDED #ifndef DLWRAP_H_INCLUDED
#define DLWRAP_H_INCLUDED #define DLWRAP_H_INCLUDED
#include <array> #include <array>
#include <cstddef> #include <cstddef>
#include <tuple>
#include <type_traits> #include "make_function.h"
// Where symbol is a function, these expand to some book keeping and an // Where symbol is a function, these expand to some book keeping and an
// implementation of that function // implementation of that function
#define DLWRAP(SYMBOL, ARITY) DLWRAP_IMPL(SYMBOL, ARITY) #define DLWRAP(SYMBOL, ARITY) DLWRAP_IMPL(SYMBOL, ARITY)
#define DLWRAP_INTERNAL(SYMBOL, ARITY) DLWRAP_INTERNAL_IMPL(SYMBOL, ARITY) #define DLWRAP_INTERNAL(SYMBOL, ARITY) DLWRAP_INTERNAL_IMPL(SYMBOL, ARITY)
// For example, given a prototype: // For example, given a prototype:
// int foo(char, double); // int foo(char, double);
// //
// DLWRAP(foo, 2) expands to: // DLWRAP(foo, 2) expands to:
// //
// namespace dlwrap { // namespace dlwrap {
// struct foo_Trait : public dlwrap::trait<decltype(&foo)> { // struct foo_Trait {
// using T = dlwrap::trait<decltype(&foo)>; // using T = trait<decltype(&foo)>;
// static T::FunctionType get() { // static T::FunctionType get() {
// constexpr size_t Index = getIndex(); // constexpr size_t Index = getIndex();
// void *P = *dlwrap::pointer(Index); // void *P = *dlwrap::pointer(Index);
// return reinterpret_cast<T::FunctionType>(P); // return reinterpret_cast<T::FunctionType>(P);
// } // }
// }; // };
// } // }
// int foo(char x0, double x1) { return dlwrap::foo_Trait::get()(x0, x1); } // int foo(char x0, double x1) { return dlwrap::foo_Trait::get()(x0, x1); }
Show All 13 Lines
// DLWRAP_FINALIZE() implements the functions from DLWRAP_INITIALIZE // DLWRAP_FINALIZE() implements the functions from DLWRAP_INITIALIZE
#define DLWRAP_FINALIZE() DLWRAP_FINALIZE_IMPL() #define DLWRAP_FINALIZE() DLWRAP_FINALIZE_IMPL()
// Implementation details follow. // Implementation details follow.
namespace dlwrap { 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 { namespace type {
// Book keeping is by type specialization // Book keeping is by type specialization
template <size_t S> struct count { template <size_t S> struct count {
static constexpr size_t N = count<S - 1>::N; static constexpr size_t N = count<S - 1>::N;
}; };
template <> struct count<0> { static constexpr size_t N = 0; }; template <> struct count<0> { static constexpr size_t N = 0; };
Show All 15 Lines
} // namespace type } // namespace type
template <size_t N, size_t... Is> template <size_t N, size_t... Is>
constexpr std::array<const char *, N> static getSymbolArray( constexpr std::array<const char *, N> static getSymbolArray(
std::index_sequence<Is...>) { std::index_sequence<Is...>) {
return {{dlwrap::type::symbol<Is>::call()...}}; return {{dlwrap::type::symbol<Is>::call()...}};
} }
template <size_t Requested, size_t Required> constexpr void verboseAssert() {
static_assert(Requested == Required, "Arity Error");
}
} // namespace dlwrap } // 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() \ #define DLWRAP_FINALIZE_IMPL() \
static size_t dlwrap::size() { return DLWRAP_ID(); } \ static size_t dlwrap::size() { return DLWRAP_ID(); } \
static const char *dlwrap::symbol(size_t i) { \ static const char *dlwrap::symbol(size_t i) { \
static constexpr const std::array<const char *, DLWRAP_ID()> \ static constexpr const std::array<const char *, DLWRAP_ID()> \
dlwrap_symbols = getSymbolArray<DLWRAP_ID()>( \ dlwrap_symbols = getSymbolArray<DLWRAP_ID()>( \
std::make_index_sequence<DLWRAP_ID()>()); \ std::make_index_sequence<DLWRAP_ID()>()); \
return dlwrap_symbols[i]; \ return dlwrap_symbols[i]; \
} \ } \
static void **dlwrap::pointer(size_t i) { \ static void **dlwrap::pointer(size_t i) { \
static std::array<void *, DLWRAP_ID()> dlwrap_pointers; \ static std::array<void *, DLWRAP_ID()> dlwrap_pointers; \
return &dlwrap_pointers.data()[i]; \ return &dlwrap_pointers.data()[i]; \
} }
#define DLWRAP_COMMON(SYMBOL, ARITY) \ #define DLWRAP_COMMON(SYMBOL, ARITY) \
DLWRAP_INC(); \ DLWRAP_INC(); \
DLWRAP_SYMBOL(SYMBOL, DLWRAP_ID() - 1); \ DLWRAP_SYMBOL(SYMBOL, DLWRAP_ID() - 1); \
namespace dlwrap { \ namespace dlwrap { \
struct SYMBOL##_Trait : public dlwrap::trait<decltype(&SYMBOL)> { \ struct SYMBOL##_Trait { \
using T = dlwrap::trait<decltype(&SYMBOL)>; \ using T = llvm::make_function::trait<decltype(&SYMBOL)>; \
static T::FunctionType get() { \ static T::FunctionType get() { \
verboseAssert<ARITY, trait<decltype(&SYMBOL)>::nargs>(); \ llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
constexpr size_t Index = DLWRAP_ID() - 1; \ constexpr size_t Index = DLWRAP_ID() - 1; \
void *P = *dlwrap::pointer(Index); \ void *P = *dlwrap::pointer(Index); \
return reinterpret_cast<T::FunctionType>(P); \ return reinterpret_cast<T::FunctionType>(P); \
} \ } \
}; \ }; \
} }
#define DLWRAP_IMPL(SYMBOL, ARITY) \ #define DLWRAP_IMPL(SYMBOL, ARITY) \
DLWRAP_COMMON(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) \ #define DLWRAP_INTERNAL_IMPL(SYMBOL, ARITY) \
DLWRAP_COMMON(SYMBOL, ARITY); \ DLWRAP_COMMON(SYMBOL, ARITY); \
static DLWRAP_INSTANTIATE(dlwrap_##SYMBOL, SYMBOL, ARITY) static MAKE_FUNCTION(dlwrap_##SYMBOL, dlwrap::SYMBOL##_Trait::get(), \
decltype(&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); \
}
#endif #endif

openmp/libomptarget/include/make_function.h

  • This file was added.
//------ 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_##ARITY(SYM_DEF, SYM_USE, \
llvm::make_function::trait<WITH_TYPE>, ARITY)
// Boilerplate instantiations
#define MAKE_FUNCTION_0(SYM_DEF, SYM_USE, T, ARITY) \
T::ReturnType SYM_DEF() { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(); \
}
#define MAKE_FUNCTION_1(SYM_DEF, SYM_USE, T, ARITY) \
T::ReturnType SYM_DEF(typename T::template arg<0>::type x0) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0); \
}
#define MAKE_FUNCTION_2(SYM_DEF, SYM_USE, T, ARITY) \
T::ReturnType SYM_DEF(typename T::template arg<0>::type x0, \
typename T::template arg<1>::type x1) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1); \
}
#define MAKE_FUNCTION_3(SYM_DEF, SYM_USE, T, ARITY) \
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) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1, x2); \
}
#define MAKE_FUNCTION_4(SYM_DEF, SYM_USE, T, ARITY) \
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) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1, x2, x3); \
}
#define MAKE_FUNCTION_5(SYM_DEF, SYM_USE, T, ARITY) \
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) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1, x2, x3, x4); \
}
#define MAKE_FUNCTION_6(SYM_DEF, SYM_USE, T, ARITY) \
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) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1, x2, x3, x4, x5); \
}
#define MAKE_FUNCTION_7(SYM_DEF, SYM_USE, T, ARITY) \
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) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1, x2, x3, x4, x5, x6); \
}
#define MAKE_FUNCTION_8(SYM_DEF, SYM_USE, T, ARITY) \
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) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1, x2, x3, x4, x5, x6, x7); \
}
#define MAKE_FUNCTION_9(SYM_DEF, SYM_USE, T, ARITY) \
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) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1, x2, x3, x4, x5, x6, x7, x8); \
}
#define MAKE_FUNCTION_10(SYM_DEF, SYM_USE, T, ARITY) \
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) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); \
}
#define MAKE_FUNCTION_11(SYM_DEF, SYM_USE, T, ARITY) \
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) { \
llvm::make_function::verboseAssert<ARITY, T::nargs>(); \
return SYM_USE(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10); \
}
#endif