SimplifyLibCalls.h revision ebe69fe11e48d322045d5949c83283927a0d790b 
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/StringRef.h"
19#include "llvm/Analysis/TargetLibraryInfo.h"
20#include "llvm/IR/IRBuilder.h"
21
22namespace llvm {
23class Value;
24class CallInst;
25class DataLayout;
26class Instruction;
27class TargetLibraryInfo;
28class BasicBlock;
29class Function;
30
31/// \brief This class implements simplifications for calls to fortified library
32/// functions (__st*cpy_chk, __memcpy_chk, __memmove_chk, __memset_chk), to,
33/// when possible, replace them with their non-checking counterparts.
34/// Other optimizations can also be done, but it's possible to disable them and
35/// only simplify needless use of the checking versions (when the object size
36/// is unknown) by passing true for OnlyLowerUnknownSize.
37class FortifiedLibCallSimplifier {
38private:
39  const DataLayout *DL;
40  const TargetLibraryInfo *TLI;
41  bool OnlyLowerUnknownSize;
42
43public:
44  FortifiedLibCallSimplifier(const DataLayout *DL, 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
53private:
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!")'.
71class LibCallSimplifier {
72private:
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
88public:
89  LibCallSimplifier(const DataLayout *TD, 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
102private:
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 *optimizeMemCmp(CallInst *CI, IRBuilder<> &B);
120  Value *optimizeMemCpy(CallInst *CI, IRBuilder<> &B);
121  Value *optimizeMemMove(CallInst *CI, IRBuilder<> &B);
122  Value *optimizeMemSet(CallInst *CI, IRBuilder<> &B);
123  // Wrapper for all String/Memory Library Call Optimizations
124  Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
125
126  // Math Library Optimizations
127  Value *optimizeUnaryDoubleFP(CallInst *CI, IRBuilder<> &B, bool CheckRetType);
128  Value *optimizeBinaryDoubleFP(CallInst *CI, IRBuilder<> &B);
129  Value *optimizeCos(CallInst *CI, IRBuilder<> &B);
130  Value *optimizePow(CallInst *CI, IRBuilder<> &B);
131  Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
132  Value *optimizeFabs(CallInst *CI, IRBuilder<> &B);
133  Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
134  Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
135
136  // Integer Library Call Optimizations
137  Value *optimizeFFS(CallInst *CI, IRBuilder<> &B);
138  Value *optimizeAbs(CallInst *CI, IRBuilder<> &B);
139  Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B);
140  Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B);
141  Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B);
142
143  // Formatting and IO Library Call Optimizations
144  Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
145                                int StreamArg = -1);
146  Value *optimizePrintF(CallInst *CI, IRBuilder<> &B);
147  Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B);
148  Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B);
149  Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B);
150  Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B);
151  Value *optimizePuts(CallInst *CI, IRBuilder<> &B);
152
153  // Helper methods
154  Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B);
155  void classifyArgUse(Value *Val, BasicBlock *BB, bool IsFloat,
156                      SmallVectorImpl<CallInst *> &SinCalls,
157                      SmallVectorImpl<CallInst *> &CosCalls,
158                      SmallVectorImpl<CallInst *> &SinCosCalls);
159  void replaceTrigInsts(SmallVectorImpl<CallInst *> &Calls, Value *Res);
160  Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B);
161  Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B);
162  Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B);
163
164  /// hasFloatVersion - Checks if there is a float version of the specified
165  /// function by checking for an existing function with name FuncName + f
166  bool hasFloatVersion(StringRef FuncName);
167};
168} // End llvm namespace
169
170#endif
171