Coverage Report

Created: 2018-09-25 00:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Analysis/TargetLibraryInfo.h
Line
Count
Source (jump to first uncovered line)
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 {
29
  StringRef ScalarFnName;
30
  StringRef VectorFnName;
31
  unsigned VectorizationFactor;
32
};
33
34
  enum LibFunc {
35
#define TLI_DEFINE_ENUM
36
#include "llvm/Analysis/TargetLibraryInfo.def"
37
38
    NumLibFuncs
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.
47
class TargetLibraryInfoImpl {
48
  friend class TargetLibraryInfo;
49
50
  unsigned char AvailableArray[(NumLibFuncs+3)/4];
51
  llvm::DenseMap<unsigned, std::string> CustomNames;
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
7.53M
  void setState(LibFunc F, AvailabilityState State) {
61
7.53M
    AvailableArray[F/4] &= ~(3 << 2*(F&3));
62
7.53M
    AvailableArray[F/4] |= State << 2*(F&3);
63
7.53M
  }
64
26.6M
  AvailabilityState getState(LibFunc F) const {
65
26.6M
    return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
66
26.6M
  }
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.
87
  enum VectorLibrary {
88
    NoLibrary,  // Don't use any vector library.
89
    Accelerate, // Use Accelerate framework.
90
    SVML        // Intel short vector math library.
91
  };
92
93
  TargetLibraryInfoImpl();
94
  explicit TargetLibraryInfoImpl(const Triple &T);
95
96
  // Provide value semantics.
97
  TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI);
98
  TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI);
99
  TargetLibraryInfoImpl &operator=(const TargetLibraryInfoImpl &TLI);
100
  TargetLibraryInfoImpl &operator=(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.
116
7.37M
  void setUnavailable(LibFunc F) {
117
7.37M
    setState(F, Unavailable);
118
7.37M
  }
119
120
  /// Forces a function to be marked as available.
121
119k
  void setAvailable(LibFunc F) {
122
119k
    setState(F, StandardName);
123
119k
  }
124
125
  /// Forces a function to be marked as available and provide an alternate name
126
  /// that must be used.
127
41.5k
  void setAvailableWithName(LibFunc F, StringRef Name) {
128
41.5k
    if (StandardNames[F] != Name) {
129
41.5k
      setState(F, CustomName);
130
41.5k
      CustomNames[F] = Name;
131
41.5k
      assert(CustomNames.find(F) != CustomNames.end());
132
41.5k
    } else {
133
4
      setState(F, StandardName);
134
4
    }
135
41.5k
  }
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
1.28k
  bool isFunctionVectorizable(StringRef F, unsigned VF) const {
153
1.28k
    return !getVectorizedFunction(F, VF).empty();
154
1.28k
  }
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
0
  bool isFunctionScalarizable(StringRef F, unsigned &VF) const {
167
0
    return !getScalarizedFunction(F, VF).empty();
168
0
  }
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
92.5k
  void setShouldExtI32Param(bool Val) {
180
92.5k
    ShouldExtI32Param = Val;
181
92.5k
  }
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
92.5k
  void setShouldExtI32Return(bool Val) {
187
92.5k
    ShouldExtI32Return = Val;
188
92.5k
  }
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
92.5k
  void setShouldSignExtI32Param(bool Val) {
193
92.5k
    ShouldSignExtI32Param = Val;
194
92.5k
  }
195
196
  /// Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
197
  /// This queries the 'wchar_size' metadata.
198
  unsigned getWCharSize(const Module &M) const;
199
};
200
201
/// Provides information about what library functions are available for
202
/// the current target.
203
///
204
/// This both allows optimizations to handle them specially and frontends to
205
/// disable such optimizations through -fno-builtin etc.
206
class TargetLibraryInfo {
207
  friend class TargetLibraryAnalysis;
208
  friend class TargetLibraryInfoWrapperPass;
209
210
  const TargetLibraryInfoImpl *Impl;
211
212
public:
213
115k
  explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl) : Impl(&Impl) {}
214
215
  // Provide value semantics.
216
  TargetLibraryInfo(const TargetLibraryInfo &TLI) : Impl(TLI.Impl) {}
217
6.06k
  TargetLibraryInfo(TargetLibraryInfo &&TLI) : Impl(TLI.Impl) {}
218
  TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI) {
219
    Impl = TLI.Impl;
220
    return *this;
221
  }
