include/llvm/Transforms/Utils/SimplifyLibCalls.h

   1 //===- SimplifyLibCalls.h - Library call simplifier -------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file exposes an interface to build some C language libcalls for
  10 // optimization passes that need to call the various functions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_TRANSFORMS_UTILS_SIMPLIFYLIBCALLS_H
  15 #define LLVM_TRANSFORMS_UTILS_SIMPLIFYLIBCALLS_H
  16
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/Analysis/TargetLibraryInfo.h"
  19 #include "llvm/IR/IRBuilder.h"
  20
  21 namespace llvm {
  22 class StringRef;
  23 class Value;
  24 class CallInst;
  25 class DataLayout;
  26 class Instruction;
  27 class TargetLibraryInfo;
  28 class BasicBlock;
  29 class Function;
  30 class OptimizationRemarkEmitter;
  31 class BlockFrequencyInfo;
  32 class ProfileSummaryInfo;
  33
  34 /// This class implements simplifications for calls to fortified library
  35 /// functions (__st*cpy_chk, __memcpy_chk, __memmove_chk, __memset_chk), to,
  36 /// when possible, replace them with their non-checking counterparts.
  37 /// Other optimizations can also be done, but it's possible to disable them and
  38 /// only simplify needless use of the checking versions (when the object size
  39 /// is unknown) by passing true for OnlyLowerUnknownSize.
  40 class FortifiedLibCallSimplifier {
  41 private:
  42   const TargetLibraryInfo *TLI;
  43   bool OnlyLowerUnknownSize;
  44
  45 public:
  46   FortifiedLibCallSimplifier(const TargetLibraryInfo *TLI,
  47                              bool OnlyLowerUnknownSize = false);
  48
  49   /// Take the given call instruction and return a more
  50   /// optimal value to replace the instruction with or 0 if a more
  51   /// optimal form can't be found.
  52   /// The call must not be an indirect call.
  53   Value *optimizeCall(CallInst *CI);
  54
  55 private:
  56   Value *optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B);
  57   Value *optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B);
  58   Value *optimizeMemSetChk(CallInst *CI, IRBuilder<> &B);
  59
  60   /// Str/Stp cpy are similar enough to be handled in the same functions.
  61   Value *optimizeStrpCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
  62   Value *optimizeStrpNCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
  63   Value *optimizeMemCCpyChk(CallInst *CI, IRBuilder<> &B);
  64   Value *optimizeSNPrintfChk(CallInst *CI, IRBuilder<> &B);
  65   Value *optimizeSPrintfChk(CallInst *CI,IRBuilder<> &B);
  66   Value *optimizeStrCatChk(CallInst *CI, IRBuilder<> &B);
  67   Value *optimizeStrLCat(CallInst *CI, IRBuilder<> &B);
  68   Value *optimizeStrNCatChk(CallInst *CI, IRBuilder<> &B);
  69   Value *optimizeStrLCpyChk(CallInst *CI, IRBuilder<> &B);
  70   Value *optimizeVSNPrintfChk(CallInst *CI, IRBuilder<> &B);
  71   Value *optimizeVSPrintfChk(CallInst *CI, IRBuilder<> &B);
  72
  73   /// Checks whether the call \p CI to a fortified libcall is foldable
  74   /// to the non-fortified version.
  75   ///
  76   /// \param CI the call to the fortified libcall.
  77   ///
  78   /// \param ObjSizeOp the index of the object size parameter of this chk
  79   /// function. Not optional since this is mandatory.
  80   ///
  81   /// \param SizeOp optionally set to the parameter index of an explicit buffer
  82   /// size argument. For instance, set to '2' for __strncpy_chk.
  83   ///
  84   /// \param StrOp optionally set to the parameter index of the source string
  85   /// parameter to strcpy-like functions, where only the strlen of the source
  86   /// will be writtin into the destination.
  87   ///
  88   /// \param FlagsOp optionally set to the parameter index of a 'flags'
  89   /// parameter. These are used by an implementation to opt-into stricter
  90   /// checking.
  91   bool isFortifiedCallFoldable(CallInst *CI, unsigned ObjSizeOp,
  92                                Optional<unsigned> SizeOp = None,
  93                                Optional<unsigned> StrOp = None,
  94                                Optional<unsigned> FlagsOp = None);
  95 };
  96
  97 /// LibCallSimplifier - This class implements a collection of optimizations
  98 /// that replace well formed calls to library functions with a more optimal
  99 /// form.  For example, replacing 'printf("Hello!")' with 'puts("Hello!")'.
 100 class LibCallSimplifier {
 101 private:
 102   FortifiedLibCallSimplifier FortifiedSimplifier;
 103   const DataLayout &DL;
 104   const TargetLibraryInfo *TLI;
 105   OptimizationRemarkEmitter &ORE;
 106   BlockFrequencyInfo *BFI;
 107   ProfileSummaryInfo *PSI;
 108   bool UnsafeFPShrink;
 109   function_ref<void(Instruction *, Value *)> Replacer;
 110   function_ref<void(Instruction *)> Eraser;
 111
 112   /// Internal wrapper for RAUW that is the default implementation.
 113   ///
 114   /// Other users may provide an alternate function with this signature instead
 115   /// of this one.
 116   static void replaceAllUsesWithDefault(Instruction *I, Value *With) {
 117     I->replaceAllUsesWith(With);
 118   }
 119
 120   /// Internal wrapper for eraseFromParent that is the default implementation.
 121   static void eraseFromParentDefault(Instruction *I) { I->eraseFromParent(); }
 122
 123   /// Replace an instruction's uses with a value using our replacer.
 124   void replaceAllUsesWith(Instruction *I, Value *With);
 125
 126   /// Erase an instruction from its parent with our eraser.
 127   void eraseFromParent(Instruction *I);
 128
 129   /// Replace an instruction with a value and erase it from its parent.
 130   void substituteInParent(Instruction *I, Value *With) {
 131     replaceAllUsesWith(I, With);
 132     eraseFromParent(I);
 133   }
 134
 135   Value *foldMallocMemset(CallInst *Memset, IRBuilder<> &B);
 136
 137 public:
 138   LibCallSimplifier(
 139       const DataLayout &DL, const TargetLibraryInfo *TLI,
 140       OptimizationRemarkEmitter &ORE,
 141       BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI,
 142       function_ref<void(Instruction *, Value *)> Replacer =
 143           &replaceAllUsesWithDefault,
 144       function_ref<void(Instruction *)> Eraser = &eraseFromParentDefault);
 145
 146   /// optimizeCall - Take the given call instruction and return a more
 147   /// optimal value to replace the instruction with or 0 if a more
 148   /// optimal form can't be found.  Note that the returned value may
 149   /// be equal to the instruction being optimized.  In this case all
 150   /// other instructions that use the given instruction were modified
 151   /// and the given instruction is dead.
 152   /// The call must not be an indirect call.
 153   Value *optimizeCall(CallInst *CI);
 154
 155 private:
 156   // String and Memory Library Call Optimizations
 157   Value *optimizeStrCat(CallInst *CI, IRBuilder<> &B);
 158   Value *optimizeStrNCat(CallInst *CI, IRBuilder<> &B);
 159   Value *optimizeStrChr(CallInst *CI, IRBuilder<> &B);
 160   Value *optimizeStrRChr(CallInst *CI, IRBuilder<> &B);
 161   Value *optimizeStrCmp(CallInst *CI, IRBuilder<> &B);
 162   Value *optimizeStrNCmp(CallInst *CI, IRBuilder<> &B);
 163   Value *optimizeStrNDup(CallInst *CI, IRBuilder<> &B);
 164   Value *optimizeStrCpy(CallInst *CI, IRBuilder<> &B);
 165   Value *optimizeStpCpy(CallInst *CI, IRBuilder<> &B);
 166   Value *optimizeStrNCpy(CallInst *CI, IRBuilder<> &B);
 167   Value *optimizeStrLen(CallInst *CI, IRBuilder<> &B);
 168   Value *optimizeStrPBrk(CallInst *CI, IRBuilder<> &B);
 169   Value *optimizeStrTo(CallInst *CI, IRBuilder<> &B);
 170   Value *optimizeStrSpn(CallInst *CI, IRBuilder<> &B);
 171   Value *optimizeStrCSpn(CallInst *CI, IRBuilder<> &B);
 172   Value *optimizeStrStr(CallInst *CI, IRBuilder<> &B);
 173   Value *optimizeMemChr(CallInst *CI, IRBuilder<> &B);
 174   Value *optimizeMemRChr(CallInst *CI, IRBuilder<> &B);
 175   Value *optimizeMemCmp(CallInst *CI, IRBuilder<> &B);
 176   Value *optimizeBCmp(CallInst *CI, IRBuilder<> &B);
 177   Value *optimizeMemCmpBCmpCommon(CallInst *CI, IRBuilder<> &B);
 178   Value *optimizeMemPCpy(CallInst *CI, IRBuilder<> &B);
 179   Value *optimizeMemCpy(CallInst *CI, IRBuilder<> &B);
 180   Value *optimizeMemMove(CallInst *CI, IRBuilder<> &B);
 181   Value *optimizeMemSet(CallInst *CI, IRBuilder<> &B);
 182   Value *optimizeRealloc(CallInst *CI, IRBuilder<> &B);
 183   Value *optimizeWcslen(CallInst *CI, IRBuilder<> &B);
 184   Value *optimizeBCopy(CallInst *CI, IRBuilder<> &B);
 185   // Wrapper for all String/Memory Library Call Optimizations
 186   Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
 187
 188   // Math Library Optimizations
 189   Value *optimizeCAbs(CallInst *CI, IRBuilder<> &B);
 190   Value *optimizePow(CallInst *CI, IRBuilder<> &B);
 191   Value *replacePowWithExp(CallInst *Pow, IRBuilder<> &B);
 192   Value *replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B);
 193   Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
 194   Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B);
 195   Value *optimizeLog(CallInst *CI, IRBuilder<> &B);
 196   Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
 197   Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
 198   Value *optimizeTan(CallInst *CI, IRBuilder<> &B);
 199   // Wrapper for all floating point library call optimizations
 200   Value *optimizeFloatingPointLibCall(CallInst *CI, LibFunc Func,
 201                                       IRBuilder<> &B);
 202
 203   // Integer Library Call Optimizations
 204   Value *optimizeFFS(CallInst *CI, IRBuilder<> &B);
 205   Value *optimizeFls(CallInst *CI, IRBuilder<> &B);
 206   Value *optimizeAbs(CallInst *CI, IRBuilder<> &B);
 207   Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B);
 208   Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B);
 209   Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B);
 210   Value *optimizeAtoi(CallInst *CI, IRBuilder<> &B);
 211   Value *optimizeStrtol(CallInst *CI, IRBuilder<> &B);
 212
 213   // Formatting and IO Library Call Optimizations
 214   Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
 215                                 int StreamArg = -1);
 216   Value *optimizePrintF(CallInst *CI, IRBuilder<> &B);
 217   Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B);
 218   Value *optimizeSnPrintF(CallInst *CI, IRBuilder<> &B);
 219   Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B);
 220   Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B);
 221   Value *optimizeFRead(CallInst *CI, IRBuilder<> &B);
 222   Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B);
 223   Value *optimizeFGets(CallInst *CI, IRBuilder<> &B);
 224   Value *optimizeFPutc(CallInst *CI, IRBuilder<> &B);
 225   Value *optimizeFGetc(CallInst *CI, IRBuilder<> &B);
 226   Value *optimizePuts(CallInst *CI, IRBuilder<> &B);
 227
 228   // Helper methods
 229   Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B);
 230   void classifyArgUse(Value *Val, Function *F, bool IsFloat,
 231                       SmallVectorImpl<CallInst *> &SinCalls,
 232                       SmallVectorImpl<CallInst *> &CosCalls,
 233                       SmallVectorImpl<CallInst *> &SinCosCalls);
 234   Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B);
 235   Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B);
 236   Value *optimizeSnPrintFString(CallInst *CI, IRBuilder<> &B);
 237   Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B);
 238
 239   /// hasFloatVersion - Checks if there is a float version of the specified
 240   /// function by checking for an existing function with name FuncName + f
 241   bool hasFloatVersion(StringRef FuncName);
 242
 243   /// Shared code to optimize strlen+wcslen.
 244   Value *optimizeStringLength(CallInst *CI, IRBuilder<> &B, unsigned CharSize);
 245 };
 246 } // End llvm namespace
 247
 248 #endif