TargetLibraryInfo.h Source File (original) (raw)

9#ifndef LLVM_ANALYSIS_TARGETLIBRARYINFO_H

10#define LLVM_ANALYSIS_TARGETLIBRARYINFO_H

22#include

23#include

25namespace llvm {

27template class ArrayRef;

49 bool Masked;

51 std::optionalCallingConv::ID CC;

53public:

57 std::optionalCallingConv::ID Conv)

58 : ScalarFnName(ScalarFnName), VectorFnName(VectorFnName),

59 VectorizationFactor(VectorizationFactor), Masked(Masked),

60 VABIPrefix(VABIPrefix), CC(Conv) {}

65 bool isMasked() const { return Masked; }

67 std::optionalCallingConv::ID getCallingConv() const { return CC; }

72};

74#define GET_TARGET_LIBRARY_INFO_ENUM

75#include "llvm/Analysis/TargetLibraryInfo.inc"

86 unsigned char AvailableArray[(NumLibFuncs+3)/4];

88#define GET_TARGET_LIBRARY_INFO_IMPL_DECL

89#include "llvm/Analysis/TargetLibraryInfo.inc"

90 bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param, ShouldSignExtI32Return;

91 unsigned SizeOfInt;

94 StandardName = 3,

95 CustomName = 1,

97 };

98 void setState(LibFunc F, AvailabilityState State) {

99 AvailableArray[F/4] &= ~(3 << 2*(F&3));

100 AvailableArray[F/4] |= State << 2*(F&3);

101 }

102 AvailabilityState getState(LibFunc F) const {

103 return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);

104 }

105

106

107 std::vector VectorDescs;

108

109

110 std::vector ScalarDescs;

111

112

113

114 LLVM_ABI bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F,

115 const Module &M) const;

116

117public:

121

122

127

128

129

130

131

133

134

135

136

137

138

139

140

142

143

144

146

147

149 setState(F, Unavailable);

150 }

151

152

154 setState(F, StandardName);

155 }

156

157

158

160 if (StringRef(StandardNamesStrTable.getCString(StandardNamesOffsets[F]),

161 StandardNamesSizeTable[F]) != Name) {

162 setState(F, CustomName);

163 CustomNames[F] = std::string(Name);

164 assert(CustomNames.contains(F));

165 } else {

166 setState(F, StandardName);

167 }

168 }

169

170

171

172

174

175

176

178

179

180

184

185

186

191

192

193

195

196

197

200

201

202

203

206

207

208

209

211 ShouldExtI32Param = Val;

212 }

213

214

215

216

218 ShouldExtI32Return = Val;

219 }

220

221

222

224 ShouldSignExtI32Param = Val;

225 }

226

227

228

230 ShouldSignExtI32Return = Val;

231 }

232

233

234

236

237

239

240

242 return SizeOfInt;

243 }

244

245

247 SizeOfInt = Bits;

248 }

249

250

251

254

255

256

259};

260

261

262

263

264

265

269

270

272

273

274

275 std::bitset OverrideAsUnavailable;

276

277public:

279

281 std::optional<const Function *> F = std::nullopt)

282 : Impl(&Impl) {

283 if ()

284 return;

285 if ((*F)->hasFnAttribute("no-builtins"))

287 else {

288

289 LibFunc LF;

290 AttributeSet FnAttrs = (*F)->getAttributes().getFnAttrs();

291 for (const Attribute &Attr : FnAttrs) {

292 if (!Attr.isStringAttribute())

293 continue;

294 auto AttrStr = Attr.getKindAsString();

295 if (!AttrStr.consume_front("no-builtin-"))

296 continue;

299 }

300 }

301 }

302

303

308

309

310

311

312

314 bool AllowCallerSuperset) const {

315 if (!AllowCallerSuperset)

316 return OverrideAsUnavailable == CalleeTLI.OverrideAsUnavailable;

317

318

319 return (CalleeTLI.OverrideAsUnavailable & ~OverrideAsUnavailable).none();

320 }

321

322

323

325 const Module &M) const {

326 return Impl->isValidProtoForLibFunc(FTy, F, M);

327 }

328

329

330

331

332

334 return Impl->getLibFunc(funcName, F);

335 }

336

338 return Impl->getLibFunc(FDecl, F);

339 }

