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" 19 #include "llvm/ADT/StringRef.h" 20 #include "llvm/Analysis/TargetLibraryInfo.h" 21 #include "llvm/IR/IRBuilder.h" 22 23 namespace llvm { 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. 38 class FortifiedLibCallSimplifier { 39 private: 40 const TargetLibraryInfo *TLI; 41 bool OnlyLowerUnknownSize; 42 43 public: 44 FortifiedLibCallSimplifier(const TargetLibraryInfo *TLI, 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. 51 Value *optimizeCall(CallInst *CI); 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!")'. 71 class LibCallSimplifier { 72 private: 73 FortifiedLibCallSimplifier FortifiedSimplifier; 74 const DataLayout &DL; 75 const TargetLibraryInfo *TLI; 76 bool UnsafeFPShrink; 77 function_ref<void(Instruction *, Value *)> Replacer; 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. 100 Value *optimizeCall(CallInst *CI); 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 *optimizeUnaryDoubleFP(CallInst *CI, IRBuilder<> &B, bool CheckRetType); 129 Value *optimizeBinaryDoubleFP(CallInst *CI, IRBuilder<> &B); 130 Value *optimizeCos(CallInst *CI, IRBuilder<> &B); 131 Value *optimizePow(CallInst *CI, IRBuilder<> &B); 132 Value *optimizeExp2(CallInst *CI, IRBuilder<> &B); 133 Value *optimizeFabs(CallInst *CI, IRBuilder<> &B); 134 Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B); 135 Value *optimizeLog(CallInst *CI, IRBuilder<> &B); 136 Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B); 137 Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B); 138 Value *optimizeTan(CallInst *CI, IRBuilder<> &B); 139 140 // Integer Library Call Optimizations 141 Value *optimizeFFS(CallInst *CI, IRBuilder<> &B); 142 Value *optimizeAbs(CallInst *CI, IRBuilder<> &B); 143 Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B); 144 Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B); 145 Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B); 146 147 // Formatting and IO Library Call Optimizations 148 Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B, 149 int StreamArg = -1); 150 Value *optimizePrintF(CallInst *CI, IRBuilder<> &B); 151 Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B); 152 Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B); 153 Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B); 154 Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B); 155 Value *optimizePuts(CallInst *CI, IRBuilder<> &B); 156 157 // Helper methods 158 Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B); 159 void classifyArgUse(Value *Val, BasicBlock *BB, bool IsFloat, 160 SmallVectorImpl<CallInst *> &SinCalls, 161 SmallVectorImpl<CallInst *> &CosCalls, 162 SmallVectorImpl<CallInst *> &SinCosCalls); 163 void replaceTrigInsts(SmallVectorImpl<CallInst *> &Calls, Value *Res); 164 Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B); 165 Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B); 166 Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B); 167 168 /// hasFloatVersion - Checks if there is a float version of the specified 169 /// function by checking for an existing function with name FuncName + f 170 bool hasFloatVersion(StringRef FuncName); 171 }; 172 } // End llvm namespace 173 174 #endif 175