FunctionExtras.h Source File (original) (raw)

32#ifndef LLVM_ADT_FUNCTIONEXTRAS_H

33#define LLVM_ADT_FUNCTIONEXTRAS_H

41#include

42#include <type_traits>

44namespace llvm {

60template <typename CallableT, typename ThisT>

62 std::enable_if_t<!std::is_same<remove_cvref_t, ThisT>::value>;

63template <typename CallableT, typename Ret, typename... Params>

65 std::is_void,

66 std::is_same<decltype(std::declval()(std::declval()...)),

67 Ret>,

68 std::is_same<const decltype(std::declval()(

69 std::declval()...)),

70 Ret>,

71 std::is_convertible<decltype(std::declval()(

72 std::declval()...)),

76protected:

90 static_assert(!std::is_reference::value,

91 "references should be handled by template specialization");

93 sizeof(T) <= 2 * sizeof(void *);

95 std::conditional_t<std::is_trivially_copy_constructible::value &&

96 std::is_trivially_move_constructible::value &&

98 T, T &>;

99 };

100

101

102

103

106

107 template

109

110

111

112 using CallPtrT = ReturnT (*)(void *CallableAddr,

114 using MovePtrT = void (*)(void *LHSCallableAddr, void *RHSCallableAddr);

116

117

118

122

123

124

130

131

132

133

136

137

138

140

141

147 static_assert(

149 "Should always use all of the out-of-line storage for inline storage!");

150

151

152

153

154

158

159

160

161

163

165

169

173

177

182

183

184

185

186

187

188

196

203

207

208 template

209 static ReturnT CallImpl(void *CallableAddr,

211 auto &Func = *reinterpret_cast<CalledAsT *>(CallableAddr);

212 return Func(std::forward(Params)...);

213 }

214

215 template

216 static void MoveImpl(void *LHSCallableAddr, void *RHSCallableAddr) noexcept {

217 new (LHSCallableAddr)

218 CallableT(std::move(*reinterpret_cast<CallableT *>(RHSCallableAddr)));

219 }

220

221 template

222 static void DestroyImpl(void *CallableAddr) noexcept {

223 reinterpret_cast<CallableT *>(CallableAddr)->~CallableT();

224 }

225

226

227

228

229

230

231

232

233 template <typename CallableT, typename CalledAs> struct CallbacksHolder {

234 inline static auto Callbacks = []() constexpr {

235

236

237 if constexpr (std::is_trivially_move_constructible_v &&

238 std::is_trivially_destructible_v)

240 else

243 }();

244 };

245

246

247 template struct CalledAs {};

248

249

250

251

252 template <typename CallableT, typename CalledAsT>

254 bool IsInlineStorage = true;

258 IsInlineStorage = false;

259

260

261 auto Size = sizeof(CallableT);

262 auto Alignment = alignof(CallableT);

265 }

266

267

268 new (CallableAddr) CallableT(std::move(Callable));

271 }

272

275 return;

276

277

279

283

284 if (!IsInlineStorage)

287 }

288

290

292

293

294 if ( RHS )

295 return;

296

298

299 StorageUnion.OutOfLineStorage = RHS.StorageUnion.OutOfLineStorage;

301

303 } else {

304

306 RHS.getInlineStorage());

308 }

309

310

311 RHS.CallbackAndInlineFlag = {};

312

313#if !defined(NDEBUG) && !LLVM_ADDRESS_SANITIZER_BUILD

314

315

316

318#endif

319 }

320

322 if (this == &RHS)

323 return *this;

324

325

326

327

330 return *this;

331 }

332

334

335public:

336 explicit operator bool() const {

338 }

339};

340

341}

342

343template <typename R, typename... P>

346

347public:

354

355 template

357 CallableT Callable,

360 : Base(std::forward(Callable),

361 typename Base::template CalledAs{}) {}

362

366};

367

368template <typename R, typename... P>

372

373public:

380

381 template

383 CallableT Callable,

386 : Base(std::forward(Callable),

387 typename Base::template CalledAs<const CallableT>{}) {}

388

392};

393

394}

395

396#endif

This file defines counterparts of C library allocation functions defined in the namespace 'std'.

This file defines the PointerIntPair class.

This file defines the PointerUnion class, which is a discriminated union of pointer types.

This file contains library features backported from future STL versions.

PointerIntPair - This class implements a pair of a pointer and small integer.

A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...

Definition FunctionExtras.h:75

CallPtrT getCallPtr() const

Definition FunctionExtras.h:178

void(*)(void *LHSCallableAddr, void *RHSCallableAddr) MovePtrT

Definition FunctionExtras.h:114

void * getInlineStorage() const

Definition FunctionExtras.h:192

CallPtrT getTrivialCallback() const

Definition FunctionExtras.h:170

PointerIntPair< CallbackPointerUnionT, 1, bool > CallbackAndInlineFlag

Definition FunctionExtras.h:162

UniqueFunctionBase()=default

~UniqueFunctionBase()

Definition FunctionExtras.h:273

void * getOutOfLineStorage() const