340

341

342

347

348

349

351 return Impl->getLibFunc(Opcode, Ty, F);

352 }

353

354

355

356

358

359

361 assert(F < OverrideAsUnavailable.size() && "out-of-bounds LibFunc");

362 OverrideAsUnavailable.set(F);

363 }

364

365 TargetLibraryInfoImpl::AvailabilityState getState(LibFunc F) const {

366 assert(F < OverrideAsUnavailable.size() && "out-of-bounds LibFunc");

367 if (OverrideAsUnavailable[F])

368 return TargetLibraryInfoImpl::Unavailable;

369 return Impl->getState(F);

370 }

371

372

373 bool has(LibFunc F) const {

374 return getState(F) != TargetLibraryInfoImpl::Unavailable;

375 }

377 return Impl->isFunctionVectorizable(F, VF);

378 }

380 return Impl->isFunctionVectorizable(F);

381 }

383 bool Masked = false) const {

384 return Impl->getVectorizedFunction(F, VF, Masked);

385 }

388 return Impl->getVectorMappingInfo(F, VF, Masked);

389 }

390

391

392

394 if (getState(F) == TargetLibraryInfoImpl::Unavailable)

395 return false;

396 switch (F) {

397 default: break;

398

399 case LibFunc_acos: case LibFunc_acosf: case LibFunc_acosl:

400 case LibFunc_asin: case LibFunc_asinf: case LibFunc_asinl:

401 case LibFunc_atan2: case LibFunc_atan2f: case LibFunc_atan2l:

402 case LibFunc_atan: case LibFunc_atanf: case LibFunc_atanl:

403 case LibFunc_ceil: case LibFunc_ceilf: case LibFunc_ceill:

404 case LibFunc_copysign: case LibFunc_copysignf: case LibFunc_copysignl:

405 case LibFunc_cos: case LibFunc_cosf: case LibFunc_cosl:

406 case LibFunc_cosh: case LibFunc_coshf: case LibFunc_coshl:

407 case LibFunc_exp2: case LibFunc_exp2f: case LibFunc_exp2l:

408 case LibFunc_exp10: case LibFunc_exp10f: case LibFunc_exp10l:

409 case LibFunc_fabs: case LibFunc_fabsf: case LibFunc_fabsl:

410 case LibFunc_floor: case LibFunc_floorf: case LibFunc_floorl:

411 case LibFunc_fmax: case LibFunc_fmaxf: case LibFunc_fmaxl:

412 case LibFunc_fmin: case LibFunc_fminf: case LibFunc_fminl:

413 case LibFunc_ldexp: case LibFunc_ldexpf: case LibFunc_ldexpl:

414 case LibFunc_log2: case LibFunc_log2f: case LibFunc_log2l:

415 case LibFunc_memcmp: case LibFunc_bcmp: case LibFunc_strcmp:

416 case LibFunc_memcpy: case LibFunc_memset: case LibFunc_memmove:

417 case LibFunc_nearbyint: case LibFunc_nearbyintf: case LibFunc_nearbyintl:

418 case LibFunc_rint: case LibFunc_rintf: case LibFunc_rintl:

419 case LibFunc_round: case LibFunc_roundf: case LibFunc_roundl:

420 case LibFunc_sin: case LibFunc_sinf: case LibFunc_sinl:

421 case LibFunc_sinh: case LibFunc_sinhf: case LibFunc_sinhl:

422 case LibFunc_sqrt: case LibFunc_sqrtf: case LibFunc_sqrtl:

423 case LibFunc_sqrt_finite: case LibFunc_sqrtf_finite:

424 case LibFunc_sqrtl_finite:

425 case LibFunc_strcpy: case LibFunc_stpcpy: case LibFunc_strlen:

426 case LibFunc_strnlen: case LibFunc_memchr: case LibFunc_mempcpy:

427 case LibFunc_tan: case LibFunc_tanf: case LibFunc_tanl:

428 case LibFunc_tanh: case LibFunc_tanhf: case LibFunc_tanhl:

429 case LibFunc_trunc: case LibFunc_truncf: case LibFunc_truncl:

430

431 return true;

432 }

433 return false;

434 }

435

436

437

