LLVM  4.0.0
SimplifyLibCalls.h
Go to the documentation of this file.
1 //===- SimplifyLibCalls.h - Library call simplifier -------------*- 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 // This file exposes an interface to build some C language libcalls for
11 // optimization passes that need to call the various functions.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_TRANSFORMS_UTILS_SIMPLIFYLIBCALLS_H
16 #define LLVM_TRANSFORMS_UTILS_SIMPLIFYLIBCALLS_H
17 
18 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/IR/IRBuilder.h"
21 
22 namespace llvm {
23 class StringRef;
24 class Value;
25 class CallInst;
26 class DataLayout;
27 class Instruction;
28 class TargetLibraryInfo;
29 class BasicBlock;
30 class Function;
31 
32 /// \brief This class implements simplifications for calls to fortified library
33 /// functions (__st*cpy_chk, __memcpy_chk, __memmove_chk, __memset_chk), to,
34 /// when possible, replace them with their non-checking counterparts.
35 /// Other optimizations can also be done, but it's possible to disable them and
36 /// only simplify needless use of the checking versions (when the object size
37 /// is unknown) by passing true for OnlyLowerUnknownSize.
39 private:
40  const TargetLibraryInfo *TLI;
41  bool OnlyLowerUnknownSize;
42 
43 public:
45  bool OnlyLowerUnknownSize = false);
46 
47  /// \brief Take the given call instruction and return a more
48  /// optimal value to replace the instruction with or 0 if a more
49  /// optimal form can't be found.
50  /// The call must not be an indirect call.
52 
53 private:
54  Value *optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B);
55  Value *optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B);
56  Value *optimizeMemSetChk(CallInst *CI, IRBuilder<> &B);
57 
58  // Str/Stp cpy are similar enough to be handled in the same functions.
59  Value *optimizeStrpCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc::Func Func);
60  Value *optimizeStrpNCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc::Func Func);
61 
62  /// \brief Checks whether the call \p CI to a fortified libcall is foldable
63  /// to the non-fortified version.
64  bool isFortifiedCallFoldable(CallInst *CI, unsigned ObjSizeOp,
65  unsigned SizeOp, bool isString);
66 };
67 
68 /// LibCallSimplifier - This class implements a collection of optimizations
69 /// that replace well formed calls to library functions with a more optimal
70 /// form. For example, replacing 'printf("Hello!")' with 'puts("Hello!")'.
72 private:
73  FortifiedLibCallSimplifier FortifiedSimplifier;
74  const DataLayout &DL;
75  const TargetLibraryInfo *TLI;
76  bool UnsafeFPShrink;
78 
79  /// \brief Internal wrapper for RAUW that is the default implementation.
80  ///
81  /// Other users may provide an alternate function with this signature instead
82  /// of this one.
83  static void replaceAllUsesWithDefault(Instruction *I, Value *With);
84 
85  /// \brief Replace an instruction's uses with a value using our replacer.
86  void replaceAllUsesWith(Instruction *I, Value *With);
87 
88 public:
89  LibCallSimplifier(const DataLayout &DL, const TargetLibraryInfo *TLI,
90  function_ref<void(Instruction *, Value *)> Replacer =
91  &replaceAllUsesWithDefault);
92 
93  /// optimizeCall - Take the given call instruction and return a more
94  /// optimal value to replace the instruction with or 0 if a more
95  /// optimal form can't be found. Note that the returned value may
96  /// be equal to the instruction being optimized. In this case all
97  /// other instructions that use the given instruction were modified
98  /// and the given instruction is dead.
99  /// The call must not be an indirect call.
101 
102 private:
103  // String and Memory Library Call Optimizations
104  Value *optimizeStrCat(CallInst *CI, IRBuilder<> &B);
105  Value *optimizeStrNCat(CallInst *CI, IRBuilder<> &B);
106  Value *optimizeStrChr(CallInst *CI, IRBuilder<> &B);
107  Value *optimizeStrRChr(CallInst *CI, IRBuilder<> &B);
108  Value *optimizeStrCmp(CallInst *CI, IRBuilder<> &B);
109  Value *optimizeStrNCmp(CallInst *CI, IRBuilder<> &B);
110  Value *optimizeStrCpy(CallInst *CI, IRBuilder<> &B);
111  Value *optimizeStpCpy(CallInst *CI, IRBuilder<> &B);
112  Value *optimizeStrNCpy(CallInst *CI, IRBuilder<> &B);
113  Value *optimizeStrLen(CallInst *CI, IRBuilder<> &B);
114  Value *optimizeStrPBrk(CallInst *CI, IRBuilder<> &B);
115  Value *optimizeStrTo(CallInst *CI, IRBuilder<> &B);
116  Value *optimizeStrSpn(CallInst *CI, IRBuilder<> &B);
117  Value *optimizeStrCSpn(CallInst *CI, IRBuilder<> &B);
118  Value *optimizeStrStr(CallInst *CI, IRBuilder<> &B);
119  Value *optimizeMemChr(CallInst *CI, IRBuilder<> &B);
120  Value *optimizeMemCmp(CallInst *CI, IRBuilder<> &B);
121  Value *optimizeMemCpy(CallInst *CI, IRBuilder<> &B);
122  Value *optimizeMemMove(CallInst *CI, IRBuilder<> &B);
123  Value *optimizeMemSet(CallInst *CI, IRBuilder<> &B);
124  // Wrapper for all String/Memory Library Call Optimizations
125  Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
126 
127  // Math Library Optimizations
128  Value *optimizeCos(CallInst *CI, IRBuilder<> &B);
129  Value *optimizePow(CallInst *CI, IRBuilder<> &B);
130  Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
131  Value *optimizeFabs(CallInst *CI, IRBuilder<> &B);
132  Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B);
133  Value *optimizeLog(CallInst *CI, IRBuilder<> &B);
134  Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
135  Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
136  Value *optimizeTan(CallInst *CI, IRBuilder<> &B);
137 
138  // Integer Library Call Optimizations
139  Value *optimizeFFS(CallInst *CI, IRBuilder<> &B);
140  Value *optimizeFls(CallInst *CI, IRBuilder<> &B);
141  Value *optimizeAbs(CallInst *CI, IRBuilder<> &B);
142  Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B);
143  Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B);
144  Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B);
145 
146  // Formatting and IO Library Call Optimizations
147  Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
148  int StreamArg = -1);
149  Value *optimizePrintF(CallInst *CI, IRBuilder<> &B);
150  Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B);
151  Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B);
152  Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B);
153  Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B);
154  Value *optimizePuts(CallInst *CI, IRBuilder<> &B);
155 
156  // Helper methods
157  Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B);
158  void classifyArgUse(Value *Val, Function *F, bool IsFloat,
159  SmallVectorImpl<CallInst *> &SinCalls,
160  SmallVectorImpl<CallInst *> &CosCalls,
161  SmallVectorImpl<CallInst *> &SinCosCalls);
162  Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B);
163  Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B);
164  Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B);
165 
166  /// hasFloatVersion - Checks if there is a float version of the specified
167  /// function by checking for an existing function with name FuncName + f
168  bool hasFloatVersion(StringRef FuncName);
169 };
170 } // End llvm namespace
171 
172 #endif
LibCallSimplifier - This class implements a collection of optimizations that replace well formed call...
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
Various leaf nodes.
Definition: ISDOpcodes.h:60
Value * optimizeCall(CallInst *CI)
Take the given call instruction and return a more optimal value to replace the instruction with or 0 ...
This class represents a function call, abstracting a target machine's calling convention.
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:83
FortifiedLibCallSimplifier(const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize=false)
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:588
#define F(x, y, z)
Definition: MD5.cpp:51
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
This class implements simplifications for calls to fortified library functions (__st*cpy_chk, __memcpy_chk, __memmove_chk, __memset_chk), to, when possible, replace them with their non-checking counterparts.
Provides information about what library functions are available for the current target.
#define I(x, y, z)
Definition: MD5.cpp:54
Value * optimizeCall(CallInst *CI)
optimizeCall - Take the given call instruction and return a more optimal value to replace the instruc...
LLVM Value Representation.
Definition: Value.h:71
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
LibCallSimplifier(const DataLayout &DL, const TargetLibraryInfo *TLI, function_ref< void(Instruction *, Value *)> Replacer=&replaceAllUsesWithDefault)