Definition FunctionExtras.h:193

void setOutOfLineStorage(void *Ptr, size_t Size, size_t Alignment)

Definition FunctionExtras.h:204

UniqueFunctionBase & operator=(UniqueFunctionBase &&RHS) noexcept

Definition FunctionExtras.h:321

typename AdjustedParamTBase< T >::type AdjustedParamT

Definition FunctionExtras.h:108

NonTrivialCallbacks * getNonTrivialCallbacks() const

Definition FunctionExtras.h:174

PointerUnion< TrivialCallback *, NonTrivialCallbacks * > CallbackPointerUnionT

Definition FunctionExtras.h:134

UniqueFunctionBase(CallableT Callable, CalledAs< CalledAsT >)

Definition FunctionExtras.h:253

static void MoveImpl(void *LHSCallableAddr, void *RHSCallableAddr) noexcept

Definition FunctionExtras.h:216

static void DestroyImpl(void *CallableAddr) noexcept

Definition FunctionExtras.h:222

bool isInlineStorage() const

Definition FunctionExtras.h:164

size_t getOutOfLineStorageSize() const

Definition FunctionExtras.h:197

static ReturnT CallImpl(void *CallableAddr, AdjustedParamT< ParamTs >... Params)

Definition FunctionExtras.h:209

void * getCalleePtr() const

Definition FunctionExtras.h:189

static constexpr size_t InlineStorageAlign

Definition FunctionExtras.h:78

size_t getOutOfLineStorageAlignment() const

Definition FunctionExtras.h:200

union llvm::detail::UniqueFunctionBase::StorageUnionT StorageUnion

void(*)(void *CallableAddr) DestroyPtrT

Definition FunctionExtras.h:115

ReturnT(*)(void *CallableAddr, AdjustedParamT< ParamTs >... Params) CallPtrT

Definition FunctionExtras.h:112

UniqueFunctionBase(UniqueFunctionBase &&RHS) noexcept

Definition FunctionExtras.h:289

bool isTrivialCallback() const

Definition FunctionExtras.h:166

static constexpr size_t InlineStorageSize

Definition FunctionExtras.h:77

unique_function(std::nullptr_t)

Definition FunctionExtras.h:375

unique_function()=default

unique_function(const unique_function &)=delete

unique_function(unique_function &&)=default

unique_function & operator=(const unique_function &)=delete

unique_function & operator=(unique_function &&)=default

R operator()(P... Params) const

Definition FunctionExtras.h:389

unique_function(CallableT Callable, detail::EnableUnlessSameType< CallableT, unique_function > *=nullptr, detail::EnableIfCallable< const CallableT, R, P... > *=nullptr)

Definition FunctionExtras.h:382

unique_function(unique_function &&)=default

unique_function & operator=(const unique_function &)=delete

unique_function(CallableT Callable, detail::EnableUnlessSameType< CallableT, unique_function > *=nullptr, detail::EnableIfCallable< CallableT, R, P... > *=nullptr)

Definition FunctionExtras.h:356

unique_function & operator=(unique_function &&)=default

R operator()(P... Params)

Definition FunctionExtras.h:363

unique_function()=default

unique_function(std::nullptr_t)

Definition FunctionExtras.h:349

unique_function(const unique_function &)=delete

unique_function is a type-erasing functor similar to std::function.

Definition FunctionExtras.h:56

std::enable_if_t<!std::is_same< remove_cvref_t< CallableT >, ThisT >::value > EnableUnlessSameType

Definition FunctionExtras.h:61

const char unit< Period >::value[]

std::enable_if_t< std::disjunction< std::is_void< Ret >, std::is_same< decltype(std::declval< CallableT >()(std::declval< Params >()...)), Ret >, std::is_same< const decltype(std::declval< CallableT >()( std::declval< Params >()...)), Ret >, std::is_convertible< decltype(std::declval< CallableT >()( std::declval< Params >()...)), Ret > >::value > EnableIfCallable

Definition FunctionExtras.h:64

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * allocate_buffer(size_t Size, size_t Alignment)

Allocate a buffer of memory with the given size and alignment.

LLVM_ABI void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment)

Deallocate a buffer of memory with the given size and alignment.

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

Implement std::hash so that hash_code can be used in STL containers.

T & type

Definition FunctionExtras.h:104

T & type

Definition FunctionExtras.h:105

Definition FunctionExtras.h:89

std::conditional_t< std::is_trivially_copy_constructible< T >::value && std::is_trivially_move_constructible< T >::value && IsSizeLessThanThreshold, T, T & > type

Definition FunctionExtras.h:94

static constexpr bool IsSizeLessThanThreshold

Definition FunctionExtras.h:92

Definition FunctionExtras.h:233

static auto Callbacks

Definition FunctionExtras.h:234

Definition FunctionExtras.h:247

A struct we use to aggregate three callbacks when we need full set of operations.

Definition FunctionExtras.h:125

DestroyPtrT DestroyPtr

Definition FunctionExtras.h:128

MovePtrT MovePtr