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/Analysis/TargetLibraryInfo.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 class OptimizationRemarkEmitter; 32 33 /// \brief This class implements simplifications for calls to fortified library 34 /// functions (__st*cpy_chk, __memcpy_chk, __memmove_chk, __memset_chk), to, 35 /// when possible, replace them with their non-checking counterparts. 36 /// Other optimizations can also be done, but it's possible to disable them and 37 /// only simplify needless use of the checking versions (when the object size 38 /// is unknown) by passing true for OnlyLowerUnknownSize. 39 class FortifiedLibCallSimplifier { 40 private: 41 const TargetLibraryInfo *TLI; 42 bool OnlyLowerUnknownSize; 43 44 public: 45 FortifiedLibCallSimplifier(const TargetLibraryInfo *TLI, 46 bool OnlyLowerUnknownSize = false); 47 48 /// \brief Take the given call instruction and return a more 49 /// optimal value to replace the instruction with or 0 if a more 50 /// optimal form can't be found. 51 /// The call must not be an indirect call. 52 Value *optimizeCall(CallInst *CI); 53 54 private: 55 Value *optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B); 56 Value *optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B); 57 Value *optimizeMemSetChk(CallInst *CI, IRBuilder<> &B); 58 59 // Str/Stp cpy are similar enough to be handled in the same functions. 60 Value *optimizeStrpCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func); 61 Value *optimizeStrpNCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func); 62 63 /// \brief Checks whether the call \p CI to a fortified libcall is foldable 64 /// to the non-fortified version. 65 bool isFortifiedCallFoldable(CallInst *CI, unsigned ObjSizeOp, 66 unsigned SizeOp, bool isString); 67 }; 68 69 /// LibCallSimplifier - This class implements a collection of optimizations 70 /// that replace well formed calls to library functions with a more optimal 71 /// form. For example, replacing 'printf("Hello!")' with 'puts("Hello!")'. 72 class LibCallSimplifier { 73 private: 74 FortifiedLibCallSimplifier FortifiedSimplifier; 75 const DataLayout &DL; 76 const TargetLibraryInfo *TLI; 77 OptimizationRemarkEmitter &ORE; 78 bool UnsafeFPShrink; 79 function_ref<void(Instruction *, Value *)> Replacer; 80 81 /// \brief Internal wrapper for RAUW that is the default implementation. 82 /// 83 /// Other users may provide an alternate function with this signature instead 84 /// of this one. 85 static void replaceAllUsesWithDefault(Instruction *I, Value *With); 86 87 /// \brief Replace an instruction's uses with a value using our replacer. 88 void replaceAllUsesWith(Instruction *I, Value *With); 89 90 public: 91 LibCallSimplifier(const DataLayout &DL, const TargetLibraryInfo *TLI, 92 OptimizationRemarkEmitter &ORE, 93 function_ref<void(Instruction *, Value *)> Replacer = 94 &replaceAllUsesWithDefault); 95 96 /// optimizeCall - Take the given call instruction and return a more 97 /// optimal value to replace the instruction with or 0 if a more 98 /// optimal form can't be found. Note that the returned value may 99 /// be equal to the instruction being optimized. In this case all 100 /// other instructions that use the given instruction were modified 101 /// and the given instruction is dead. 102 /// The call must not be an indirect call. 103 Value *optimizeCall(CallInst *CI); 104 105 private: 106 // String and Memory Library Call Optimizations 107 Value *optimizeStrCat(CallInst *CI, IRBuilder<> &B); 108 Value *optimizeStrNCat(CallInst *CI, IRBuilder<> &B); 109 Value *optimizeStrChr(CallInst *CI, IRBuilder<> &B); 110 Value *optimizeStrRChr(CallInst *CI, IRBuilder<> &B); 111 Value *optimizeStrCmp(CallInst *CI, IRBuilder<> &B); 112 Value *optimizeStrNCmp(CallInst *CI, IRBuilder<> &B); 113 Value *optimizeStrCpy(CallInst *CI, IRBuilder<> &B); 114 Value *optimizeStpCpy(CallInst *CI, IRBuilder<> &B); 115 Value *optimizeStrNCpy(CallInst *CI, IRBuilder<> &B); 116 Value *optimizeStrLen(CallInst *CI, IRBuilder<> &B); 117 Value *optimizeStrPBrk(CallInst *CI, IRBuilder<> &B); 118 Value *optimizeStrTo(CallInst *CI, IRBuilder<> &B); 119 Value *optimizeStrSpn(CallInst *CI, IRBuilder<> &B); 120 Value *optimizeStrCSpn(CallInst *CI, IRBuilder<> &B); 121 Value *optimizeStrStr(CallInst *CI, IRBuilder<> &B); 122 Value *optimizeMemChr(CallInst *CI, IRBuilder<> &B); 123 Value *optimizeMemCmp(CallInst *CI, IRBuilder<> &B); 124 Value *optimizeMemCpy(CallInst *CI, IRBuilder<> &B); 125 Value *optimizeMemMove(CallInst *CI, IRBuilder<> &B); 126 Value *optimizeMemSet(CallInst *CI, IRBuilder<> &B); 127 Value *optimizeWcslen(CallInst *CI, IRBuilder<> &B); 128 // Wrapper for all String/Memory Library Call Optimizations 129 Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B); 130 131 // Math Library Optimizations 132 Value *optimizeCos(CallInst *CI, IRBuilder<> &B); 133 Value *optimizePow(CallInst *CI, IRBuilder<> &B); 134 Value *optimizeExp2(CallInst *CI, IRBuilder<> &B); 135 Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B); 136 Value *optimizeLog(CallInst *CI, IRBuilder<> &B); 137 Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B); 138 Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B); 139 Value *optimizeTan(CallInst *CI, IRBuilder<> &B); 140 // Wrapper for all floating point library call optimizations 141 Value *optimizeFloatingPointLibCall(CallInst *CI, LibFunc Func, 142 IRBuilder<> &B); 143 144 // Integer Library Call Optimizations 145 Value *optimizeFFS(CallInst *CI, IRBuilder<> &B); 146 Value *optimizeFls(CallInst *CI, IRBuilder<> &B); 147 Value *optimizeAbs(CallInst *CI, IRBuilder<> &B); 148 Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B); 149 Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B); 150 Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B); 151 152 // Formatting and IO Library Call Optimizations 153 Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B, 154 int StreamArg = -1); 155 Value *optimizePrintF(CallInst *CI, IRBuilder<> &B); 156 Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B); 157 Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B); 158 Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B); 159 Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B); 160 Value *optimizePuts(CallInst *CI, IRBuilder<> &B); 161 162 // Helper methods 163 Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B); 164 void classifyArgUse(Value *Val, Function *F, bool IsFloat, 165 SmallVectorImpl<CallInst *> &SinCalls, 166 SmallVectorImpl<CallInst *> &CosCalls, 167 SmallVectorImpl<CallInst *> &SinCosCalls); 168 Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B); 169 Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B); 170 Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B); 171 172 /// hasFloatVersion - Checks if there is a float version of the specified 173 /// function by checking for an existing function with name FuncName + f 174 bool hasFloatVersion(StringRef FuncName); 175 176 /// Shared code to optimize strlen+wcslen. 177 Value *optimizeStringLength(CallInst *CI, IRBuilder<> &B, unsigned CharSize); 178 }; 179 } // End llvm namespace 180 181 #endif 182