439 return StringRef(TargetLibraryInfoImpl::StandardNamesStrTable.getCString(

440 TargetLibraryInfoImpl::StandardNamesOffsets[F]),

441 TargetLibraryInfoImpl::StandardNamesSizeTable[F]);

442 }

443

446 if (State == TargetLibraryInfoImpl::Unavailable)

448 if (State == TargetLibraryInfoImpl::StandardName)

450 Impl->StandardNamesStrTable.getCString(Impl->StandardNamesOffsets[F]),

451 Impl->StandardNamesSizeTable[F]);

452 assert(State == TargetLibraryInfoImpl::CustomName);

453 return Impl->CustomNames.find(F)->second;

454 }

455

457 bool &ShouldExtI32Return,

458 bool &ShouldSignExtI32Param,

459 bool &ShouldSignExtI32Return,

461 ShouldExtI32Param = ShouldExtI32Return = false;

462 ShouldSignExtI32Param = ShouldSignExtI32Return = false;

463

464

465

468 ShouldExtI32Param = true;

469 ShouldExtI32Return = true;

470 }

471

472

473 if (T.isLoongArch() || T.isMIPS() || T.isRISCV64()) {

474 ShouldSignExtI32Param = true;

475 }

476

477

478 if (T.isLoongArch() || T.isRISCV64()) {

479 ShouldSignExtI32Return = true;

480 }

481 }

482

483

484

485

486private:

487 static Attribute::AttrKind getExtAttrForI32Param(bool ShouldExtI32Param_,

488 bool ShouldSignExtI32Param_,

489 bool Signed = true) {

490 if (ShouldExtI32Param_)

491 return Signed ? Attribute::SExt : Attribute::ZExt;

492 if (ShouldSignExtI32Param_)

493 return Attribute::SExt;

495 }

496

497public:

499 bool Signed = true) {

500 bool ShouldExtI32Param, ShouldExtI32Return;

501 bool ShouldSignExtI32Param, ShouldSignExtI32Return;

503 ShouldSignExtI32Param, ShouldSignExtI32Return, T);

504 return getExtAttrForI32Param(ShouldExtI32Param, ShouldSignExtI32Param,

506 }

507

509 return getExtAttrForI32Param(Impl->ShouldExtI32Param,

510 Impl->ShouldSignExtI32Param, Signed);

511 }

512

513

514

515

516private:

517 static Attribute::AttrKind getExtAttrForI32Return(bool ShouldExtI32Return_,

518 bool ShouldSignExtI32Return_,

520 if (ShouldExtI32Return_)

521 return Signed ? Attribute::SExt : Attribute::ZExt;

522 if (ShouldSignExtI32Return_)

523 return Attribute::SExt;

525 }

526

527public:

529 bool Signed = true) {

530 bool ShouldExtI32Param, ShouldExtI32Return;

531 bool ShouldSignExtI32Param, ShouldSignExtI32Return;

533 ShouldSignExtI32Param, ShouldSignExtI32Return, T);

534 return getExtAttrForI32Return(ShouldExtI32Return, ShouldSignExtI32Return,

536 }

537

539 return getExtAttrForI32Return(Impl->ShouldExtI32Return,

540 Impl->ShouldSignExtI32Return, Signed);

541 }

542

543

544

545

547 bool Signed, bool Ret = false,

548 AttributeList AL = AttributeList()) const {

549 if (auto AK = getExtAttrForI32Param(Signed))

550 for (auto ArgNo : ArgNos)

551 AL = AL.addParamAttribute(*C, ArgNo, AK);

552 if (Ret)

553 if (auto AK = getExtAttrForI32Return(Signed))

554 AL = AL.addRetAttribute(*C, AK);

555 return AL;

556 }

557

558

560 return Impl->getWCharSize(M);

561 }

562

563

565

566

570

571

575

576

578 return Impl->getIntSize();

579 }

580

581

582

583

584

586 ModuleAnalysisManager::Invalidator &) {

587 return false;

588 }

590 FunctionAnalysisManager::Invalidator &) {

591 return false;

592 }

593

594

597 Impl->getWidestVF(ScalarF, FixedVF, ScalableVF);

598 }

599

600

604};

605

606

607

608

609

611public:

613

614

615

616

617

619

620

621

622

624 : BaselineInfoImpl(std::move(BaselineInfoImpl)) {}

625

627

628private:

631