222
  TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) {
223
    Impl = TLI.Impl;
224
    return *this;
225
  }
226
227
  /// Searches for a particular function name.
228
  ///
229
  /// If it is one of the known library functions, return true and set F to the
230
  /// corresponding value.
231
25.7M
  bool getLibFunc(StringRef funcName, LibFunc &F) const {
232
25.7M
    return Impl->getLibFunc(funcName, F);
233
25.7M
  }
234
235
23.7M
  bool getLibFunc(const Function &FDecl, LibFunc &F) const {
236
23.7M
    return Impl->getLibFunc(FDecl, F);
237
23.7M
  }
238
239
  /// If a callsite does not have the 'nobuiltin' attribute, return if the
240
  /// called function is a known library function and set F to that function.
241
1.86M
  bool getLibFunc(ImmutableCallSite CS, LibFunc &F) const {
242
1.86M
    return !CS.isNoBuiltin() && 
CS.getCalledFunction()753k
&&
243
1.86M
           
getLibFunc(*(CS.getCalledFunction()), F)709k
;
244
1.86M
  }
245
246
  /// Tests whether a library function is available.
247
20.7M
  bool has(LibFunc F) const {
248
20.7M
    return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
249
20.7M
  }
250
1.28k
  bool isFunctionVectorizable(StringRef F, unsigned VF) const {
251
1.28k
    return Impl->isFunctionVectorizable(F, VF);
252
1.28k
  }
253
30.3k
  bool isFunctionVectorizable(StringRef F) const {
254
30.3k
    return Impl->isFunctionVectorizable(F);
255
30.3k
  }
256
72
  StringRef getVectorizedFunction(StringRef F, unsigned VF) const {
257
72
    return Impl->getVectorizedFunction(F, VF);
258
72
  }
259
260
  /// Tests if the function is both available and a candidate for optimized code
261
  /// generation.
262
79.8k
  bool hasOptimizedCodeGen(LibFunc F) const {
263
79.8k
    if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
264
3.05k
      return false;
265
76.8k
    switch (F) {
266
76.8k
    
default: break67.5k
;
267
76.8k
    
case LibFunc_copysign: 9.27k
case LibFunc_copysignf: 9.27k
case LibFunc_copysignl:
268
9.27k
    case LibFunc_fabs:         case LibFunc_fabsf:      case LibFunc_fabsl:
269
9.27k
    case LibFunc_sin:          case LibFunc_sinf:       case LibFunc_sinl:
270
9.27k
    case LibFunc_cos:          case LibFunc_cosf:       case LibFunc_cosl:
271
9.27k
    case LibFunc_sqrt:         case LibFunc_sqrtf:      case LibFunc_sqrtl:
272
9.27k
    case LibFunc_sqrt_finite:  case LibFunc_sqrtf_finite:
273
9.27k
                                                   case LibFunc_sqrtl_finite:
274
9.27k
    case LibFunc_fmax:         case LibFunc_fmaxf:      case LibFunc_fmaxl:
275
9.27k
    case LibFunc_fmin:         case LibFunc_fminf:      case LibFunc_fminl:
276
9.27k
    case LibFunc_floor:        case LibFunc_floorf:     case LibFunc_floorl:
277
9.27k
    case LibFunc_nearbyint:    case LibFunc_nearbyintf: case LibFunc_nearbyintl:
278
9.27k
    case LibFunc_ceil:         case LibFunc_ceilf:      case LibFunc_ceill:
279
9.27k
    case LibFunc_rint:         case LibFunc_rintf:      case LibFunc_rintl:
280
9.27k
    case LibFunc_round:        case LibFunc_roundf:     case LibFunc_roundl:
281
9.27k
    case LibFunc_trunc:        case LibFunc_truncf:     case LibFunc_truncl:
282
9.27k
    case LibFunc_log2:         case LibFunc_log2f:      case LibFunc_log2l:
283
9.27k
    case LibFunc_exp2:         case LibFunc_exp2f:      case LibFunc_exp2l:
284
9.27k
    case LibFunc_memcmp:       case LibFunc_strcmp:     case LibFunc_strcpy:
285
9.27k
    case LibFunc_stpcpy:       case LibFunc_strlen:     case LibFunc_strnlen:
286
9.27k
    case LibFunc_memchr:       case LibFunc_mempcpy:
287
9.27k
      return true;
288
67.5k
    }
289
67.5k
    return false;
290
67.5k
  }
