LLVM 19.0.0git
TargetLibraryInfo.h
Go to the documentation of this file.
1//===-- TargetLibraryInfo.h - Library information ---------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_ANALYSIS_TARGETLIBRARYINFO_H
10#define LLVM_ANALYSIS_TARGETLIBRARYINFO_H
11
12#include "llvm/ADT/BitVector.h"
13#include "llvm/ADT/DenseMap.h"
14#include "llvm/IR/InstrTypes.h"
15#include "llvm/IR/PassManager.h"
16#include "llvm/Pass.h"
18#include <optional>
19
20namespace llvm {
21
22template <typename T> class ArrayRef;
23class Function;
24class Module;
25class Triple;
26
27/// Provides info so a possible vectorization of a function can be
28/// computed. Function 'VectorFnName' is equivalent to 'ScalarFnName'
29/// vectorized by a factor 'VectorizationFactor'.
30/// The VABIPrefix string holds information about isa, mask, vlen,
31/// and vparams so a scalar-to-vector mapping of the form:
32/// _ZGV<isa><mask><vlen><vparams>_<scalarname>(<vectorname>)
33/// can be constructed where:
34///
35/// <isa> = "_LLVM_"
36/// <mask> = "M" if masked, "N" if no mask.
37/// <vlen> = Number of concurrent lanes, stored in the `VectorizationFactor`
38/// field of the `VecDesc` struct. If the number of lanes is scalable
39/// then 'x' is printed instead.
40/// <vparams> = "v", as many as are the numArgs.
41/// <scalarname> = the name of the scalar function.
42/// <vectorname> = the name of the vector function.
43class VecDesc {
44 StringRef ScalarFnName;
45 StringRef VectorFnName;
47 bool Masked;
48 StringRef VABIPrefix;
49
50public:
51 VecDesc() = delete;
52 VecDesc(StringRef ScalarFnName, StringRef VectorFnName,
53 ElementCount VectorizationFactor, bool Masked, StringRef VABIPrefix)
54 : ScalarFnName(ScalarFnName), VectorFnName(VectorFnName),
56 VABIPrefix(VABIPrefix) {}
57
58 StringRef getScalarFnName() const { return ScalarFnName; }
59 StringRef getVectorFnName() const { return VectorFnName; }
61 bool isMasked() const { return Masked; }
62 StringRef getVABIPrefix() const { return VABIPrefix; }
63
64 /// Returns a vector function ABI variant string on the form:
65 /// _ZGV<isa><mask><vlen><vparams>_<scalarname>(<vectorname>)
66 std::string getVectorFunctionABIVariantString() const;
67};
68
69 enum LibFunc : unsigned {
70#define TLI_DEFINE_ENUM
71#include "llvm/Analysis/TargetLibraryInfo.def"
72
75 };
76
77/// Implementation of the target library information.
78///
79/// This class constructs tables that hold the target library information and
80/// make it available. However, it is somewhat expensive to compute and only
81/// depends on the triple. So users typically interact with the \c
82/// TargetLibraryInfo wrapper below.
84 friend class TargetLibraryInfo;
85
86 unsigned char AvailableArray[(NumLibFuncs+3)/4];
88 static StringLiteral const StandardNames[NumLibFuncs];
89 bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param, ShouldSignExtI32Return;
90 unsigned SizeOfInt;
91
92 enum AvailabilityState {
93 StandardName = 3, // (memset to all ones)
94 CustomName = 1,
95 Unavailable = 0 // (memset to all zeros)
96 };
97 void setState(LibFunc F, AvailabilityState State) {
98 AvailableArray[F/4] &= ~(3 << 2*(F&3));
99 AvailableArray[F/4] |= State << 2*(F&3);
100 }
101 AvailabilityState getState(LibFunc F) const {
102 return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
103 }
104
105 /// Vectorization descriptors - sorted by ScalarFnName.
106 std::vector<VecDesc> VectorDescs;
107 /// Scalarization descriptors - same content as VectorDescs but sorted based
108 /// on VectorFnName rather than ScalarFnName.
109 std::vector<VecDesc> ScalarDescs;
110
111 /// Return true if the function type FTy is valid for the library function
112 /// F, regardless of whether the function is available.
113 bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F,
114 const Module &M) const;
115
116public:
117 /// List of known vector-functions libraries.
118 ///
119 /// The vector-functions library defines, which functions are vectorizable
120 /// and with which factor. The library can be specified by either frontend,
121 /// or a commandline option, and then used by
122 /// addVectorizableFunctionsFromVecLib for filling up the tables of
123 /// vectorizable functions.
125 NoLibrary, // Don't use any vector library.
126 Accelerate, // Use Accelerate framework.
127 DarwinLibSystemM, // Use Darwin's libsystem_m.
128 LIBMVEC_X86, // GLIBC Vector Math library.
129 MASSV, // IBM MASS vector library.
130 SVML, // Intel short vector math library.
131 SLEEFGNUABI, // SLEEF - SIMD Library for Evaluating Elementary Functions.
132 ArmPL, // Arm Performance Libraries.
133 AMDLIBM // AMD Math Vector library.
134 };
135
137 explicit TargetLibraryInfoImpl(const Triple &T);
138
139 // Provide value semantics.
144
145 /// Searches for a particular function name.
146 ///
147 /// If it is one of the known library functions, return true and set F to the
148 /// corresponding value.
149 bool getLibFunc(StringRef funcName, LibFunc &F) const;
150
151 /// Searches for a particular function name, also checking that its type is
152 /// valid for the library function matching that name.
153 ///
154 /// If it is one of the known library functions, return true and set F to the
155 /// corresponding value.
156 ///
157 /// FDecl is assumed to have a parent Module when using this function.
158 bool getLibFunc(const Function &FDecl, LibFunc &F) const;
159
160 /// Searches for a function name using an Instruction \p Opcode.
161 /// Currently, only the frem instruction is supported.
162 bool getLibFunc(unsigned int Opcode, Type *Ty, LibFunc &F) const;
163
164 /// Forces a function to be marked as unavailable.
166 setState(F, Unavailable);
167 }
168
169 /// Forces a function to be marked as available.
171 setState(F, StandardName);
172 }
173
174 /// Forces a function to be marked as available and provide an alternate name
175 /// that must be used.
177 if (StandardNames[F] != Name) {
178 setState(F, CustomName);
179 CustomNames[F] = std::string(Name);
180 assert(CustomNames.contains(F));
181 } else {
182 setState(F, StandardName);
183 }
184 }
185
186 /// Disables all builtins.
187 ///
188 /// This can be used for options like -fno-builtin.
189 void disableAllFunctions();
190
191 /// Add a set of scalar -> vector mappings, queryable via
192 /// getVectorizedFunction and getScalarizedFunction.
194
195 /// Calls addVectorizableFunctions with a known preset of functions for the
196 /// given vector library.
198 const llvm::Triple &TargetTriple);
199
200 /// Return true if the function F has a vector equivalent with vectorization
201 /// factor VF.
203 return !(getVectorizedFunction(F, VF, false).empty() &&
204 getVectorizedFunction(F, VF, true).empty());
205 }
206
207 /// Return true if the function F has a vector equivalent with any
208 /// vectorization factor.
210
211 /// Return the name of the equivalent of F, vectorized with factor VF. If no
212 /// such mapping exists, return the empty string.
214 bool Masked) const;
215
216 /// Return a pointer to a VecDesc object holding all info for scalar to vector
217 /// mappings in TLI for the equivalent of F, vectorized with factor VF.
218 /// If no such mapping exists, return nullpointer.
220 bool Masked) const;
221
222 /// Set to true iff i32 parameters to library functions should have signext
223 /// or zeroext attributes if they correspond to C-level int or unsigned int,
224 /// respectively.
225 void setShouldExtI32Param(bool Val) {
226 ShouldExtI32Param = Val;
227 }
228
229 /// Set to true iff i32 results from library functions should have signext
230 /// or zeroext attributes if they correspond to C-level int or unsigned int,
231 /// respectively.
232 void setShouldExtI32Return(bool Val) {
233 ShouldExtI32Return = Val;
234 }
235
236 /// Set to true iff i32 parameters to library functions should have signext
237 /// attribute if they correspond to C-level int or unsigned int.
239 ShouldSignExtI32Param = Val;
240 }
241
242 /// Set to true iff i32 results from library functions should have signext
243 /// attribute if they correspond to C-level int or unsigned int.
245 ShouldSignExtI32Return = Val;
246 }
247
248 /// Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
249 /// This queries the 'wchar_size' metadata.
250 unsigned getWCharSize(const Module &M) const;
251
252 /// Returns the size of the size_t type in bits.
253 unsigned getSizeTSize(const Module &M) const;
254
255 /// Get size of a C-level int or unsigned int, in bits.
256 unsigned getIntSize() const {
257 return SizeOfInt;
258 }
259
260 /// Initialize the C-level size of an integer.
261 void setIntSize(unsigned Bits) {
262 SizeOfInt = Bits;
263 }
264
265 /// Returns the largest vectorization factor used in the list of
266 /// vector functions.
267 void getWidestVF(StringRef ScalarF, ElementCount &FixedVF,
268 ElementCount &Scalable) const;
269
270 /// Returns true if call site / callee has cdecl-compatible calling
271 /// conventions.
272 static bool isCallingConvCCompatible(CallBase *CI);
273 static bool isCallingConvCCompatible(Function *Callee);
274};
275
276/// Provides information about what library functions are available for
277/// the current target.
278///
279/// This both allows optimizations to handle them specially and frontends to
280/// disable such optimizations through -fno-builtin etc.
284
285 /// The global (module level) TLI info.
286 const TargetLibraryInfoImpl *Impl;
287
288 /// Support for -fno-builtin* options as function attributes, overrides
289 /// information in global TargetLibraryInfoImpl.
290 BitVector OverrideAsUnavailable;
291
292public:
294 std::optional<const Function *> F = std::nullopt)
295 : Impl(&Impl), OverrideAsUnavailable(NumLibFuncs) {
296 if (!F)
297 return;
298 if ((*F)->hasFnAttribute("no-builtins"))
300 else {
301 // Disable individual libc/libm calls in TargetLibraryInfo.
302 LibFunc LF;
303 AttributeSet FnAttrs = (*F)->getAttributes().getFnAttrs();
304 for (const Attribute &Attr : FnAttrs) {
305 if (!Attr.isStringAttribute())
306 continue;
307 auto AttrStr = Attr.getKindAsString();
308 if (!AttrStr.consume_front("no-builtin-"))
309 continue;
310 if (getLibFunc(AttrStr, LF))
311 setUnavailable(LF);
312 }
313 }
314 }
315
316 // Provide value semantics.
319 : Impl(TLI.Impl), OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
322 Impl = TLI.Impl;
323 OverrideAsUnavailable = TLI.OverrideAsUnavailable;
324 return *this;
325 }
326
327 /// Determine whether a callee with the given TLI can be inlined into
328 /// caller with this TLI, based on 'nobuiltin' attributes. When requested,
329 /// allow inlining into a caller with a superset of the callee's nobuiltin
330 /// attributes, which is conservatively correct.
332 bool AllowCallerSuperset) const {
333 if (!AllowCallerSuperset)
334 return OverrideAsUnavailable == CalleeTLI.OverrideAsUnavailable;
335 BitVector B = OverrideAsUnavailable;
336 B |= CalleeTLI.OverrideAsUnavailable;
337 // We can inline if the union of the caller and callee's nobuiltin
338 // attributes is no stricter than the caller's nobuiltin attributes.
339 return B == OverrideAsUnavailable;
340 }
341
342 /// Return true if the function type FTy is valid for the library function
343 /// F, regardless of whether the function is available.
345 const Module &M) const {
346 return Impl->isValidProtoForLibFunc(FTy, F, M);
347 }
348
349 /// Searches for a particular function name.
350 ///
351 /// If it is one of the known library functions, return true and set F to the
352 /// corresponding value.
353 bool getLibFunc(StringRef funcName, LibFunc &F) const {
354 return Impl->getLibFunc(funcName, F);
355 }
356
357 bool getLibFunc(const Function &FDecl, LibFunc &F) const {
358 return Impl->getLibFunc(FDecl, F);
359 }
360
361 /// If a callbase does not have the 'nobuiltin' attribute, return if the
362 /// called function is a known library function and set F to that function.
363 bool getLibFunc(const CallBase &CB, LibFunc &F) const {
364 return !CB.isNoBuiltin() && CB.getCalledFunction() &&
366 }
367
368 /// Searches for a function name using an Instruction \p Opcode.
369 /// Currently, only the frem instruction is supported.
370 bool getLibFunc(unsigned int Opcode, Type *Ty, LibFunc &F) const {
371 return Impl->getLibFunc(Opcode, Ty, F);
372 }
373
374 /// Disables all builtins.
375 ///
376 /// This can be used for options like -fno-builtin.
378 OverrideAsUnavailable.set();
379 }
380
381 /// Forces a function to be marked as unavailable.
383 OverrideAsUnavailable.set(F);
384 }
385
386 TargetLibraryInfoImpl::AvailabilityState getState(LibFunc F) const {
387 if (OverrideAsUnavailable[F])
388 return TargetLibraryInfoImpl::Unavailable;
389 return Impl->getState(F);
390 }
391
392 /// Tests whether a library function is available.
393 bool has(LibFunc F) const {
394 return getState(F) != TargetLibraryInfoImpl::Unavailable;
395 }
397 return Impl->isFunctionVectorizable(F, VF);
398 }
400 return Impl->isFunctionVectorizable(F);
401 }
403 bool Masked = false) const {
404 return Impl->getVectorizedFunction(F, VF, Masked);
405 }
407 bool Masked) const {
408 return Impl->getVectorMappingInfo(F, VF, Masked);
409 }
410
411 /// Tests if the function is both available and a candidate for optimized code
412 /// generation.
414 if (getState(F) == TargetLibraryInfoImpl::Unavailable)
415 return false;
416 switch (F) {
417 default: break;
418 case LibFunc_copysign: case LibFunc_copysignf: case LibFunc_copysignl:
419 case LibFunc_fabs: case LibFunc_fabsf: case LibFunc_fabsl:
420 case LibFunc_sin: case LibFunc_sinf: case LibFunc_sinl:
421 case LibFunc_cos: case LibFunc_cosf: case LibFunc_cosl:
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_fmax: case LibFunc_fmaxf: case LibFunc_fmaxl:
426 case LibFunc_fmin: case LibFunc_fminf: case LibFunc_fminl:
427 case LibFunc_floor: case LibFunc_floorf: case LibFunc_floorl:
428 case LibFunc_nearbyint: case LibFunc_nearbyintf: case LibFunc_nearbyintl:
429 case LibFunc_ceil: case LibFunc_ceilf: case LibFunc_ceill:
430 case LibFunc_rint: case LibFunc_rintf: case LibFunc_rintl:
431 case LibFunc_round: case LibFunc_roundf: case LibFunc_roundl:
432 case LibFunc_trunc: case LibFunc_truncf: case LibFunc_truncl:
433 case LibFunc_log2: case LibFunc_log2f: case LibFunc_log2l:
434 case LibFunc_exp2: case LibFunc_exp2f: case LibFunc_exp2l:
435 case LibFunc_ldexp: case LibFunc_ldexpf: case LibFunc_ldexpl:
436 case LibFunc_memcpy: case LibFunc_memset: case LibFunc_memmove:
437 case LibFunc_memcmp: case LibFunc_bcmp: case LibFunc_strcmp:
438 case LibFunc_strcpy: case LibFunc_stpcpy: case LibFunc_strlen:
439 case LibFunc_strnlen: case LibFunc_memchr: case LibFunc_mempcpy:
440 return true;
441 }
442 return false;
443 }
444
446 auto State = getState(F);
447 if (State == TargetLibraryInfoImpl::Unavailable)
448 return StringRef();
449 if (State == TargetLibraryInfoImpl::StandardName)
450 return Impl->StandardNames[F];
451 assert(State == TargetLibraryInfoImpl::CustomName);
452 return Impl->CustomNames.find(F)->second;
453 }
454
455 static void initExtensionsForTriple(bool &ShouldExtI32Param,
456 bool &ShouldExtI32Return,
457 bool &ShouldSignExtI32Param,
458 bool &ShouldSignExtI32Return,
459 const Triple &T) {
460 ShouldExtI32Param = ShouldExtI32Return = false;
461 ShouldSignExtI32Param = ShouldSignExtI32Return = false;
462
463 // PowerPC64, Sparc64, SystemZ need signext/zeroext on i32 parameters and
464 // returns corresponding to C-level ints and unsigned ints.
465 if (T.isPPC64() || T.getArch() == Triple::sparcv9 ||
466 T.getArch() == Triple::systemz) {
467 ShouldExtI32Param = true;
468 ShouldExtI32Return = true;
469 }
470 // LoongArch, Mips, and riscv64, on the other hand, need signext on i32
471 // parameters corresponding to both signed and unsigned ints.
472 if (T.isLoongArch() || T.isMIPS() || T.isRISCV64()) {
473 ShouldSignExtI32Param = true;
474 }
475 // LoongArch and riscv64 need signext on i32 returns corresponding to both
476 // signed and unsigned ints.
477 if (T.isLoongArch() || T.isRISCV64()) {
478 ShouldSignExtI32Return = true;
479 }
480 }
481
482 /// Returns extension attribute kind to be used for i32 parameters
483 /// corresponding to C-level int or unsigned int. May be zeroext, signext,
484 /// or none.
485private:
486 static Attribute::AttrKind getExtAttrForI32Param(bool ShouldExtI32Param_,
487 bool ShouldSignExtI32Param_,
488 bool Signed = true) {
489 if (ShouldExtI32Param_)
490 return Signed ? Attribute::SExt : Attribute::ZExt;
491 if (ShouldSignExtI32Param_)
492 return Attribute::SExt;
493 return Attribute::None;
494 }
495
496public:
498 bool Signed = true) {
499 bool ShouldExtI32Param, ShouldExtI32Return;
500 bool ShouldSignExtI32Param, ShouldSignExtI32Return;
501 initExtensionsForTriple(ShouldExtI32Param, ShouldExtI32Return,
502 ShouldSignExtI32Param, ShouldSignExtI32Return, T);
503 return getExtAttrForI32Param(ShouldExtI32Param, ShouldSignExtI32Param,
504 Signed);
505 }
506
508 return getExtAttrForI32Param(Impl->ShouldExtI32Param,
509 Impl->ShouldSignExtI32Param, Signed);
510 }
511
512 /// Returns extension attribute kind to be used for i32 return values
513 /// corresponding to C-level int or unsigned int. May be zeroext, signext,
514 /// or none.
515private:
516 static Attribute::AttrKind getExtAttrForI32Return(bool ShouldExtI32Return_,
517 bool ShouldSignExtI32Return_,
518 bool Signed) {
519 if (ShouldExtI32Return_)
520 return Signed ? Attribute::SExt : Attribute::ZExt;
521 if (ShouldSignExtI32Return_)
522 return Attribute::SExt;
523 return Attribute::None;
524 }
525
526public:
528 bool Signed = true) {
529 bool ShouldExtI32Param, ShouldExtI32Return;
530 bool ShouldSignExtI32Param, ShouldSignExtI32Return;
531 initExtensionsForTriple(ShouldExtI32Param, ShouldExtI32Return,
532 ShouldSignExtI32Param, ShouldSignExtI32Return, T);
533 return getExtAttrForI32Return(ShouldExtI32Return, ShouldSignExtI32Return,
534 Signed);
535 }
536
538 return getExtAttrForI32Return(Impl->ShouldExtI32Return,
539 Impl->ShouldSignExtI32Return, Signed);
540 }
541
542 // Helper to create an AttributeList for args (and ret val) which all have
543 // the same signedness. Attributes in AL may be passed in to include them
544 // as well in the returned AttributeList.
546 bool Signed, bool Ret = false,
547 AttributeList AL = AttributeList()) const {
548 if (auto AK = getExtAttrForI32Param(Signed))
549 for (auto ArgNo : ArgNos)
550 AL = AL.addParamAttribute(*C, ArgNo, AK);
551 if (Ret)
552 if (auto AK = getExtAttrForI32Return(Signed))
553 AL = AL.addRetAttribute(*C, AK);
554 return AL;
555 }
556
557 /// \copydoc TargetLibraryInfoImpl::getWCharSize()
558 unsigned getWCharSize(const Module &M) const {
559 return Impl->getWCharSize(M);
560 }
561
562 /// \copydoc TargetLibraryInfoImpl::getSizeTSize()
563 unsigned getSizeTSize(const Module &M) const { return Impl->getSizeTSize(M); }
564
565 /// \copydoc TargetLibraryInfoImpl::getIntSize()
566 unsigned getIntSize() const {
567 return Impl->getIntSize();
568 }
569
570 /// Handle invalidation from the pass manager.
571 ///
572 /// If we try to invalidate this info, just return false. It cannot become
573 /// invalid even if the module or function changes.
576 return false;
577 }
580 return false;
581 }
582 /// Returns the largest vectorization factor used in the list of
583 /// vector functions.
584 void getWidestVF(StringRef ScalarF, ElementCount &FixedVF,
585 ElementCount &ScalableVF) const {
586 Impl->getWidestVF(ScalarF, FixedVF, ScalableVF);
587 }
588
589 /// Check if the function "F" is listed in a library known to LLVM.
591 return this->isFunctionVectorizable(F);
592 }
593};
594
595/// Analysis pass providing the \c TargetLibraryInfo.
596///
597/// Note that this pass's result cannot be invalidated, it is immutable for the
598/// life of the module.
599class TargetLibraryAnalysis : public AnalysisInfoMixin<TargetLibraryAnalysis> {
600public:
602
603 /// Default construct the library analysis.
604 ///
605 /// This will use the module's triple to construct the library info for that
606 /// module.
608
609 /// Construct a library analysis with baseline Module-level info.
610 ///
611 /// This will be supplemented with Function-specific info in the Result.
613 : BaselineInfoImpl(std::move(BaselineInfoImpl)) {}
614
616
617private:
619 static AnalysisKey Key;
620
621 std::optional<TargetLibraryInfoImpl> BaselineInfoImpl;
622};
623
626 std::optional<TargetLibraryInfo> TLI;
627
628 virtual void anchor();
629
630public:
631 static char ID;
633 explicit TargetLibraryInfoWrapperPass(const Triple &T);
635
638 TLI = TLA.run(F, DummyFAM);
639 return *TLI;
640 }
641};
642
643} // end namespace llvm
644
645#endif
This file implements the BitVector class.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define LLVM_ATTRIBUTE_UNUSED
Definition: Compiler.h:203
This file defines the DenseMap class.
std::string Name
AvailabilityState
Definition: GVN.cpp:808
@ Unavailable
We know the block is not fully available. This is a fixpoint.
#define F(x, y, z)
Definition: MD5.cpp:55
Machine Check Debug Module
This header defines various interfaces for pass management in LLVM.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:387
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:348
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
Definition: Attributes.h:84
@ None
No attributes have been set.
Definition: Attributes.h:86
BitVector & set()
Definition: BitVector.h:351
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1457
bool isNoBuiltin() const
Return true if the call should not be treated as a call to a builtin.
Definition: InstrTypes.h:2160
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
Definition: InstrTypes.h:1696
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
Class to represent function types.
Definition: DerivedTypes.h:103
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:282
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:109
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition: StringRef.h:849
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
Analysis pass providing the TargetLibraryInfo.
TargetLibraryAnalysis()=default
Default construct the library analysis.
TargetLibraryInfo run(const Function &F, FunctionAnalysisManager &)
TargetLibraryAnalysis(TargetLibraryInfoImpl BaselineInfoImpl)
Construct a library analysis with baseline Module-level info.
Implementation of the target library information.
void setShouldExtI32Param(bool Val)
Set to true iff i32 parameters to library functions should have signext or zeroext attributes if they...
void setShouldExtI32Return(bool Val)
Set to true iff i32 results from library functions should have signext or zeroext attributes if they ...
unsigned getWCharSize(const Module &M) const
Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
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.
void setShouldSignExtI32Param(bool Val)
Set to true iff i32 parameters to library functions should have signext attribute if they correspond ...
void setAvailableWithName(LibFunc F, StringRef Name)
Forces a function to be marked as available and provide an alternate name that must be used.
unsigned getIntSize() const
Get size of a C-level int or unsigned int, in bits.
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.
unsigned getSizeTSize(const Module &M) const
Returns the size of the size_t type in bits.
void addVectorizableFunctions(ArrayRef< VecDesc > Fns)
Add a set of scalar -> vector mappings, queryable via getVectorizedFunction and getScalarizedFunction...
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 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...
TargetLibraryInfoImpl & operator=(const TargetLibraryInfoImpl &TLI)
void disableAllFunctions()
Disables all builtins.
VectorLibrary
List of known vector-functions libraries.
void setUnavailable(LibFunc F)
Forces a function to be marked as unavailable.
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.
TargetLibraryInfo & getTLI(const Function &F)
Provides information about what library functions are available for the current target.
AttributeList getAttrList(LLVMContext *C, ArrayRef< unsigned > ArgNos, bool Signed, bool Ret=false, AttributeList AL=AttributeList()) const
TargetLibraryInfo & operator=(TargetLibraryInfo &&TLI)
static Attribute::AttrKind getExtAttrForI32Param(const Triple &T, bool Signed=true)
bool areInlineCompatible(const TargetLibraryInfo &CalleeTLI, bool AllowCallerSuperset) const
Determine whether a callee with the given TLI can be inlined into caller with this TLI,...
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...
bool invalidate(Module &, const PreservedAnalyses &, ModuleAnalysisManager::Invalidator &)
Handle invalidation from the pass manager.
TargetLibraryInfo(TargetLibraryInfo &&TLI)
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...
unsigned getWCharSize(const Module &M) const
Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
bool hasOptimizedCodeGen(LibFunc F) const
Tests if the function is both available and a candidate for optimized code generation.
Attribute::AttrKind getExtAttrForI32Return(bool Signed=true) const
bool invalidate(Function &, const PreservedAnalyses &, FunctionAnalysisManager::Invalidator &)
bool isKnownVectorFunctionInLibrary(StringRef F) const
Check if the function "F" is listed in a library known to LLVM.
bool isFunctionVectorizable(StringRef F) const
bool has(LibFunc F) const
Tests whether a library function is available.
unsigned getSizeTSize(const Module &M) const
Returns the size of the size_t type in bits.
TargetLibraryInfoImpl::AvailabilityState getState(LibFunc F) const
TargetLibraryInfo & operator=(const TargetLibraryInfo &TLI)=default
void disableAllFunctions() LLVM_ATTRIBUTE_UNUSED
Disables all builtins.
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.
void setUnavailable(LibFunc F) LLVM_ATTRIBUTE_UNUSED
Forces a function to be marked as unavailable.
TargetLibraryInfo(const TargetLibraryInfoImpl &Impl, std::optional< const Function * > F=std::nullopt)
static Attribute::AttrKind getExtAttrForI32Return(const Triple &T, bool Signed=true)
bool getLibFunc(const Function &FDecl, LibFunc &F) const
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
static void initExtensionsForTriple(bool &ShouldExtI32Param, bool &ShouldExtI32Return, bool &ShouldSignExtI32Param, bool &ShouldSignExtI32Return, const Triple &T)
bool getLibFunc(unsigned int Opcode, Type *Ty, LibFunc &F) const
Searches for a function name using an Instruction Opcode.
StringRef getVectorizedFunction(StringRef F, const ElementCount &VF, bool Masked=false) const
StringRef getName(LibFunc F) const
const VecDesc * getVectorMappingInfo(StringRef F, const ElementCount &VF, bool Masked) const
unsigned getIntSize() const
Get size of a C-level int or unsigned int, in bits.
Attribute::AttrKind getExtAttrForI32Param(bool Signed=true) const
bool isFunctionVectorizable(StringRef F, const ElementCount &VF) const
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
Provides info so a possible vectorization of a function can be computed.
StringRef getVABIPrefix() const
VecDesc()=delete
bool isMasked() const
std::string getVectorFunctionABIVariantString() const
Returns a vector function ABI variant string on the form: ZGV<isa><mask><vlen><vparams><scalarname>(<...
StringRef getScalarFnName() const
VecDesc(StringRef ScalarFnName, StringRef VectorFnName, ElementCount VectorizationFactor, bool Masked, StringRef VABIPrefix)
StringRef getVectorFnName() const
ElementCount getVectorizationFactor() const
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
ArrayRef(const T &OneElt) -> ArrayRef< T >
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1858
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:114
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:26
TODO: The following VectorizationFactor was pulled out of LoopVectorizationCostModel class.