632 std::optional BaselineInfoImpl;

633};

634

637 std::optional TLI;

638

639 virtual void anchor();

640

641public:

643

644

645

647

650

651

652

654

657 TLI = TLA.run(F, DummyFAM);

658 return *TLI;

659 }

660};

661

662}

663

664#endif

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

This file contains the declarations for the subclasses of Constant, which represent the different fla...

This file defines the DenseMap class.

@ Unavailable

We know the block is not fully available. This is a fixpoint.

Module.h This file contains the declarations for the Module class.

This header defines various interfaces for pass management in LLVM.

Machine Check Debug Module

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

This class holds the attributes for a particular argument, parameter, function, or return value.

Functions, function parameters, and return types can have attributes to indicate how they should be t...

AttrKind

This enumeration lists the attributes that can be associated with parameters, function results,...

@ None

No attributes have been set.

Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...

bool isNoBuiltin() const

Return true if the call should not be treated as a call to a builtin.

Function * getCalledFunction() const

Returns the function called, or null if this is an indirect function invocation or the function signa...

This is the shared class of boolean and integer constants.

Class to represent function types.

Class to represent integer types.

static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)

This static method is the primary way of constructing an IntegerType.

This is an important class for using LLVM in a threaded context.

A Module instance is used to store all the information related to an LLVM module.

A set of analyses that are preserved following a run of a transformation pass.

StringRef - Represent a constant reference to a string, i.e.

constexpr bool empty() const

empty - Check if the string is empty.

Analysis pass providing the TargetLibraryInfo.

Definition TargetLibraryInfo.h:610

TargetLibraryAnalysis()=default

Default construct the library analysis.

TargetLibraryInfo Result

Definition TargetLibraryInfo.h:612

LLVM_ABI TargetLibraryInfo run(const Function &F, FunctionAnalysisManager &)

TargetLibraryAnalysis(TargetLibraryInfoImpl BaselineInfoImpl)

Construct a library analysis with baseline Module-level info.

Definition TargetLibraryInfo.h:623

Implementation of the target library information.

Definition TargetLibraryInfo.h:83

void setShouldExtI32Param(bool Val)

Set to true iff i32 parameters to library functions should have signext or zeroext attributes if they...

Definition TargetLibraryInfo.h:210

void setShouldExtI32Return(bool Val)

Set to true iff i32 results from library functions should have signext or zeroext attributes if they ...

Definition TargetLibraryInfo.h:217

LLVM_ABI unsigned getWCharSize(const Module &M) const

Returns the size of the wchar_t type in bytes or 0 if the size is unknown.

LLVM_ABI bool getLibFunc(StringRef funcName, LibFunc &F) const

Searches for a particular function name.

friend class TargetLibraryInfo

Definition TargetLibraryInfo.h:84

LLVM_ABI void getWidestVF(StringRef ScalarF, ElementCount &FixedVF, ElementCount &Scalable) const

Returns the largest vectorization factor used in the list of vector functions.

bool isFunctionVectorizable(StringRef F, const ElementCount &VF) const

Return true if the function F has a vector equivalent with vectorization factor VF.

Definition TargetLibraryInfo.h:187

void setShouldSignExtI32Param(bool Val)

Set to true iff i32 parameters to library functions should have signext attribute if they correspond ...

Definition TargetLibraryInfo.h:223

void setAvailableWithName(LibFunc F, StringRef Name)

Forces a function to be marked as available and provide an alternate name that must be used.

Definition TargetLibraryInfo.h:159

TargetLibraryInfoImpl()=delete

unsigned getIntSize() const

Get size of a C-level int or unsigned int, in bits.

Definition TargetLibraryInfo.h:241

LLVM_ABI void addVectorizableFunctionsFromVecLib(enum VectorLibrary VecLib, const llvm::Triple &TargetTriple)

Calls addVectorizableFunctions with a known preset of functions for the given vector library.

void setIntSize(unsigned Bits)

Initialize the C-level size of an integer.

Definition TargetLibraryInfo.h:246

LLVM_ABI unsigned getSizeTSize(const Module &M) const

Returns the size of the size_t type in bits.

LLVM_ABI void addVectorizableFunctions(ArrayRef< VecDesc > Fns)

Add a set of scalar -> vector mappings, queryable via getVectorizedFunction and getScalarizedFunction...

