1 //===------ SimplifyLibCalls.cpp - Library calls simplifier ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This is a utility pass used for testing the InstructionSimplify analysis.
11 // The analysis is applied to every instruction, and if it simplifies then the
12 // instruction is replaced by the simplification. If you are looking for a pass
13 // that performs serious instruction folding, use the instcombine pass instead.
15 //===----------------------------------------------------------------------===//
17 #include "llvm/Transforms/Utils/SimplifyLibCalls.h"
18 #include "llvm/DataLayout.h"
19 #include "llvm/ADT/StringMap.h"
20 #include "llvm/Analysis/ValueTracking.h"
21 #include "llvm/Function.h"
22 #include "llvm/IRBuilder.h"
23 #include "llvm/LLVMContext.h"
24 #include "llvm/Target/TargetLibraryInfo.h"
25 #include "llvm/Transforms/Utils/BuildLibCalls.h"
29 /// This class is the abstract base class for the set of optimizations that
30 /// corresponds to one library call.
32 class LibCallOptimization {
36 const TargetLibraryInfo *TLI;
39 LibCallOptimization() { }
40 virtual ~LibCallOptimization() {}
42 /// callOptimizer - This pure virtual method is implemented by base classes to
43 /// do various optimizations. If this returns null then no transformation was
44 /// performed. If it returns CI, then it transformed the call and CI is to be
45 /// deleted. If it returns something else, replace CI with the new value and
47 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B)
50 Value *optimizeCall(CallInst *CI, const DataLayout *TD,
51 const TargetLibraryInfo *TLI, IRBuilder<> &B) {
52 Caller = CI->getParent()->getParent();
55 if (CI->getCalledFunction())
56 Context = &CI->getCalledFunction()->getContext();
58 // We never change the calling convention.
59 if (CI->getCallingConv() != llvm::CallingConv::C)
62 return callOptimizer(CI->getCalledFunction(), CI, B);
66 //===----------------------------------------------------------------------===//
67 // Fortified Library Call Optimizations
68 //===----------------------------------------------------------------------===//
70 struct FortifiedLibCallOptimization : public LibCallOptimization {
72 virtual bool isFoldable(unsigned SizeCIOp, unsigned SizeArgOp,
73 bool isString) const = 0;
76 struct InstFortifiedLibCallOptimization : public FortifiedLibCallOptimization {
79 bool isFoldable(unsigned SizeCIOp, unsigned SizeArgOp, bool isString) const {
80 if (CI->getArgOperand(SizeCIOp) == CI->getArgOperand(SizeArgOp))
82 if (ConstantInt *SizeCI =
83 dyn_cast<ConstantInt>(CI->getArgOperand(SizeCIOp))) {
84 if (SizeCI->isAllOnesValue())
87 uint64_t Len = GetStringLength(CI->getArgOperand(SizeArgOp));
88 // If the length is 0 we don't know how long it is and so we can't
90 if (Len == 0) return false;
91 return SizeCI->getZExtValue() >= Len;
93 if (ConstantInt *Arg = dyn_cast<ConstantInt>(
94 CI->getArgOperand(SizeArgOp)))
95 return SizeCI->getZExtValue() >= Arg->getZExtValue();
101 struct MemCpyChkOpt : public InstFortifiedLibCallOptimization {
102 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
104 FunctionType *FT = Callee->getFunctionType();
105 LLVMContext &Context = CI->getParent()->getContext();
107 // Check if this has the right signature.
108 if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
109 !FT->getParamType(0)->isPointerTy() ||
110 !FT->getParamType(1)->isPointerTy() ||
111 FT->getParamType(2) != TD->getIntPtrType(Context) ||
112 FT->getParamType(3) != TD->getIntPtrType(Context))
115 if (isFoldable(3, 2, false)) {
116 B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
117 CI->getArgOperand(2), 1);
118 return CI->getArgOperand(0);
124 struct MemMoveChkOpt : public InstFortifiedLibCallOptimization {
125 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
127 FunctionType *FT = Callee->getFunctionType();
128 LLVMContext &Context = CI->getParent()->getContext();
130 // Check if this has the right signature.
131 if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
132 !FT->getParamType(0)->isPointerTy() ||
133 !FT->getParamType(1)->isPointerTy() ||
134 FT->getParamType(2) != TD->getIntPtrType(Context) ||
135 FT->getParamType(3) != TD->getIntPtrType(Context))
138 if (isFoldable(3, 2, false)) {
139 B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
140 CI->getArgOperand(2), 1);
141 return CI->getArgOperand(0);
147 struct MemSetChkOpt : public InstFortifiedLibCallOptimization {
148 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
150 FunctionType *FT = Callee->getFunctionType();
151 LLVMContext &Context = CI->getParent()->getContext();
153 // Check if this has the right signature.
154 if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
155 !FT->getParamType(0)->isPointerTy() ||
156 !FT->getParamType(1)->isIntegerTy() ||
157 FT->getParamType(2) != TD->getIntPtrType(Context) ||
158 FT->getParamType(3) != TD->getIntPtrType(Context))
161 if (isFoldable(3, 2, false)) {
162 Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(),
164 B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
165 return CI->getArgOperand(0);
171 struct StrCpyChkOpt : public InstFortifiedLibCallOptimization {
172 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
174 StringRef Name = Callee->getName();
175 FunctionType *FT = Callee->getFunctionType();
176 LLVMContext &Context = CI->getParent()->getContext();
178 // Check if this has the right signature.
179 if (FT->getNumParams() != 3 ||
180 FT->getReturnType() != FT->getParamType(0) ||
181 FT->getParamType(0) != FT->getParamType(1) ||
182 FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
183 FT->getParamType(2) != TD->getIntPtrType(Context))
186 Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
187 if (Dst == Src) // __strcpy_chk(x,x) -> x
190 // If a) we don't have any length information, or b) we know this will
191 // fit then just lower to a plain st[rp]cpy. Otherwise we'll keep our
192 // st[rp]cpy_chk call which may fail at runtime if the size is too long.
193 // TODO: It might be nice to get a maximum length out of the possible
194 // string lengths for varying.
195 if (isFoldable(2, 1, true)) {
196 Value *Ret = EmitStrCpy(Dst, Src, B, TD, TLI, Name.substr(2, 6));
199 // Maybe we can stil fold __strcpy_chk to __memcpy_chk.
200 uint64_t Len = GetStringLength(Src);
201 if (Len == 0) return 0;
203 // This optimization require DataLayout.
207 EmitMemCpyChk(Dst, Src,
208 ConstantInt::get(TD->getIntPtrType(Context), Len),
209 CI->getArgOperand(2), B, TD, TLI);
216 struct StrNCpyChkOpt : public InstFortifiedLibCallOptimization {
217 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
219 StringRef Name = Callee->getName();
220 FunctionType *FT = Callee->getFunctionType();
221 LLVMContext &Context = CI->getParent()->getContext();
223 // Check if this has the right signature.
224 if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
225 FT->getParamType(0) != FT->getParamType(1) ||
226 FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
227 !FT->getParamType(2)->isIntegerTy() ||
228 FT->getParamType(3) != TD->getIntPtrType(Context))
231 if (isFoldable(3, 2, false)) {
232 Value *Ret = EmitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
233 CI->getArgOperand(2), B, TD, TLI,
241 //===----------------------------------------------------------------------===//
242 // String and Memory Library Call Optimizations
243 //===----------------------------------------------------------------------===//
245 struct StrCatOpt : public LibCallOptimization {
246 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
247 // Verify the "strcat" function prototype.
248 FunctionType *FT = Callee->getFunctionType();
249 if (FT->getNumParams() != 2 ||
250 FT->getReturnType() != B.getInt8PtrTy() ||
251 FT->getParamType(0) != FT->getReturnType() ||
252 FT->getParamType(1) != FT->getReturnType())
255 // Extract some information from the instruction
256 Value *Dst = CI->getArgOperand(0);
257 Value *Src = CI->getArgOperand(1);
259 // See if we can get the length of the input string.
260 uint64_t Len = GetStringLength(Src);
261 if (Len == 0) return 0;
262 --Len; // Unbias length.
264 // Handle the simple, do-nothing case: strcat(x, "") -> x
268 // These optimizations require DataLayout.
271 return emitStrLenMemCpy(Src, Dst, Len, B);
274 Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len,
276 // We need to find the end of the destination string. That's where the
277 // memory is to be moved to. We just generate a call to strlen.
278 Value *DstLen = EmitStrLen(Dst, B, TD, TLI);
282 // Now that we have the destination's length, we must index into the
283 // destination's pointer to get the actual memcpy destination (end of
284 // the string .. we're concatenating).
285 Value *CpyDst = B.CreateGEP(Dst, DstLen, "endptr");
287 // We have enough information to now generate the memcpy call to do the
288 // concatenation for us. Make a memcpy to copy the nul byte with align = 1.
289 B.CreateMemCpy(CpyDst, Src,
290 ConstantInt::get(TD->getIntPtrType(*Context), Len + 1), 1);
295 struct StrNCatOpt : public StrCatOpt {
296 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
297 // Verify the "strncat" function prototype.
298 FunctionType *FT = Callee->getFunctionType();
299 if (FT->getNumParams() != 3 ||
300 FT->getReturnType() != B.getInt8PtrTy() ||
301 FT->getParamType(0) != FT->getReturnType() ||
302 FT->getParamType(1) != FT->getReturnType() ||
303 !FT->getParamType(2)->isIntegerTy())
306 // Extract some information from the instruction
307 Value *Dst = CI->getArgOperand(0);
308 Value *Src = CI->getArgOperand(1);
311 // We don't do anything if length is not constant
312 if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(CI->getArgOperand(2)))
313 Len = LengthArg->getZExtValue();
317 // See if we can get the length of the input string.
318 uint64_t SrcLen = GetStringLength(Src);
319 if (SrcLen == 0) return 0;
320 --SrcLen; // Unbias length.
322 // Handle the simple, do-nothing cases:
323 // strncat(x, "", c) -> x
324 // strncat(x, c, 0) -> x
325 if (SrcLen == 0 || Len == 0) return Dst;
327 // These optimizations require DataLayout.
330 // We don't optimize this case
331 if (Len < SrcLen) return 0;
333 // strncat(x, s, c) -> strcat(x, s)
334 // s is constant so the strcat can be optimized further
335 return emitStrLenMemCpy(Src, Dst, SrcLen, B);
339 struct StrChrOpt : public LibCallOptimization {
340 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
341 // Verify the "strchr" function prototype.
342 FunctionType *FT = Callee->getFunctionType();
343 if (FT->getNumParams() != 2 ||
344 FT->getReturnType() != B.getInt8PtrTy() ||
345 FT->getParamType(0) != FT->getReturnType() ||
346 !FT->getParamType(1)->isIntegerTy(32))
349 Value *SrcStr = CI->getArgOperand(0);
351 // If the second operand is non-constant, see if we can compute the length
352 // of the input string and turn this into memchr.
353 ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
355 // These optimizations require DataLayout.
358 uint64_t Len = GetStringLength(SrcStr);
359 if (Len == 0 || !FT->getParamType(1)->isIntegerTy(32))// memchr needs i32.
362 return EmitMemChr(SrcStr, CI->getArgOperand(1), // include nul.
363 ConstantInt::get(TD->getIntPtrType(*Context), Len),
367 // Otherwise, the character is a constant, see if the first argument is
368 // a string literal. If so, we can constant fold.
370 if (!getConstantStringInfo(SrcStr, Str))
373 // Compute the offset, make sure to handle the case when we're searching for
374 // zero (a weird way to spell strlen).
375 size_t I = CharC->getSExtValue() == 0 ?
376 Str.size() : Str.find(CharC->getSExtValue());
377 if (I == StringRef::npos) // Didn't find the char. strchr returns null.
378 return Constant::getNullValue(CI->getType());
380 // strchr(s+n,c) -> gep(s+n+i,c)
381 return B.CreateGEP(SrcStr, B.getInt64(I), "strchr");
385 struct StrRChrOpt : public LibCallOptimization {
386 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
387 // Verify the "strrchr" function prototype.
388 FunctionType *FT = Callee->getFunctionType();
389 if (FT->getNumParams() != 2 ||
390 FT->getReturnType() != B.getInt8PtrTy() ||
391 FT->getParamType(0) != FT->getReturnType() ||
392 !FT->getParamType(1)->isIntegerTy(32))
395 Value *SrcStr = CI->getArgOperand(0);
396 ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
398 // Cannot fold anything if we're not looking for a constant.
403 if (!getConstantStringInfo(SrcStr, Str)) {
404 // strrchr(s, 0) -> strchr(s, 0)
405 if (TD && CharC->isZero())
406 return EmitStrChr(SrcStr, '\0', B, TD, TLI);
410 // Compute the offset.
411 size_t I = CharC->getSExtValue() == 0 ?
412 Str.size() : Str.rfind(CharC->getSExtValue());
413 if (I == StringRef::npos) // Didn't find the char. Return null.
414 return Constant::getNullValue(CI->getType());
416 // strrchr(s+n,c) -> gep(s+n+i,c)
417 return B.CreateGEP(SrcStr, B.getInt64(I), "strrchr");
421 struct StrCmpOpt : public LibCallOptimization {
422 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
423 // Verify the "strcmp" function prototype.
424 FunctionType *FT = Callee->getFunctionType();
425 if (FT->getNumParams() != 2 ||
426 !FT->getReturnType()->isIntegerTy(32) ||
427 FT->getParamType(0) != FT->getParamType(1) ||
428 FT->getParamType(0) != B.getInt8PtrTy())
431 Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
432 if (Str1P == Str2P) // strcmp(x,x) -> 0
433 return ConstantInt::get(CI->getType(), 0);
435 StringRef Str1, Str2;
436 bool HasStr1 = getConstantStringInfo(Str1P, Str1);
437 bool HasStr2 = getConstantStringInfo(Str2P, Str2);
439 // strcmp(x, y) -> cnst (if both x and y are constant strings)
440 if (HasStr1 && HasStr2)
441 return ConstantInt::get(CI->getType(), Str1.compare(Str2));
443 if (HasStr1 && Str1.empty()) // strcmp("", x) -> -*x
444 return B.CreateNeg(B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"),
447 if (HasStr2 && Str2.empty()) // strcmp(x,"") -> *x
448 return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType());
450 // strcmp(P, "x") -> memcmp(P, "x", 2)
451 uint64_t Len1 = GetStringLength(Str1P);
452 uint64_t Len2 = GetStringLength(Str2P);
454 // These optimizations require DataLayout.
457 return EmitMemCmp(Str1P, Str2P,
458 ConstantInt::get(TD->getIntPtrType(*Context),
459 std::min(Len1, Len2)), B, TD, TLI);
466 struct StrNCmpOpt : public LibCallOptimization {
467 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
468 // Verify the "strncmp" function prototype.
469 FunctionType *FT = Callee->getFunctionType();
470 if (FT->getNumParams() != 3 ||
471 !FT->getReturnType()->isIntegerTy(32) ||
472 FT->getParamType(0) != FT->getParamType(1) ||
473 FT->getParamType(0) != B.getInt8PtrTy() ||
474 !FT->getParamType(2)->isIntegerTy())
477 Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
478 if (Str1P == Str2P) // strncmp(x,x,n) -> 0
479 return ConstantInt::get(CI->getType(), 0);
481 // Get the length argument if it is constant.
483 if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(CI->getArgOperand(2)))
484 Length = LengthArg->getZExtValue();
488 if (Length == 0) // strncmp(x,y,0) -> 0
489 return ConstantInt::get(CI->getType(), 0);
491 if (TD && Length == 1) // strncmp(x,y,1) -> memcmp(x,y,1)
492 return EmitMemCmp(Str1P, Str2P, CI->getArgOperand(2), B, TD, TLI);
494 StringRef Str1, Str2;
495 bool HasStr1 = getConstantStringInfo(Str1P, Str1);
496 bool HasStr2 = getConstantStringInfo(Str2P, Str2);
498 // strncmp(x, y) -> cnst (if both x and y are constant strings)
499 if (HasStr1 && HasStr2) {
500 StringRef SubStr1 = Str1.substr(0, Length);
501 StringRef SubStr2 = Str2.substr(0, Length);
502 return ConstantInt::get(CI->getType(), SubStr1.compare(SubStr2));
505 if (HasStr1 && Str1.empty()) // strncmp("", x, n) -> -*x
506 return B.CreateNeg(B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"),
509 if (HasStr2 && Str2.empty()) // strncmp(x, "", n) -> *x
510 return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType());
516 struct StrCpyOpt : public LibCallOptimization {
517 virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
518 // Verify the "strcpy" function prototype.
519 FunctionType *FT = Callee->getFunctionType();
520 if (FT->getNumParams() != 2 ||
521 FT->getReturnType() != FT->getParamType(0) ||
522 FT->getParamType(0) != FT->getParamType(1) ||
523 FT->getParamType(0) != B.getInt8PtrTy())
526 Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
527 if (Dst == Src) // strcpy(x,x) -> x
530 // These optimizations require DataLayout.
533 // See if we can get the length of the input string.
534 uint64_t Len = GetStringLength(Src);
535 if (Len == 0) return 0;
537 // We have enough information to now generate the memcpy call to do the
538 // copy for us. Make a memcpy to copy the nul byte with align = 1.
539 B.CreateMemCpy(Dst, Src,
540 ConstantInt::get(TD->getIntPtrType(*Context), Len), 1);
545 } // End anonymous namespace.
549 class LibCallSimplifierImpl {
550 const DataLayout *TD;
551 const TargetLibraryInfo *TLI;
552 StringMap<LibCallOptimization*> Optimizations;
554 // Fortified library call optimizations.
555 MemCpyChkOpt MemCpyChk;
556 MemMoveChkOpt MemMoveChk;
557 MemSetChkOpt MemSetChk;
558 StrCpyChkOpt StrCpyChk;
559 StrNCpyChkOpt StrNCpyChk;
561 // String and memory library call optimizations.
570 void initOptimizations();
572 LibCallSimplifierImpl(const DataLayout *TD, const TargetLibraryInfo *TLI) {
577 Value *optimizeCall(CallInst *CI);
580 void LibCallSimplifierImpl::initOptimizations() {
581 // Fortified library call optimizations.
582 Optimizations["__memcpy_chk"] = &MemCpyChk;
583 Optimizations["__memmove_chk"] = &MemMoveChk;
584 Optimizations["__memset_chk"] = &MemSetChk;
585 Optimizations["__strcpy_chk"] = &StrCpyChk;
586 Optimizations["__stpcpy_chk"] = &StrCpyChk;
587 Optimizations["__strncpy_chk"] = &StrNCpyChk;
588 Optimizations["__stpncpy_chk"] = &StrNCpyChk;
589 Optimizations["strcmp"] = &StrCmp;
590 Optimizations["strncmp"] = &StrNCmp;
592 // String and memory library call optimizations.
593 Optimizations["strcat"] = &StrCat;
594 Optimizations["strncat"] = &StrNCat;
595 Optimizations["strchr"] = &StrChr;
596 Optimizations["strrchr"] = &StrRChr;
597 Optimizations["strcpy"] = &StrCpy;
600 Value *LibCallSimplifierImpl::optimizeCall(CallInst *CI) {
601 if (Optimizations.empty())
604 Function *Callee = CI->getCalledFunction();
605 LibCallOptimization *LCO = Optimizations.lookup(Callee->getName());
607 IRBuilder<> Builder(CI);
608 return LCO->optimizeCall(CI, TD, TLI, Builder);
613 LibCallSimplifier::LibCallSimplifier(const DataLayout *TD,
614 const TargetLibraryInfo *TLI) {
615 Impl = new LibCallSimplifierImpl(TD, TLI);
618 LibCallSimplifier::~LibCallSimplifier() {
622 Value *LibCallSimplifier::optimizeCall(CallInst *CI) {
623 return Impl->optimizeCall(CI);