291
292
5.87M
  StringRef getName(LibFunc F) const {
293
5.87M
    auto State = Impl->getState(F);
294
5.87M
    if (State == TargetLibraryInfoImpl::Unavailable)
295
174
      return StringRef();
296
5.87M
    if (State == TargetLibraryInfoImpl::StandardName)
297
5.87M
      return Impl->StandardNames[F];
298
37
    assert(State == TargetLibraryInfoImpl::CustomName);
299
37
    return Impl->CustomNames.find(F)->second;
300
37
  }
301
302
  /// Returns extension attribute kind to be used for i32 parameters
303
  /// corresponding to C-level int or unsigned int.  May be zeroext, signext,
304
  /// or none.
305
180
  Attribute::AttrKind getExtAttrForI32Param(bool Signed = true) const {
306
180
    if (Impl->ShouldExtI32Param)
307
8
      return Signed ? 
Attribute::SExt0
: Attribute::ZExt;
308
172
    if (Impl->ShouldSignExtI32Param)
309
4
      return Attribute::SExt;
310
168
    return Attribute::None;
311
168
  }
312
313
  /// Returns extension attribute kind to be used for i32 return values
314
  /// corresponding to C-level int or unsigned int.  May be zeroext, signext,
315
  /// or none.
316
  Attribute::AttrKind getExtAttrForI32Return(bool Signed = true) const {
317
    if (Impl->ShouldExtI32Return)
318
      return Signed ? Attribute::SExt : Attribute::ZExt;
319
    return Attribute::None;
320
  }
321
322
  /// \copydoc TargetLibraryInfoImpl::getWCharSize()
323
73
  unsigned getWCharSize(const Module &M) const {
324
73
    return Impl->getWCharSize(M);
325
73
  }
326
327
  /// Handle invalidation from the pass manager.
328
  ///
329
  /// If we try to invalidate this info, just return false. It cannot become
330
  /// invalid even if the module or function changes.
331
  bool invalidate(Module &, const PreservedAnalyses &,
332
361
                  ModuleAnalysisManager::Invalidator &) {
333
361
    return false;
334
361
  }
335
  bool invalidate(Function &, const PreservedAnalyses &,
336
2.23k
                  FunctionAnalysisManager::Invalidator &) {
337
2.23k
    return false;
338
2.23k
  }
339
};
340
341
/// Analysis pass providing the \c TargetLibraryInfo.
342
///
343
/// Note that this pass's result cannot be invalidated, it is immutable for the
344
/// life of the module.
345
class TargetLibraryAnalysis : public AnalysisInfoMixin<TargetLibraryAnalysis> {
346
public:
347
  typedef TargetLibraryInfo Result;
348
349
  /// Default construct the library analysis.
350
  ///
351
  /// This will use the module's triple to construct the library info for that
352
  /// module.
353
1.94k
  TargetLibraryAnalysis() {}
354
355
  /// Construct a library analysis with preset info.
356
  ///
357
  /// This will directly copy the preset info into the result without
358
  /// consulting the module's triple.
359
  TargetLibraryAnalysis(TargetLibraryInfoImpl PresetInfoImpl)
360
68
      : PresetInfoImpl(std::move(PresetInfoImpl)) {}
361
362
  TargetLibraryInfo run(Module &M, ModuleAnalysisManager &);
363
  TargetLibraryInfo run(Function &F, FunctionAnalysisManager &);
364
365
private:
366
  friend AnalysisInfoMixin<TargetLibraryAnalysis>;
367
  static AnalysisKey Key;
368
369
  Optional<TargetLibraryInfoImpl> PresetInfoImpl;
370
371
  StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls;
372
373
  TargetLibraryInfoImpl &lookupInfoImpl(const Triple &T);
374
};
375
376
class TargetLibraryInfoWrapperPass : public ImmutablePass {
377
  TargetLibraryInfoImpl TLIImpl;
378
  TargetLibraryInfo TLI;
379
380
  virtual void anchor();
381
382
public:
383
  static char ID;
384
  TargetLibraryInfoWrapperPass();
385
  explicit TargetLibraryInfoWrapperPass(const Triple &T);
386
  explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfoImpl &TLI);
387
388
51.3M
  TargetLibraryInfo &getTLI() { return TLI; }
389
0
  const TargetLibraryInfo &getTLI() const { return TLI; }
390
};
391
392
} // end namespace llvm
393
394
#endif