LLVM_ABI const VecDesc * getVectorMappingInfo(StringRef F, const ElementCount &VF, bool Masked) const

Return a pointer to a VecDesc object holding all info for scalar to vector mappings in TLI for the eq...

static LLVM_ABI bool isCallingConvCCompatible(CallBase *CI)

Returns true if call site / callee has cdecl-compatible calling conventions.

void setShouldSignExtI32Return(bool Val)

Set to true iff i32 results from library functions should have signext attribute if they correspond t...

Definition TargetLibraryInfo.h:229

LLVM_ABI TargetLibraryInfoImpl & operator=(const TargetLibraryInfoImpl &TLI)

LLVM_ABI void disableAllFunctions()

Disables all builtins.

void setUnavailable(LibFunc F)

Forces a function to be marked as unavailable.

Definition TargetLibraryInfo.h:148

LLVM_ABI StringRef getVectorizedFunction(StringRef F, const ElementCount &VF, bool Masked) const

Return the name of the equivalent of F, vectorized with factor VF.

void setAvailable(LibFunc F)

Forces a function to be marked as available.

Definition TargetLibraryInfo.h:153

TargetLibraryInfoWrapperPass()

The default constructor should not be used and is only for pass manager initialization purposes.

static char ID

Definition TargetLibraryInfo.h:642

TargetLibraryInfo & getTLI(const Function &F)

Definition TargetLibraryInfo.h:655

Provides information about what library functions are available for the current target.

Definition TargetLibraryInfo.h:266

AttributeList getAttrList(LLVMContext *C, ArrayRef< unsigned > ArgNos, bool Signed, bool Ret=false, AttributeList AL=AttributeList()) const

Definition TargetLibraryInfo.h:546

static Attribute::AttrKind getExtAttrForI32Param(const Triple &T, bool Signed=true)

Definition TargetLibraryInfo.h:498

bool areInlineCompatible(const TargetLibraryInfo &CalleeTLI, bool AllowCallerSuperset) const

Determine whether a callee with the given TLI can be inlined into caller with this TLI,...

Definition TargetLibraryInfo.h:313

bool getLibFunc(const CallBase &CB, LibFunc &F) const

If a callbase does not have the 'nobuiltin' attribute, return if the called function is a known libra...

Definition TargetLibraryInfo.h:343

bool invalidate(Module &, const PreservedAnalyses &, ModuleAnalysisManager::Invalidator &)

Handle invalidation from the pass manager.

Definition TargetLibraryInfo.h:585

bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F, const Module &M) const

Return true if the function type FTy is valid for the library function F, regardless of whether the f...

Definition TargetLibraryInfo.h:324

TargetLibraryInfo()=delete

unsigned getWCharSize(const Module &M) const

Returns the size of the wchar_t type in bytes or 0 if the size is unknown.

Definition TargetLibraryInfo.h:559

ConstantInt * getAsSizeT(uint64_t V, const Module &M) const

Returns a constant materialized as a size_t type.

Definition TargetLibraryInfo.h:572

bool hasOptimizedCodeGen(LibFunc F) const

Tests if the function is both available and a candidate for optimized code generation.

Definition TargetLibraryInfo.h:393

Attribute::AttrKind getExtAttrForI32Return(bool Signed=true) const

Definition TargetLibraryInfo.h:538

bool invalidate(Function &, const PreservedAnalyses &, FunctionAnalysisManager::Invalidator &)

Definition TargetLibraryInfo.h:589

bool isKnownVectorFunctionInLibrary(StringRef F) const

Check if the function "F" is listed in a library known to LLVM.

Definition TargetLibraryInfo.h:601

static StringRef getStandardName(LibFunc F)

Return the canonical name for a LibFunc.

Definition TargetLibraryInfo.h:438

bool isFunctionVectorizable(StringRef F) const

Definition TargetLibraryInfo.h:379

bool has(LibFunc F) const

Tests whether a library function is available.

Definition TargetLibraryInfo.h:373

void disableAllFunctions()

Disables all builtins.

Definition TargetLibraryInfo.h:357

unsigned getSizeTSize(const Module &M) const

Returns the size of the size_t type in bits.

Definition TargetLibraryInfo.h:564

