SimplifyLibCalls.h revision f3ef5332fa3f4d5ec72c178a2b19dac363a19383 
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
23namespace llvm {
24class Value;
25class CallInst;
26class DataLayout;
27class Instruction;
28class TargetLibraryInfo;
29class BasicBlock;
30class 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.
38class FortifiedLibCallSimplifier {
39private:
40  const TargetLibraryInfo *TLI;
41  bool OnlyLowerUnknownSize;
42
43public:
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
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 &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
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 *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