[PM] Replace an abuse of inheritance to override a single function with
[opencl/llvm.git] / include / llvm / Transforms / Utils / SimplifyLibCalls.h
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 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_TRANSFORMS_UTILS_SIMPLIFYLIBCALLS_H
16 #define LLVM_TRANSFORMS_UTILS_SIMPLIFYLIBCALLS_H
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/IR/IRBuilder.h"
21 namespace llvm {
22 class Value;
23 class CallInst;
24 class DataLayout;
25 class Instruction;
26 class TargetLibraryInfo;
27 class BasicBlock;
28 class Function;
30 /// \brief This class implements simplifications for calls to fortified library
31 /// functions (__st*cpy_chk, __memcpy_chk, __memmove_chk, __memset_chk), to,
32 /// when possible, replace them with their non-checking counterparts.
33 /// Other optimizations can also be done, but it's possible to disable them and
34 /// only simplify needless use of the checking versions (when the object size
35 /// is unknown) by passing true for OnlyLowerUnknownSize.
36 class FortifiedLibCallSimplifier {
37 private:
38   const DataLayout *DL;
39   const TargetLibraryInfo *TLI;
40   bool OnlyLowerUnknownSize;
42 public:
43   FortifiedLibCallSimplifier(const DataLayout *DL, const TargetLibraryInfo *TLI,
44                              bool OnlyLowerUnknownSize = false);
46   /// \brief Take the given call instruction and return a more
47   /// optimal value to replace the instruction with or 0 if a more
48   /// optimal form can't be found.
49   /// The call must not be an indirect call.
50   Value *optimizeCall(CallInst *CI);
52 private:
53   Value *optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B);
54   Value *optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B);
55   Value *optimizeMemSetChk(CallInst *CI, IRBuilder<> &B);
56   Value *optimizeStrCpyChk(CallInst *CI, IRBuilder<> &B);
57   Value *optimizeStrNCpyChk(CallInst *CI, IRBuilder<> &B);
59   /// \brief Checks whether the call \p CI to a fortified libcall is foldable
60   /// to the non-fortified version.
61   bool isFortifiedCallFoldable(CallInst *CI, unsigned ObjSizeOp,
62                                unsigned SizeOp, bool isString);
63 };
65 /// LibCallSimplifier - This class implements a collection of optimizations
66 /// that replace well formed calls to library functions with a more optimal
67 /// form.  For example, replacing 'printf("Hello!")' with 'puts("Hello!")'.
68 class LibCallSimplifier {
69 private:
70   FortifiedLibCallSimplifier FortifiedSimplifier;
71   const DataLayout *DL;
72   const TargetLibraryInfo *TLI;
73   bool UnsafeFPShrink;
74   function_ref<void(Instruction *, Value *)> Replacer;
76   /// \brief Internal wrapper for RAUW that is the default implementation.
77   ///
78   /// Other users may provide an alternate function with this signature instead
79   /// of this one.
80   static void replaceAllUsesWithDefault(Instruction *I, Value *With);
82   /// \brief Replace an instruction's uses with a value using our replacer.
83   void replaceAllUsesWith(Instruction *I, Value *With);
85 public:
86   LibCallSimplifier(const DataLayout *TD, const TargetLibraryInfo *TLI,
87                     function_ref<void(Instruction *, Value *)> Replacer =
88                         &replaceAllUsesWithDefault);
90   /// optimizeCall - Take the given call instruction and return a more
91   /// optimal value to replace the instruction with or 0 if a more
92   /// optimal form can't be found.  Note that the returned value may
93   /// be equal to the instruction being optimized.  In this case all
94   /// other instructions that use the given instruction were modified
95   /// and the given instruction is dead.
96   /// The call must not be an indirect call.
97   Value *optimizeCall(CallInst *CI);
99 private:
100   // String and Memory Library Call Optimizations
101   Value *optimizeStrCat(CallInst *CI, IRBuilder<> &B);
102   Value *optimizeStrNCat(CallInst *CI, IRBuilder<> &B);
103   Value *optimizeStrChr(CallInst *CI, IRBuilder<> &B);
104   Value *optimizeStrRChr(CallInst *CI, IRBuilder<> &B);
105   Value *optimizeStrCmp(CallInst *CI, IRBuilder<> &B);
106   Value *optimizeStrNCmp(CallInst *CI, IRBuilder<> &B);
107   Value *optimizeStrCpy(CallInst *CI, IRBuilder<> &B);
108   Value *optimizeStpCpy(CallInst *CI, IRBuilder<> &B);
109   Value *optimizeStrNCpy(CallInst *CI, IRBuilder<> &B);
110   Value *optimizeStrLen(CallInst *CI, IRBuilder<> &B);
111   Value *optimizeStrPBrk(CallInst *CI, IRBuilder<> &B);
112   Value *optimizeStrTo(CallInst *CI, IRBuilder<> &B);
113   Value *optimizeStrSpn(CallInst *CI, IRBuilder<> &B);
114   Value *optimizeStrCSpn(CallInst *CI, IRBuilder<> &B);
115   Value *optimizeStrStr(CallInst *CI, IRBuilder<> &B);
116   Value *optimizeMemCmp(CallInst *CI, IRBuilder<> &B);
117   Value *optimizeMemCpy(CallInst *CI, IRBuilder<> &B);
118   Value *optimizeMemMove(CallInst *CI, IRBuilder<> &B);
119   Value *optimizeMemSet(CallInst *CI, IRBuilder<> &B);
120   // Wrapper for all String/Memory Library Call Optimizations
121   Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
123   // Math Library Optimizations
124   Value *optimizeUnaryDoubleFP(CallInst *CI, IRBuilder<> &B, bool CheckRetType);
125   Value *optimizeBinaryDoubleFP(CallInst *CI, IRBuilder<> &B);
126   Value *optimizeCos(CallInst *CI, IRBuilder<> &B);
127   Value *optimizePow(CallInst *CI, IRBuilder<> &B);
128   Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
129   Value *optimizeFabs(CallInst *CI, IRBuilder<> &B);
130   Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
131   Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
133   // Integer Library Call Optimizations
134   Value *optimizeFFS(CallInst *CI, IRBuilder<> &B);
135   Value *optimizeAbs(CallInst *CI, IRBuilder<> &B);
136   Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B);
137   Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B);
138   Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B);
140   // Formatting and IO Library Call Optimizations
141   Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
142                                 int StreamArg = -1);
143   Value *optimizePrintF(CallInst *CI, IRBuilder<> &B);
144   Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B);
145   Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B);
146   Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B);
147   Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B);
148   Value *optimizePuts(CallInst *CI, IRBuilder<> &B);
150   // Helper methods
151   Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B);
152   void classifyArgUse(Value *Val, BasicBlock *BB, bool IsFloat,
153                       SmallVectorImpl<CallInst *> &SinCalls,
154                       SmallVectorImpl<CallInst *> &CosCalls,
155                       SmallVectorImpl<CallInst *> &SinCosCalls);
156   void replaceTrigInsts(SmallVectorImpl<CallInst *> &Calls, Value *Res);
157   Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B);
158   Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B);
159   Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B);
161   /// hasFloatVersion - Checks if there is a float version of the specified
162   /// function by checking for an existing function with name FuncName + f
163   bool hasFloatVersion(StringRef FuncName);
164 };
165 } // End llvm namespace
167 #endif