TargetLibraryInfoImpl::AvailabilityState getState(LibFunc F) const

Definition TargetLibraryInfo.h:365

TargetLibraryInfo & operator=(const TargetLibraryInfo &TLI)=default

TargetLibraryInfo(const TargetLibraryInfo &TLI)=default

void getWidestVF(StringRef ScalarF, ElementCount &FixedVF, ElementCount &ScalableVF) const

Returns the largest vectorization factor used in the list of vector functions.

Definition TargetLibraryInfo.h:595

TargetLibraryInfo(const TargetLibraryInfoImpl &Impl, std::optional< const Function * > F=std::nullopt)

Definition TargetLibraryInfo.h:280

static Attribute::AttrKind getExtAttrForI32Return(const Triple &T, bool Signed=true)

Definition TargetLibraryInfo.h:528

bool getLibFunc(const Function &FDecl, LibFunc &F) const

Definition TargetLibraryInfo.h:337

bool getLibFunc(StringRef funcName, LibFunc &F) const

Searches for a particular function name.

Definition TargetLibraryInfo.h:333

IntegerType * getSizeTType(const Module &M) const

Returns an IntegerType corresponding to size_t.

Definition TargetLibraryInfo.h:567

static void initExtensionsForTriple(bool &ShouldExtI32Param, bool &ShouldExtI32Return, bool &ShouldSignExtI32Param, bool &ShouldSignExtI32Return, const Triple &T)

Definition TargetLibraryInfo.h:456

bool getLibFunc(unsigned int Opcode, Type *Ty, LibFunc &F) const

Searches for a function name using an Instruction Opcode.

Definition TargetLibraryInfo.h:350

StringRef getVectorizedFunction(StringRef F, const ElementCount &VF, bool Masked=false) const

Definition TargetLibraryInfo.h:382

StringRef getName(LibFunc F) const

Definition TargetLibraryInfo.h:444

const VecDesc * getVectorMappingInfo(StringRef F, const ElementCount &VF, bool Masked) const

Definition TargetLibraryInfo.h:386

TargetLibraryInfo & operator=(TargetLibraryInfo &&TLI)=default

unsigned getIntSize() const

Get size of a C-level int or unsigned int, in bits.

Definition TargetLibraryInfo.h:577

friend class TargetLibraryInfoWrapperPass

Definition TargetLibraryInfo.h:268

TargetLibraryInfo(TargetLibraryInfo &&TLI)=default

friend class TargetLibraryAnalysis

Definition TargetLibraryInfo.h:267

void setUnavailable(LibFunc F)

Forces a function to be marked as unavailable.

Definition TargetLibraryInfo.h:360

Attribute::AttrKind getExtAttrForI32Param(bool Signed=true) const

Definition TargetLibraryInfo.h:508

bool isFunctionVectorizable(StringRef F, const ElementCount &VF) const

Definition TargetLibraryInfo.h:376

Triple - Helper class for working with autoconf configuration names.

The instances of the Type class are immutable: once they are created, they are never changed.

Provides info so a possible vectorization of a function can be computed.

Definition TargetLibraryInfo.h:45

StringRef getVABIPrefix() const

Definition TargetLibraryInfo.h:66

bool isMasked() const

Definition TargetLibraryInfo.h:65

std::optional< CallingConv::ID > getCallingConv() const

Definition TargetLibraryInfo.h:67

LLVM_ABI std::string getVectorFunctionABIVariantString() const

Returns a vector function ABI variant string on the form: ZGV(<...

StringRef getScalarFnName() const

Definition TargetLibraryInfo.h:62

StringRef getVectorFnName() const

Definition TargetLibraryInfo.h:63

ElementCount getVectorizationFactor() const

Definition TargetLibraryInfo.h:64

VecDesc(StringRef ScalarFnName, StringRef VectorFnName, ElementCount VectorizationFactor, bool Masked, StringRef VABIPrefix, std::optional< CallingConv::ID > Conv)

Definition TargetLibraryInfo.h:55

@ C

The default llvm calling convention, compatible with C.

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key

OutputIt move(R &&Range, OutputIt Out)

Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.

VectorLibrary

List of known vector-functions libraries.

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

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

A CRTP mix-in that provides informational APIs needed for analysis passes.

A special type used by analysis passes to provide an address that identifies that particular analysis...