contrib/llvm/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 //===----------------------------------------------------------------------===//
  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 /// 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   /// 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   /// 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   /// 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   /// 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 *optimizeRealloc(CallInst *CI, IRBuilder<> &B);
 128   Value *optimizeWcslen(CallInst *CI, IRBuilder<> &B);
 129   // Wrapper for all String/Memory Library Call Optimizations
 130   Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
 131
 132   // Math Library Optimizations
 133   Value *optimizeCAbs(CallInst *CI, IRBuilder<> &B);
 134   Value *optimizeCos(CallInst *CI, IRBuilder<> &B);
 135   Value *optimizePow(CallInst *CI, IRBuilder<> &B);
 136   Value *replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B);
 137   Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
 138   Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B);
 139   Value *optimizeLog(CallInst *CI, IRBuilder<> &B);
 140   Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
 141   Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
 142   Value *optimizeTan(CallInst *CI, IRBuilder<> &B);
 143   // Wrapper for all floating point library call optimizations
 144   Value *optimizeFloatingPointLibCall(CallInst *CI, LibFunc Func,
 145                                       IRBuilder<> &B);
 146
 147   // Integer Library Call Optimizations
 148   Value *optimizeFFS(CallInst *CI, IRBuilder<> &B);
 149   Value *optimizeFls(CallInst *CI, IRBuilder<> &B);
 150   Value *optimizeAbs(CallInst *CI, IRBuilder<> &B);
 151   Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B);
 152   Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B);
 153   Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B);
 154   Value *optimizeAtoi(CallInst *CI, IRBuilder<> &B);
 155   Value *optimizeStrtol(CallInst *CI, IRBuilder<> &B);
 156
 157   // Formatting and IO Library Call Optimizations
 158   Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
 159                                 int StreamArg = -1);
 160   Value *optimizePrintF(CallInst *CI, IRBuilder<> &B);
 161   Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B);
 162   Value *optimizeSnPrintF(CallInst *CI, IRBuilder<> &B);
 163   Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B);
 164   Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B);
 165   Value *optimizeFRead(CallInst *CI, IRBuilder<> &B);
 166   Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B);
 167   Value *optimizeFGets(CallInst *CI, IRBuilder<> &B);
 168   Value *optimizeFPutc(CallInst *CI, IRBuilder<> &B);
 169   Value *optimizeFGetc(CallInst *CI, IRBuilder<> &B);
 170   Value *optimizePuts(CallInst *CI, IRBuilder<> &B);
 171
 172   // Helper methods
 173   Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B);
 174   void classifyArgUse(Value *Val, Function *F, bool IsFloat,
 175                       SmallVectorImpl<CallInst *> &SinCalls,
 176                       SmallVectorImpl<CallInst *> &CosCalls,
 177                       SmallVectorImpl<CallInst *> &SinCosCalls);
 178   Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B);
 179   Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B);
 180   Value *optimizeSnPrintFString(CallInst *CI, IRBuilder<> &B);
 181   Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B);
 182
 183   /// hasFloatVersion - Checks if there is a float version of the specified
 184   /// function by checking for an existing function with name FuncName + f
 185   bool hasFloatVersion(StringRef FuncName);
 186
 187   /// Shared code to optimize strlen+wcslen.
 188   Value *optimizeStringLength(CallInst *CI, IRBuilder<> &B, unsigned CharSize);
 189 };
 190 } // End llvm namespace
 191
 192 #endif