LLVM  6.0.0svn
TargetLibraryInfo.h
Go to the documentation of this file.
1 //===-- TargetLibraryInfo.h - Library information ---------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_ANALYSIS_TARGETLIBRARYINFO_H
11 #define LLVM_ANALYSIS_TARGETLIBRARYINFO_H
12 
13 #include "llvm/ADT/DenseMap.h"
14 #include "llvm/ADT/Optional.h"
15 #include "llvm/ADT/Triple.h"
16 #include "llvm/IR/CallSite.h"
17 #include "llvm/IR/Function.h"
18 #include "llvm/IR/Module.h"
19 #include "llvm/IR/PassManager.h"
20 #include "llvm/Pass.h"
21 
22 namespace llvm {
23 template <typename T> class ArrayRef;
24 
25 /// Describes a possible vectorization of a function.
26 /// Function 'VectorFnName' is equivalent to 'ScalarFnName' vectorized
27 /// by a factor 'VectorizationFactor'.
28 struct VecDesc {
32 };
33 
34  enum LibFunc {
35 #define TLI_DEFINE_ENUM
36 #include "llvm/Analysis/TargetLibraryInfo.def"
37 
39  };
40 
41 /// Implementation of the target library information.
42 ///
43 /// This class constructs tables that hold the target library information and
44 /// make it available. However, it is somewhat expensive to compute and only
45 /// depends on the triple. So users typically interact with the \c
46 /// TargetLibraryInfo wrapper below.
48  friend class TargetLibraryInfo;
49 
50  unsigned char AvailableArray[(NumLibFuncs+3)/4];
52  static StringRef const StandardNames[NumLibFuncs];
53  bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param;
54 
55  enum AvailabilityState {
56  StandardName = 3, // (memset to all ones)
57  CustomName = 1,
58  Unavailable = 0 // (memset to all zeros)
59  };
60  void setState(LibFunc F, AvailabilityState State) {
61  AvailableArray[F/4] &= ~(3 << 2*(F&3));
62  AvailableArray[F/4] |= State << 2*(F&3);
63  }
64  AvailabilityState getState(LibFunc F) const {
65  return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
66  }
67 
68  /// Vectorization descriptors - sorted by ScalarFnName.
69  std::vector<VecDesc> VectorDescs;
70  /// Scalarization descriptors - same content as VectorDescs but sorted based
71  /// on VectorFnName rather than ScalarFnName.
72  std::vector<VecDesc> ScalarDescs;
73 
74  /// Return true if the function type FTy is valid for the library function
75  /// F, regardless of whether the function is available.
76  bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F,
77  const DataLayout *DL) const;
78 
79 public:
80  /// List of known vector-functions libraries.
81  ///
82  /// The vector-functions library defines, which functions are vectorizable
83  /// and with which factor. The library can be specified by either frontend,
84  /// or a commandline option, and then used by
85  /// addVectorizableFunctionsFromVecLib for filling up the tables of
86  /// vectorizable functions.
88  NoLibrary, // Don't use any vector library.
89  Accelerate, // Use Accelerate framework.
90  SVML // Intel short vector math library.
91  };
92 
94  explicit TargetLibraryInfoImpl(const Triple &T);
95 
96  // Provide value semantics.
99  TargetLibraryInfoImpl &operator=(const TargetLibraryInfoImpl &TLI);
101 
102  /// Searches for a particular function name.
103  ///
104  /// If it is one of the known library functions, return true and set F to the
105  /// corresponding value.
106  bool getLibFunc(StringRef funcName, LibFunc &F) const;
107 
108  /// Searches for a particular function name, also checking that its type is
109  /// valid for the library function matching that name.
110  ///
111  /// If it is one of the known library functions, return true and set F to the
112  /// corresponding value.
113  bool getLibFunc(const Function &FDecl, LibFunc &F) const;
114 
115  /// Forces a function to be marked as unavailable.
117  setState(F, Unavailable);
118  }
119 
120  /// Forces a function to be marked as available.
122  setState(F, StandardName);
123  }
124 
125  /// Forces a function to be marked as available and provide an alternate name
126  /// that must be used.
128  if (StandardNames[F] != Name) {
129  setState(F, CustomName);
130  CustomNames[F] = Name;
131  assert(CustomNames.find(F) != CustomNames.end());
132  } else {
133  setState(F, StandardName);
134  }
135  }
136 
137  /// Disables all builtins.
138  ///
139  /// This can be used for options like -fno-builtin.
140  void disableAllFunctions();
141 
142  /// Add a set of scalar -> vector mappings, queryable via
143  /// getVectorizedFunction and getScalarizedFunction.
144  void addVectorizableFunctions(ArrayRef<VecDesc> Fns);
145 
146  /// Calls addVectorizableFunctions with a known preset of functions for the
147  /// given vector library.
148  void addVectorizableFunctionsFromVecLib(enum VectorLibrary VecLib);
149 
150  /// Return true if the function F has a vector equivalent with vectorization
151  /// factor VF.
152  bool isFunctionVectorizable(StringRef F, unsigned VF) const {
153  return !getVectorizedFunction(F, VF).empty();
154  }
155 
156  /// Return true if the function F has a vector equivalent with any
157  /// vectorization factor.
158  bool isFunctionVectorizable(StringRef F) const;
159 
160  /// Return the name of the equivalent of F, vectorized with factor VF. If no
161  /// such mapping exists, return the empty string.
162  StringRef getVectorizedFunction(StringRef F, unsigned VF) const;
163 
164  /// Return true if the function F has a scalar equivalent, and set VF to be
165  /// the vectorization factor.
166  bool isFunctionScalarizable(StringRef F, unsigned &VF) const {
167  return !getScalarizedFunction(F, VF).empty();
168  }
169 
170  /// Return the name of the equivalent of F, scalarized. If no such mapping
171  /// exists, return the empty string.
172  ///
173  /// Set VF to the vectorization factor.
174  StringRef getScalarizedFunction(StringRef F, unsigned &VF) const;
175 
176  /// Set to true iff i32 parameters to library functions should have signext
177  /// or zeroext attributes if they correspond to C-level int or unsigned int,
178  /// respectively.
179  void setShouldExtI32Param(bool Val) {
180  ShouldExtI32Param = Val;
181  }
182 
183  /// Set to true iff i32 results from library functions should have signext
184  /// or zeroext attributes if they correspond to C-level int or unsigned int,
185  /// respectively.
186  void setShouldExtI32Return(bool Val) {
187  ShouldExtI32Return = Val;
188  }
189 
190  /// Set to true iff i32 parameters to library functions should have signext
191  /// attribute if they correspond to C-level int or unsigned int.
192  void setShouldSignExtI32Param(bool Val) {
193  ShouldSignExtI32Param = Val;
194  }
195 
196  /// Returns the size of the wchar_t type in bytes.
197  unsigned getWCharSize(const Module &M) const;
198 
199  /// Returns size of the default wchar_t type on target \p T. This is mostly
200  /// intended to verify that the size in the frontend matches LLVM. All other
201  /// queries should use getWCharSize() instead.
202  static unsigned getTargetWCharSize(const Triple &T);
203 };
204 
205 /// Provides information about what library functions are available for
206 /// the current target.
207 ///
208 /// This both allows optimizations to handle them specially and frontends to
209 /// disable such optimizations through -fno-builtin etc.
211  friend class TargetLibraryAnalysis;
213 
214  const TargetLibraryInfoImpl *Impl;
215 
216 public:
217  explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl) : Impl(&Impl) {}
218 
219  // Provide value semantics.
220  TargetLibraryInfo(const TargetLibraryInfo &TLI) : Impl(TLI.Impl) {}
221  TargetLibraryInfo(TargetLibraryInfo &&TLI) : Impl(TLI.Impl) {}
223  Impl = TLI.Impl;
224  return *this;
225  }
227  Impl = TLI.Impl;
228  return *this;
229  }
230 
231  /// Searches for a particular function name.
232  ///
233  /// If it is one of the known library functions, return true and set F to the
234  /// corresponding value.
235  bool getLibFunc(StringRef funcName, LibFunc &F) const {
236  return Impl->getLibFunc(funcName, F);
237  }
238 
239  bool getLibFunc(const Function &FDecl, LibFunc &F) const {
240  return Impl->getLibFunc(FDecl, F);
241  }
242 
243  /// If a callsite does not have the 'nobuiltin' attribute, return if the
244  /// called function is a known library function and set F to that function.
246  return !CS.isNoBuiltin() && CS.getCalledFunction() &&
247  getLibFunc(*(CS.getCalledFunction()), F);
248  }
249 
250  /// Tests whether a library function is available.
251  bool has(LibFunc F) const {
252  return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
253  }
254  bool isFunctionVectorizable(StringRef F, unsigned VF) const {
255  return Impl->isFunctionVectorizable(F, VF);
256  }
258  return Impl->isFunctionVectorizable(F);
259  }
261  return Impl->getVectorizedFunction(F, VF);
262  }
263 
264  /// Tests if the function is both available and a candidate for optimized code
265  /// generation.
267  if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
268  return false;
269  switch (F) {
270  default: break;
271  case LibFunc_copysign: case LibFunc_copysignf: case LibFunc_copysignl:
272  case LibFunc_fabs: case LibFunc_fabsf: case LibFunc_fabsl:
273  case LibFunc_sin: case LibFunc_sinf: case LibFunc_sinl:
274  case LibFunc_cos: case LibFunc_cosf: case LibFunc_cosl:
275  case LibFunc_sqrt: case LibFunc_sqrtf: case LibFunc_sqrtl:
276  case LibFunc_sqrt_finite: case LibFunc_sqrtf_finite:
277  case LibFunc_sqrtl_finite:
278  case LibFunc_fmax: case LibFunc_fmaxf: case LibFunc_fmaxl:
279  case LibFunc_fmin: case LibFunc_fminf: case LibFunc_fminl:
280  case LibFunc_floor: case LibFunc_floorf: case LibFunc_floorl:
281  case LibFunc_nearbyint: case LibFunc_nearbyintf: case LibFunc_nearbyintl:
282  case LibFunc_ceil: case LibFunc_ceilf: case LibFunc_ceill:
283  case LibFunc_rint: case LibFunc_rintf: case LibFunc_rintl:
284  case LibFunc_round: case LibFunc_roundf: case LibFunc_roundl:
285  case LibFunc_trunc: case LibFunc_truncf: case LibFunc_truncl:
286  case LibFunc_log2: case LibFunc_log2f: case LibFunc_log2l:
287  case LibFunc_exp2: case LibFunc_exp2f: case LibFunc_exp2l:
288  case LibFunc_memcmp: case LibFunc_strcmp: case LibFunc_strcpy:
289  case LibFunc_stpcpy: case LibFunc_strlen: case LibFunc_strnlen:
290  case LibFunc_memchr: case LibFunc_mempcpy:
291  return true;
292  }
293  return false;
294  }
295 
297  auto State = Impl->getState(F);
298  if (State == TargetLibraryInfoImpl::Unavailable)
299  return StringRef();
300  if (State == TargetLibraryInfoImpl::StandardName)
301  return Impl->StandardNames[F];
302  assert(State == TargetLibraryInfoImpl::CustomName);
303  return Impl->CustomNames.find(F)->second;
304  }
305 
306  /// Returns extension attribute kind to be used for i32 parameters
307  /// corresponding to C-level int or unsigned int. May be zeroext, signext,
308  /// or none.
310  if (Impl->ShouldExtI32Param)
311  return Signed ? Attribute::SExt : Attribute::ZExt;
312  if (Impl->ShouldSignExtI32Param)
313  return Attribute::SExt;
314  return Attribute::None;
315  }
316 
317  /// Returns extension attribute kind to be used for i32 return values
318  /// corresponding to C-level int or unsigned int. May be zeroext, signext,
319  /// or none.
321  if (Impl->ShouldExtI32Return)
322  return Signed ? Attribute::SExt : Attribute::ZExt;
323  return Attribute::None;
324  }
325 
326  /// \copydoc TargetLibraryInfoImpl::getWCharSize()
327  unsigned getWCharSize(const Module &M) const {
328  return Impl->getWCharSize(M);
329  }
330 
331  /// Handle invalidation from the pass manager.
332  ///
333  /// If we try to invalidate this info, just return false. It cannot become
334  /// invalid even if the module or function changes.
337  return false;
338  }
341  return false;
342  }
343 };
344 
345 /// Analysis pass providing the \c TargetLibraryInfo.
346 ///
347 /// Note that this pass's result cannot be invalidated, it is immutable for the
348 /// life of the module.
349 class TargetLibraryAnalysis : public AnalysisInfoMixin<TargetLibraryAnalysis> {
350 public:
352 
353  /// Default construct the library analysis.
354  ///
355  /// This will use the module's triple to construct the library info for that
356  /// module.
358 
359  /// Construct a library analysis with preset info.
360  ///
361  /// This will directly copy the preset info into the result without
362  /// consulting the module's triple.
364  : PresetInfoImpl(std::move(PresetInfoImpl)) {}
365 
368 
369 private:
371  static AnalysisKey Key;
372 
373  Optional<TargetLibraryInfoImpl> PresetInfoImpl;
374 
376 
377  TargetLibraryInfoImpl &lookupInfoImpl(const Triple &T);
378 };
379 
381  TargetLibraryInfoImpl TLIImpl;
382  TargetLibraryInfo TLI;
383 
384  virtual void anchor();
385 
386 public:
387  static char ID;
389  explicit TargetLibraryInfoWrapperPass(const Triple &T);
391 
392  TargetLibraryInfo &getTLI() { return TLI; }
393  const TargetLibraryInfo &getTLI() const { return TLI; }
394 };
395 
396 } // end namespace llvm
397 
398 #endif
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:109
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void setShouldExtI32Return(bool Val)
Set to true iff i32 results from library functions should have signext or zeroext attributes if they ...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
VectorLibrary
List of known vector-functions libraries.
StringRef VectorFnName
TargetLibraryInfo(const TargetLibraryInfo &TLI)
void setShouldExtI32Param(bool Val)
Set to true iff i32 parameters to library functions should have signext or zeroext attributes if they...
StringRef getName(LibFunc F) const
Implementation of the target library information.
TargetLibraryInfo & operator=(const TargetLibraryInfo &TLI)
bool isFunctionScalarizable(StringRef F, unsigned &VF) const
Return true if the function F has a scalar equivalent, and set VF to be the vectorization factor...
bool getLibFunc(const Function &FDecl, LibFunc &F) const
TargetLibraryInfo & operator=(TargetLibraryInfo &&TLI)
Attribute::AttrKind getExtAttrForI32Param(bool Signed=true) const
Returns extension attribute kind to be used for i32 parameters corresponding to C-level int or unsign...
TargetLibraryAnalysis()
Default construct the library analysis.
StringRef ScalarFnName
Definition: BitVector.h:920
Attribute::AttrKind getExtAttrForI32Return(bool Signed=true) const
Returns extension attribute kind to be used for i32 return values corresponding to C-level int or uns...
No attributes have been set.
Definition: Attributes.h:72
Class to represent function types.
Definition: DerivedTypes.h:103
#define F(x, y, z)
Definition: MD5.cpp:55
bool isNoBuiltin() const
Return true if the call should not be treated as a call to a builtin.
Definition: CallSite.h:425
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
bool has(LibFunc F) const
Tests whether a library function is available.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
bool invalidate(Function &, const PreservedAnalyses &, FunctionAnalysisManager::Invalidator &)
void setShouldSignExtI32Param(bool Val)
Set to true iff i32 parameters to library functions should have signext attribute if they correspond ...
void setUnavailable(LibFunc F)
Forces a function to be marked as unavailable.
const char * Name
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:131
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:153
bool isFunctionVectorizable(StringRef F, unsigned VF) const
Return true if the function F has a vector equivalent with vectorization factor VF.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:382
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
unsigned VectorizationFactor
ImmutablePass class - This class is used to provide information that does not need to be run...
Definition: Pass.h:266
Describes a possible vectorization of a function.
bool isFunctionVectorizable(StringRef F, unsigned VF) const
Module.h This file contains the declarations for the Module class.
Provides information about what library functions are available for the current target.
StringRef getVectorizedFunction(StringRef F, unsigned VF) const
Return the name of the equivalent of F, vectorized with factor VF.
bool hasOptimizedCodeGen(LibFunc F) const
Tests if the function is both available and a candidate for optimized code generation.
StringRef getVectorizedFunction(StringRef F, unsigned VF) const
const TargetLibraryInfo & getTLI() const
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:224
bool getLibFunc(ImmutableCallSite CS, LibFunc &F) const
If a callsite does not have the &#39;nobuiltin&#39; attribute, return if the called function is a known libra...
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
bool isFunctionVectorizable(StringRef F) const
Establish a view to a call site for examination.
Definition: CallSite.h:687
unsigned getWCharSize(const Module &M) const
Returns the size of the wchar_t type in bytes.
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:559
TargetLibraryAnalysis(TargetLibraryInfoImpl PresetInfoImpl)
Construct a library analysis with preset info.
bool invalidate(Module &, const PreservedAnalyses &, ModuleAnalysisManager::Invalidator &)
Handle invalidation from the pass manager.
FunTy * getCalledFunction() const
Return the function being called if this is a direct call, otherwise return null (if it&#39;s an indirect...
Definition: CallSite.h:104
Analysis pass providing the TargetLibraryInfo.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void setAvailableWithName(LibFunc F, StringRef Name)
Forces a function to be marked as available and provide an alternate name that must be used...
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A container for analyses that lazily runs them and caches their results.
This header defines various interfaces for pass management in LLVM.
TargetLibraryInfo(TargetLibraryInfo &&TLI)
void setAvailable(LibFunc F)
Forces a function to be marked as available.
TargetLibraryInfo(const TargetLibraryInfoImpl &Impl)
unsigned getWCharSize(const Module &M) const
Returns the size of the wchar_t type in bytes.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:70
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:70