1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
#pragma once
#include <yql/essentials/public/udf/udf_value.h>
#if defined(_msan_enabled_) && defined(__linux__)
#define SHOULD_WRAP_ALL_UNBOXED_VALUES_FOR_CODEGEN 1
#else
#define SHOULD_WRAP_ALL_UNBOXED_VALUES_FOR_CODEGEN 0
#endif
namespace NYql {
// Concept that checks if a type is a free function.
template <typename T>
concept FunctionPointer = std::is_pointer_v<T> &&
std::is_function_v<std::remove_pointer_t<T>>;
// Concept that checks if a type is a pointer-to-member function.
template <typename T>
concept MethodPointer = std::is_member_function_pointer_v<T>;
// When compling with msan you have to replace all NUdf::TUnboxedValuePod with __int128_t.
// See YQL-19520#67da4c599dd9e93523567aff for details.
// This helpers help to solve the problem by converting each NUdf::TUnboxedValuePod with __int128_t for passed method.
// For example:
// 1. You have a function
// NUdf::TUnboxedValuePod Func(OtherType a, NUdf::TUnboxedValuePod b) {
// ...
// }
// 2. You call GetMethodPtr<&Func>()
// 3. You recieve pointer to function that do something like this:
// __int128_t FuncWrapper(OtherType a, __int128_t b) {
// NUdf::TUnboxedValuePod realB;
// memcpy(&realB, &b, sizeof(b));
// NUdf::TUnboxedValuePod result = Func(std::move(a), NUdf::TUnboxedValuePod(std::move(b)));
// __int128_t fakeResult;
// memcpy(&fakeResult, &result, sizeof(fakeResult));
// return fakeResult;
// }
#if SHOULD_WRAP_ALL_UNBOXED_VALUES_FOR_CODEGEN
template <FunctionPointer Method>
inline uintptr_t GetMethodPtrNumber(Method method) {
uintptr_t ptr;
std::memcpy(&ptr, &method, sizeof(uintptr_t));
return ptr;
}
template <typename T>
struct TReplaceUnboxedValuePodWithUInt128 {
using TType = T;
};
template <>
struct TReplaceUnboxedValuePodWithUInt128<NUdf::TUnboxedValuePod> {
using TType = __int128_t;
};
template <typename T>
using TReplaceUnboxedValuePodWithUInt128_t =
typename TReplaceUnboxedValuePodWithUInt128<T>::TType;
template <typename TR, typename... TArgs>
struct TFunctionWrapper {
template <FunctionPointer auto function>
static TReplaceUnboxedValuePodWithUInt128_t<TR> Wrapper(TReplaceUnboxedValuePodWithUInt128_t<TArgs>... wargs) {
// Call the original function with converted parameters.
if constexpr (std::is_same_v<TR, void>) {
function(ConvertArg<TArgs>(TReplaceUnboxedValuePodWithUInt128_t<TArgs>(std::move(wargs)))...);
return;
} else {
return ConvertReturn<TR>(function(ConvertArg<TArgs>(TReplaceUnboxedValuePodWithUInt128_t<TArgs>(std::move(wargs)))...));
}
}
private:
template <typename T>
static T ConvertArg(TReplaceUnboxedValuePodWithUInt128_t<T> arg Y_LIFETIME_BOUND) {
if constexpr (std::is_same_v<std::remove_const_t<T>, NUdf::TUnboxedValuePod>) {
NUdf::TUnboxedValuePod tmp;
std::memcpy(&tmp, &arg, sizeof(T));
return tmp;
} else {
return std::forward<TReplaceUnboxedValuePodWithUInt128_t<T>>(arg);
}
}
template <typename T>
static TReplaceUnboxedValuePodWithUInt128_t<T> ConvertReturn(T arg Y_LIFETIME_BOUND) {
if constexpr (std::is_same_v<std::remove_const_t<T>, NUdf::TUnboxedValuePod>) {
__int128_t tmp;
std::memcpy(&tmp, &arg, sizeof(T));
return tmp;
} else {
return std::forward<T>(arg);
}
}
};
template <FunctionPointer auto func, typename TR, typename... TArgs>
inline auto DoGetFreeFunctionPtrInternal() {
return &(TFunctionWrapper<TR, TArgs...>::template Wrapper<func>);
}
template <FunctionPointer auto func>
inline auto DoGetFreeFunctionPtr() {
return []<typename TR, typename... TArgs>(TR (*fptr)(TArgs...)) {
Y_UNUSED(fptr, "For type deducing only.");
return DoGetFreeFunctionPtrInternal<func, TR, TArgs...>();
}(func);
}
template <FunctionPointer auto func>
inline auto GetMethodPtr() {
return GetMethodPtrNumber(DoGetFreeFunctionPtr<func>());
}
template <MethodPointer auto func, typename TR, typename TM, typename... TArgs>
inline TR Adapter(TM obj, TArgs&&... args) {
return (obj->*func)(std::forward<TArgs>(args)...);
}
template <MethodPointer auto func, typename TR, typename TM, typename... TArgs>
inline auto GetMethodPtrImpl() {
return DoGetFreeFunctionPtrInternal<&Adapter<func, TR, TM, TArgs...>, TR, TM, TArgs...>();
}
template <typename T>
struct is_const_member_function_pointer: std::false_type {};
template <typename TR, typename TM, typename... TArgs>
struct is_const_member_function_pointer<TR (TM::*)(TArgs...) const>: std::true_type {};
template <MethodPointer auto func>
inline auto DoGetMethodPtr() {
// Just an template helper to get TArgs..., R, T from func.
if constexpr (is_const_member_function_pointer<decltype(func)>::value) {
return []<typename TR, typename TM, typename... TArgs>(TR (TM::*fptr)(TArgs...) const) {
Y_UNUSED(fptr);
return GetMethodPtrImpl<func, TR, TM*, TArgs...>();
}(func);
} else {
return []<typename TR, typename TM, typename... TArgs>(TR (TM::*fptr)(TArgs...)) {
Y_UNUSED(fptr);
return GetMethodPtrImpl<func, TR, TM*, TArgs...>();
}(func);
}
}
template <MethodPointer auto func>
inline uintptr_t GetMethodPtr() {
return GetMethodPtrNumber(DoGetMethodPtr<func>());
}
#else // SHOULD_WRAP_ALL_UNBOXED_VALUES_FOR_CODEGEN
namespace NInternal {
template <typename Method>
inline uintptr_t GetMethodPtr(Method method) {
uintptr_t ptr;
std::memcpy(&ptr, &method, sizeof(uintptr_t));
return ptr;
}
} // namespace NInternal
template <MethodPointer auto func>
inline uintptr_t GetMethodPtr() {
return NInternal::GetMethodPtr(func);
}
template <FunctionPointer auto func>
inline uintptr_t GetMethodPtr() {
return NInternal::GetMethodPtr(func);
}
#endif // SHOULD_WRAP_ALL_UNBOXED_VALUES_FOR_CODEGEN
} // namespace NYql
|
