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
22namespace llvm {
23class StringRef;
24class Value;
25class CallInst;
26class DataLayout;
27class Instruction;
28class TargetLibraryInfo;
29class BasicBlock;
30class Function;
31class 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.
39class FortifiedLibCallSimplifier {
40private:
41  const TargetLibraryInfo *TLI;
42  bool OnlyLowerUnknownSize;
43
44public:
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
54private:
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!")'.
72class LibCallSimplifier {
73private:
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
90public:
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
105private:
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