2012-10-14 00:45:24 +08:00
|
|
|
//===------ SimplifyLibCalls.cpp - Library calls simplifier ---------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This is a utility pass used for testing the InstructionSimplify analysis.
|
|
|
|
// The analysis is applied to every instruction, and if it simplifies then the
|
|
|
|
// instruction is replaced by the simplification. If you are looking for a pass
|
|
|
|
// that performs serious instruction folding, use the instcombine pass instead.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Transforms/Utils/SimplifyLibCalls.h"
|
2013-03-12 08:08:29 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2012-10-14 00:45:24 +08:00
|
|
|
#include "llvm/ADT/StringMap.h"
|
2013-11-03 14:48:38 +08:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2012-10-14 00:45:24 +08:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2014-05-22 22:19:46 +08:00
|
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Function.h"
|
|
|
|
#include "llvm/IR/IRBuilder.h"
|
2013-03-12 08:08:29 +08:00
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Intrinsics.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
2014-10-17 02:48:17 +08:00
|
|
|
#include "llvm/IR/PatternMatch.h"
|
2013-02-27 13:53:43 +08:00
|
|
|
#include "llvm/Support/Allocator.h"
|
2013-11-17 10:06:35 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2015-01-15 10:16:27 +08:00
|
|
|
#include "llvm/Analysis/TargetLibraryInfo.h"
|
2012-10-14 00:45:24 +08:00
|
|
|
#include "llvm/Transforms/Utils/BuildLibCalls.h"
|
2015-08-29 02:30:18 +08:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2012-10-14 00:45:24 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
2014-10-17 02:48:17 +08:00
|
|
|
using namespace PatternMatch;
|
2012-10-14 00:45:24 +08:00
|
|
|
|
2013-11-17 10:06:35 +08:00
|
|
|
static cl::opt<bool>
|
2014-09-18 04:55:46 +08:00
|
|
|
ColdErrorCalls("error-reporting-is-cold", cl::init(true), cl::Hidden,
|
|
|
|
cl::desc("Treat error-reporting calls as cold"));
|
2012-10-14 00:45:24 +08:00
|
|
|
|
2014-10-22 23:29:23 +08:00
|
|
|
static cl::opt<bool>
|
|
|
|
EnableUnsafeFPShrink("enable-double-float-shrink", cl::Hidden,
|
|
|
|
cl::init(false),
|
|
|
|
cl::desc("Enable unsafe double to float "
|
|
|
|
"shrinking for math lib calls"));
|
|
|
|
|
|
|
|
|
2012-10-31 11:33:06 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Helper Functions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
static bool ignoreCallingConv(LibFunc::Func Func) {
|
|
|
|
switch (Func) {
|
|
|
|
case LibFunc::abs:
|
|
|
|
case LibFunc::labs:
|
|
|
|
case LibFunc::llabs:
|
|
|
|
case LibFunc::strlen:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
2014-09-18 05:06:59 +08:00
|
|
|
llvm_unreachable("All cases should be covered in the switch.");
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
|
|
|
|
2012-10-31 11:33:06 +08:00
|
|
|
/// isOnlyUsedInZeroEqualityComparison - Return true if it only matters that the
|
|
|
|
/// value is equal or not-equal to zero.
|
|
|
|
static bool isOnlyUsedInZeroEqualityComparison(Value *V) {
|
2014-03-09 11:16:01 +08:00
|
|
|
for (User *U : V->users()) {
|
|
|
|
if (ICmpInst *IC = dyn_cast<ICmpInst>(U))
|
2012-10-31 11:33:06 +08:00
|
|
|
if (IC->isEquality())
|
|
|
|
if (Constant *C = dyn_cast<Constant>(IC->getOperand(1)))
|
|
|
|
if (C->isNullValue())
|
|
|
|
continue;
|
|
|
|
// Unknown instruction.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-11-11 11:51:48 +08:00
|
|
|
/// isOnlyUsedInEqualityComparison - Return true if it is only used in equality
|
|
|
|
/// comparisons with With.
|
|
|
|
static bool isOnlyUsedInEqualityComparison(Value *V, Value *With) {
|
2014-03-09 11:16:01 +08:00
|
|
|
for (User *U : V->users()) {
|
|
|
|
if (ICmpInst *IC = dyn_cast<ICmpInst>(U))
|
2012-11-11 11:51:48 +08:00
|
|
|
if (IC->isEquality() && IC->getOperand(1) == With)
|
|
|
|
continue;
|
|
|
|
// Unknown instruction.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-11-27 04:37:20 +08:00
|
|
|
static bool callHasFloatingPointArgument(const CallInst *CI) {
|
|
|
|
for (CallInst::const_op_iterator it = CI->op_begin(), e = CI->op_end();
|
|
|
|
it != e; ++it) {
|
|
|
|
if ((*it)->getType()->isFloatingPointTy())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-09-01 02:19:35 +08:00
|
|
|
/// \brief Check whether the overloaded unary floating point function
|
2015-08-13 04:36:18 +08:00
|
|
|
/// corresponding to \a Ty is available.
|
2013-09-01 02:19:35 +08:00
|
|
|
static bool hasUnaryFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
|
|
|
|
LibFunc::Func DoubleFn, LibFunc::Func FloatFn,
|
|
|
|
LibFunc::Func LongDoubleFn) {
|
|
|
|
switch (Ty->getTypeID()) {
|
|
|
|
case Type::FloatTyID:
|
|
|
|
return TLI->has(FloatFn);
|
|
|
|
case Type::DoubleTyID:
|
|
|
|
return TLI->has(DoubleFn);
|
|
|
|
default:
|
|
|
|
return TLI->has(LongDoubleFn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-29 10:58:44 +08:00
|
|
|
/// \brief Check whether we can use unsafe floating point math for
|
|
|
|
/// the function passed as input.
|
|
|
|
static bool canUseUnsafeFPMath(Function *F) {
|
|
|
|
|
|
|
|
// FIXME: For finer-grain optimization, we need intrinsics to have the same
|
|
|
|
// fast-math flag decorations that are applied to FP instructions. For now,
|
|
|
|
// we have to rely on the function-level unsafe-fp-math attribute to do this
|
|
|
|
// optimization because there's no other way to express that the sqrt can be
|
|
|
|
// reassociated.
|
|
|
|
if (F->hasFnAttribute("unsafe-fp-math")) {
|
|
|
|
Attribute Attr = F->getFnAttribute("unsafe-fp-math");
|
|
|
|
if (Attr.getValueAsString() == "true")
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-01-13 01:18:19 +08:00
|
|
|
/// \brief Returns whether \p F matches the signature expected for the
|
|
|
|
/// string/memory copying library function \p Func.
|
|
|
|
/// Acceptable functions are st[rp][n]?cpy, memove, memcpy, and memset.
|
|
|
|
/// Their fortified (_chk) counterparts are also accepted.
|
2015-03-10 10:37:25 +08:00
|
|
|
static bool checkStringCopyLibFuncSignature(Function *F, LibFunc::Func Func) {
|
|
|
|
const DataLayout &DL = F->getParent()->getDataLayout();
|
2015-01-13 01:18:19 +08:00
|
|
|
FunctionType *FT = F->getFunctionType();
|
|
|
|
LLVMContext &Context = F->getContext();
|
|
|
|
Type *PCharTy = Type::getInt8PtrTy(Context);
|
2015-03-10 10:37:25 +08:00
|
|
|
Type *SizeTTy = DL.getIntPtrType(Context);
|
2015-01-13 01:18:19 +08:00
|
|
|
unsigned NumParams = FT->getNumParams();
|
|
|
|
|
|
|
|
// All string libfuncs return the same type as the first parameter.
|
|
|
|
if (FT->getReturnType() != FT->getParamType(0))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
switch (Func) {
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Can't check signature for non-string-copy libfunc.");
|
|
|
|
case LibFunc::stpncpy_chk:
|
|
|
|
case LibFunc::strncpy_chk:
|
|
|
|
--NumParams; // fallthrough
|
|
|
|
case LibFunc::stpncpy:
|
|
|
|
case LibFunc::strncpy: {
|
|
|
|
if (NumParams != 3 || FT->getParamType(0) != FT->getParamType(1) ||
|
|
|
|
FT->getParamType(0) != PCharTy || !FT->getParamType(2)->isIntegerTy())
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case LibFunc::strcpy_chk:
|
|
|
|
case LibFunc::stpcpy_chk:
|
|
|
|
--NumParams; // fallthrough
|
|
|
|
case LibFunc::stpcpy:
|
|
|
|
case LibFunc::strcpy: {
|
|
|
|
if (NumParams != 2 || FT->getParamType(0) != FT->getParamType(1) ||
|
|
|
|
FT->getParamType(0) != PCharTy)
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case LibFunc::memmove_chk:
|
|
|
|
case LibFunc::memcpy_chk:
|
|
|
|
--NumParams; // fallthrough
|
|
|
|
case LibFunc::memmove:
|
|
|
|
case LibFunc::memcpy: {
|
|
|
|
if (NumParams != 3 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() || FT->getParamType(2) != SizeTTy)
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case LibFunc::memset_chk:
|
|
|
|
--NumParams; // fallthrough
|
|
|
|
case LibFunc::memset: {
|
|
|
|
if (NumParams != 3 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isIntegerTy() || FT->getParamType(2) != SizeTTy)
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If this is a fortified libcall, the last parameter is a size_t.
|
|
|
|
if (NumParams == FT->getNumParams() - 1)
|
|
|
|
return FT->getParamType(FT->getNumParams() - 1) == SizeTTy;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-10-14 00:45:32 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// String and Memory Library Call Optimizations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Verify the "strcat" function prototype.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2||
|
|
|
|
FT->getReturnType() != B.getInt8PtrTy() ||
|
|
|
|
FT->getParamType(0) != FT->getReturnType() ||
|
|
|
|
FT->getParamType(1) != FT->getReturnType())
|
|
|
|
return nullptr;
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Extract some information from the instruction
|
|
|
|
Value *Dst = CI->getArgOperand(0);
|
|
|
|
Value *Src = CI->getArgOperand(1);
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// See if we can get the length of the input string.
|
|
|
|
uint64_t Len = GetStringLength(Src);
|
|
|
|
if (Len == 0)
|
|
|
|
return nullptr;
|
|
|
|
--Len; // Unbias length.
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Handle the simple, do-nothing case: strcat(x, "") -> x
|
|
|
|
if (Len == 0)
|
|
|
|
return Dst;
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return emitStrLenMemCpy(Src, Dst, Len, B);
|
|
|
|
}
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len,
|
|
|
|
IRBuilder<> &B) {
|
|
|
|
// We need to find the end of the destination string. That's where the
|
|
|
|
// memory is to be moved to. We just generate a call to strlen.
|
|
|
|
Value *DstLen = EmitStrLen(Dst, B, DL, TLI);
|
|
|
|
if (!DstLen)
|
|
|
|
return nullptr;
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Now that we have the destination's length, we must index into the
|
|
|
|
// destination's pointer to get the actual memcpy destination (end of
|
|
|
|
// the string .. we're concatenating).
|
2015-03-31 04:42:56 +08:00
|
|
|
Value *CpyDst = B.CreateGEP(B.getInt8Ty(), Dst, DstLen, "endptr");
|
2014-09-18 04:55:46 +08:00
|
|
|
|
|
|
|
// We have enough information to now generate the memcpy call to do the
|
|
|
|
// concatenation for us. Make a memcpy to copy the nul byte with align = 1.
|
2015-03-10 10:37:25 +08:00
|
|
|
B.CreateMemCpy(CpyDst, Src,
|
|
|
|
ConstantInt::get(DL.getIntPtrType(Src->getContext()), Len + 1),
|
|
|
|
1);
|
2014-09-18 04:55:46 +08:00
|
|
|
return Dst;
|
|
|
|
}
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrNCat(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Verify the "strncat" function prototype.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 3 || FT->getReturnType() != B.getInt8PtrTy() ||
|
|
|
|
FT->getParamType(0) != FT->getReturnType() ||
|
|
|
|
FT->getParamType(1) != FT->getReturnType() ||
|
|
|
|
!FT->getParamType(2)->isIntegerTy())
|
|
|
|
return nullptr;
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Extract some information from the instruction
|
|
|
|
Value *Dst = CI->getArgOperand(0);
|
|
|
|
Value *Src = CI->getArgOperand(1);
|
|
|
|
uint64_t Len;
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// We don't do anything if length is not constant
|
|
|
|
if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(CI->getArgOperand(2)))
|
|
|
|
Len = LengthArg->getZExtValue();
|
|
|
|
else
|
|
|
|
return nullptr;
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// See if we can get the length of the input string.
|
|
|
|
uint64_t SrcLen = GetStringLength(Src);
|
|
|
|
if (SrcLen == 0)
|
|
|
|
return nullptr;
|
|
|
|
--SrcLen; // Unbias length.
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Handle the simple, do-nothing cases:
|
|
|
|
// strncat(x, "", c) -> x
|
|
|
|
// strncat(x, c, 0) -> x
|
|
|
|
if (SrcLen == 0 || Len == 0)
|
|
|
|
return Dst;
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// We don't optimize this case
|
|
|
|
if (Len < SrcLen)
|
|
|
|
return nullptr;
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strncat(x, s, c) -> strcat(x, s)
|
|
|
|
// s is constant so the strcat can be optimized further
|
|
|
|
return emitStrLenMemCpy(Src, Dst, SrcLen, B);
|
|
|
|
}
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrChr(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Verify the "strchr" function prototype.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || FT->getReturnType() != B.getInt8PtrTy() ||
|
|
|
|
FT->getParamType(0) != FT->getReturnType() ||
|
|
|
|
!FT->getParamType(1)->isIntegerTy(32))
|
|
|
|
return nullptr;
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *SrcStr = CI->getArgOperand(0);
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// If the second operand is non-constant, see if we can compute the length
|
|
|
|
// of the input string and turn this into memchr.
|
|
|
|
ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
|
|
|
|
if (!CharC) {
|
|
|
|
uint64_t Len = GetStringLength(SrcStr);
|
|
|
|
if (Len == 0 || !FT->getParamType(1)->isIntegerTy(32)) // memchr needs i32.
|
|
|
|
return nullptr;
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
return EmitMemChr(SrcStr, CI->getArgOperand(1), // include nul.
|
|
|
|
ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len),
|
|
|
|
B, DL, TLI);
|
2012-10-14 00:45:37 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Otherwise, the character is a constant, see if the first argument is
|
|
|
|
// a string literal. If so, we can constant fold.
|
|
|
|
StringRef Str;
|
|
|
|
if (!getConstantStringInfo(SrcStr, Str)) {
|
2015-03-10 10:37:25 +08:00
|
|
|
if (CharC->isZero()) // strchr(p, 0) -> p + strlen(p)
|
2015-03-31 04:42:56 +08:00
|
|
|
return B.CreateGEP(B.getInt8Ty(), SrcStr, EmitStrLen(SrcStr, B, DL, TLI), "strchr");
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Compute the offset, make sure to handle the case when we're searching for
|
|
|
|
// zero (a weird way to spell strlen).
|
|
|
|
size_t I = (0xFF & CharC->getSExtValue()) == 0
|
|
|
|
? Str.size()
|
|
|
|
: Str.find(CharC->getSExtValue());
|
|
|
|
if (I == StringRef::npos) // Didn't find the char. strchr returns null.
|
|
|
|
return Constant::getNullValue(CI->getType());
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strchr(s+n,c) -> gep(s+n+i,c)
|
2015-03-31 04:42:56 +08:00
|
|
|
return B.CreateGEP(B.getInt8Ty(), SrcStr, B.getInt64(I), "strchr");
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrRChr(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Verify the "strrchr" function prototype.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || FT->getReturnType() != B.getInt8PtrTy() ||
|
|
|
|
FT->getParamType(0) != FT->getReturnType() ||
|
|
|
|
!FT->getParamType(1)->isIntegerTy(32))
|
|
|
|
return nullptr;
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *SrcStr = CI->getArgOperand(0);
|
|
|
|
ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Cannot fold anything if we're not looking for a constant.
|
|
|
|
if (!CharC)
|
|
|
|
return nullptr;
|
2012-10-14 00:45:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
StringRef Str;
|
|
|
|
if (!getConstantStringInfo(SrcStr, Str)) {
|
|
|
|
// strrchr(s, 0) -> strchr(s, 0)
|
2015-03-10 10:37:25 +08:00
|
|
|
if (CharC->isZero())
|
|
|
|
return EmitStrChr(SrcStr, '\0', B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Compute the offset.
|
|
|
|
size_t I = (0xFF & CharC->getSExtValue()) == 0
|
|
|
|
? Str.size()
|
|
|
|
: Str.rfind(CharC->getSExtValue());
|
|
|
|
if (I == StringRef::npos) // Didn't find the char. Return null.
|
|
|
|
return Constant::getNullValue(CI->getType());
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strrchr(s+n,c) -> gep(s+n+i,c)
|
2015-03-31 04:42:56 +08:00
|
|
|
return B.CreateGEP(B.getInt8Ty(), SrcStr, B.getInt64(I), "strrchr");
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrCmp(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Verify the "strcmp" function prototype.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || !FT->getReturnType()->isIntegerTy(32) ||
|
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
|
|
|
FT->getParamType(0) != B.getInt8PtrTy())
|
|
|
|
return nullptr;
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
|
|
|
|
if (Str1P == Str2P) // strcmp(x,x) -> 0
|
|
|
|
return ConstantInt::get(CI->getType(), 0);
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
StringRef Str1, Str2;
|
|
|
|
bool HasStr1 = getConstantStringInfo(Str1P, Str1);
|
|
|
|
bool HasStr2 = getConstantStringInfo(Str2P, Str2);
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strcmp(x, y) -> cnst (if both x and y are constant strings)
|
|
|
|
if (HasStr1 && HasStr2)
|
|
|
|
return ConstantInt::get(CI->getType(), Str1.compare(Str2));
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (HasStr1 && Str1.empty()) // strcmp("", x) -> -*x
|
|
|
|
return B.CreateNeg(
|
|
|
|
B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"), CI->getType()));
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (HasStr2 && Str2.empty()) // strcmp(x,"") -> *x
|
|
|
|
return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType());
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strcmp(P, "x") -> memcmp(P, "x", 2)
|
|
|
|
uint64_t Len1 = GetStringLength(Str1P);
|
|
|
|
uint64_t Len2 = GetStringLength(Str2P);
|
|
|
|
if (Len1 && Len2) {
|
|
|
|
return EmitMemCmp(Str1P, Str2P,
|
2015-03-10 10:37:25 +08:00
|
|
|
ConstantInt::get(DL.getIntPtrType(CI->getContext()),
|
2014-09-18 04:55:46 +08:00
|
|
|
std::min(Len1, Len2)),
|
|
|
|
B, DL, TLI);
|
|
|
|
}
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Verify the "strncmp" function prototype.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 3 || !FT->getReturnType()->isIntegerTy(32) ||
|
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
|
|
|
FT->getParamType(0) != B.getInt8PtrTy() ||
|
|
|
|
!FT->getParamType(2)->isIntegerTy())
|
|
|
|
return nullptr;
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
|
|
|
|
if (Str1P == Str2P) // strncmp(x,x,n) -> 0
|
|
|
|
return ConstantInt::get(CI->getType(), 0);
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Get the length argument if it is constant.
|
|
|
|
uint64_t Length;
|
|
|
|
if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(CI->getArgOperand(2)))
|
|
|
|
Length = LengthArg->getZExtValue();
|
|
|
|
else
|
|
|
|
return nullptr;
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (Length == 0) // strncmp(x,y,0) -> 0
|
|
|
|
return ConstantInt::get(CI->getType(), 0);
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (Length == 1) // strncmp(x,y,1) -> memcmp(x,y,1)
|
2014-09-18 04:55:46 +08:00
|
|
|
return EmitMemCmp(Str1P, Str2P, CI->getArgOperand(2), B, DL, TLI);
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
StringRef Str1, Str2;
|
|
|
|
bool HasStr1 = getConstantStringInfo(Str1P, Str1);
|
|
|
|
bool HasStr2 = getConstantStringInfo(Str2P, Str2);
|
2012-10-15 11:47:37 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strncmp(x, y) -> cnst (if both x and y are constant strings)
|
|
|
|
if (HasStr1 && HasStr2) {
|
|
|
|
StringRef SubStr1 = Str1.substr(0, Length);
|
|
|
|
StringRef SubStr2 = Str2.substr(0, Length);
|
|
|
|
return ConstantInt::get(CI->getType(), SubStr1.compare(SubStr2));
|
2012-10-15 11:47:37 +08:00
|
|
|
}
|
2012-10-19 02:12:40 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (HasStr1 && Str1.empty()) // strncmp("", x, n) -> -*x
|
|
|
|
return B.CreateNeg(
|
|
|
|
B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"), CI->getType()));
|
2012-10-19 02:12:40 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (HasStr2 && Str2.empty()) // strncmp(x, "", n) -> *x
|
|
|
|
return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType());
|
2012-10-19 02:12:40 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-10-31 08:20:56 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
2015-01-13 01:18:19 +08:00
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::strcpy))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
2012-10-31 08:20:56 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
|
|
|
|
if (Dst == Src) // strcpy(x,x) -> x
|
|
|
|
return Src;
|
2012-10-31 08:20:56 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// See if we can get the length of the input string.
|
|
|
|
uint64_t Len = GetStringLength(Src);
|
|
|
|
if (Len == 0)
|
|
|
|
return nullptr;
|
2012-10-31 08:20:56 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// We have enough information to now generate the memcpy call to do the
|
|
|
|
// copy for us. Make a memcpy to copy the nul byte with align = 1.
|
|
|
|
B.CreateMemCpy(Dst, Src,
|
2015-03-10 10:37:25 +08:00
|
|
|
ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len), 1);
|
2014-09-18 04:55:46 +08:00
|
|
|
return Dst;
|
|
|
|
}
|
2012-10-31 08:20:56 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Verify the "stpcpy" function prototype.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
2015-01-13 01:18:19 +08:00
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::stpcpy))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
2012-10-31 11:33:00 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
|
|
|
|
if (Dst == Src) { // stpcpy(x,x) -> x+strlen(x)
|
|
|
|
Value *StrLen = EmitStrLen(Src, B, DL, TLI);
|
2015-04-04 05:33:42 +08:00
|
|
|
return StrLen ? B.CreateInBoundsGEP(B.getInt8Ty(), Dst, StrLen) : nullptr;
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
2012-10-31 11:33:00 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// See if we can get the length of the input string.
|
|
|
|
uint64_t Len = GetStringLength(Src);
|
|
|
|
if (Len == 0)
|
|
|
|
return nullptr;
|
2012-10-31 11:33:00 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Type *PT = FT->getParamType(0);
|
2015-03-10 10:37:25 +08:00
|
|
|
Value *LenV = ConstantInt::get(DL.getIntPtrType(PT), Len);
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *DstEnd =
|
2015-03-31 04:42:56 +08:00
|
|
|
B.CreateGEP(B.getInt8Ty(), Dst, ConstantInt::get(DL.getIntPtrType(PT), Len - 1));
|
2012-10-31 11:33:00 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// We have enough information to now generate the memcpy call to do the
|
|
|
|
// copy for us. Make a memcpy to copy the nul byte with align = 1.
|
|
|
|
B.CreateMemCpy(Dst, Src, LenV, 1);
|
|
|
|
return DstEnd;
|
|
|
|
}
|
2012-10-31 11:33:00 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
2015-01-13 01:18:19 +08:00
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::strncpy))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
2012-10-31 11:33:00 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Dst = CI->getArgOperand(0);
|
|
|
|
Value *Src = CI->getArgOperand(1);
|
|
|
|
Value *LenOp = CI->getArgOperand(2);
|
2012-10-31 11:33:00 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// See if we can get the length of the input string.
|
|
|
|
uint64_t SrcLen = GetStringLength(Src);
|
|
|
|
if (SrcLen == 0)
|
|
|
|
return nullptr;
|
|
|
|
--SrcLen;
|
2012-10-31 11:33:00 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (SrcLen == 0) {
|
|
|
|
// strncpy(x, "", y) -> memset(x, '\0', y, 1)
|
|
|
|
B.CreateMemSet(Dst, B.getInt8('\0'), LenOp, 1);
|
2012-10-31 11:33:00 +08:00
|
|
|
return Dst;
|
|
|
|
}
|
2012-10-31 11:33:06 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
uint64_t Len;
|
|
|
|
if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(LenOp))
|
|
|
|
Len = LengthArg->getZExtValue();
|
|
|
|
else
|
|
|
|
return nullptr;
|
2014-05-02 12:11:45 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (Len == 0)
|
|
|
|
return Dst; // strncpy(x, y, 0) -> x
|
2014-05-02 12:11:45 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Let strncpy handle the zero padding
|
|
|
|
if (Len > SrcLen + 1)
|
|
|
|
return nullptr;
|
2012-10-31 12:29:58 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Type *PT = FT->getParamType(0);
|
|
|
|
// strncpy(x, s, c) -> memcpy(x, s, c, 1) [s and c are constant]
|
2015-03-10 10:37:25 +08:00
|
|
|
B.CreateMemCpy(Dst, Src, ConstantInt::get(DL.getIntPtrType(PT), Len), 1);
|
2012-10-31 12:29:58 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return Dst;
|
|
|
|
}
|
2012-10-31 12:29:58 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrLen(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 1 || FT->getParamType(0) != B.getInt8PtrTy() ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
|
|
|
return nullptr;
|
2012-10-31 12:29:58 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Src = CI->getArgOperand(0);
|
|
|
|
|
|
|
|
// Constant folding: strlen("xyz") -> 3
|
|
|
|
if (uint64_t Len = GetStringLength(Src))
|
|
|
|
return ConstantInt::get(CI->getType(), Len - 1);
|
|
|
|
|
|
|
|
// strlen(x?"foo":"bars") --> x ? 3 : 4
|
|
|
|
if (SelectInst *SI = dyn_cast<SelectInst>(Src)) {
|
|
|
|
uint64_t LenTrue = GetStringLength(SI->getTrueValue());
|
|
|
|
uint64_t LenFalse = GetStringLength(SI->getFalseValue());
|
|
|
|
if (LenTrue && LenFalse) {
|
|
|
|
Function *Caller = CI->getParent()->getParent();
|
|
|
|
emitOptimizationRemark(CI->getContext(), "simplify-libcalls", *Caller,
|
|
|
|
SI->getDebugLoc(),
|
|
|
|
"folded strlen(select) to select of constants");
|
|
|
|
return B.CreateSelect(SI->getCondition(),
|
|
|
|
ConstantInt::get(CI->getType(), LenTrue - 1),
|
|
|
|
ConstantInt::get(CI->getType(), LenFalse - 1));
|
2012-10-31 12:29:58 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strlen(x) != 0 --> *x != 0
|
|
|
|
// strlen(x) == 0 --> *x == 0
|
|
|
|
if (isOnlyUsedInZeroEqualityComparison(CI))
|
|
|
|
return B.CreateZExt(B.CreateLoad(Src, "strlenfirst"), CI->getType());
|
2012-10-31 22:58:26 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-10-31 22:58:26 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrPBrk(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || FT->getParamType(0) != B.getInt8PtrTy() ||
|
|
|
|
FT->getParamType(1) != FT->getParamType(0) ||
|
|
|
|
FT->getReturnType() != FT->getParamType(0))
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2012-10-31 22:58:26 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
StringRef S1, S2;
|
|
|
|
bool HasS1 = getConstantStringInfo(CI->getArgOperand(0), S1);
|
|
|
|
bool HasS2 = getConstantStringInfo(CI->getArgOperand(1), S2);
|
2012-11-08 09:33:50 +08:00
|
|
|
|
2014-11-14 06:55:19 +08:00
|
|
|
// strpbrk(s, "") -> nullptr
|
|
|
|
// strpbrk("", s) -> nullptr
|
2014-09-18 04:55:46 +08:00
|
|
|
if ((HasS1 && S1.empty()) || (HasS2 && S2.empty()))
|
|
|
|
return Constant::getNullValue(CI->getType());
|
2012-11-08 09:33:50 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Constant folding.
|
|
|
|
if (HasS1 && HasS2) {
|
|
|
|
size_t I = S1.find_first_of(S2);
|
|
|
|
if (I == StringRef::npos) // No match.
|
2012-11-08 09:33:50 +08:00
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
2015-03-31 04:42:56 +08:00
|
|
|
return B.CreateGEP(B.getInt8Ty(), CI->getArgOperand(0), B.getInt64(I), "strpbrk");
|
2012-11-08 09:33:50 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strpbrk(s, "a") -> strchr(s, 'a')
|
2015-03-10 10:37:25 +08:00
|
|
|
if (HasS2 && S2.size() == 1)
|
|
|
|
return EmitStrChr(CI->getArgOperand(0), S2[0], B, TLI);
|
2012-11-10 23:16:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-10 23:16:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrTo(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if ((FT->getNumParams() != 2 && FT->getNumParams() != 3) ||
|
|
|
|
!FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy())
|
|
|
|
return nullptr;
|
2012-11-10 23:16:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *EndPtr = CI->getArgOperand(1);
|
|
|
|
if (isa<ConstantPointerNull>(EndPtr)) {
|
|
|
|
// With a null EndPtr, this function won't capture the main argument.
|
|
|
|
// It would be readonly too, except that it still may write to errno.
|
|
|
|
CI->addAttribute(1, Attribute::NoCapture);
|
|
|
|
}
|
2012-11-10 23:16:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-10 23:16:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrSpn(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || FT->getParamType(0) != B.getInt8PtrTy() ||
|
|
|
|
FT->getParamType(1) != FT->getParamType(0) ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2012-11-10 23:16:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
StringRef S1, S2;
|
|
|
|
bool HasS1 = getConstantStringInfo(CI->getArgOperand(0), S1);
|
|
|
|
bool HasS2 = getConstantStringInfo(CI->getArgOperand(1), S2);
|
2012-11-11 11:51:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strspn(s, "") -> 0
|
|
|
|
// strspn("", s) -> 0
|
|
|
|
if ((HasS1 && S1.empty()) || (HasS2 && S2.empty()))
|
|
|
|
return Constant::getNullValue(CI->getType());
|
2012-11-11 11:51:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Constant folding.
|
|
|
|
if (HasS1 && HasS2) {
|
|
|
|
size_t Pos = S1.find_first_not_of(S2);
|
|
|
|
if (Pos == StringRef::npos)
|
|
|
|
Pos = S1.size();
|
|
|
|
return ConstantInt::get(CI->getType(), Pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *LibCallSimplifier::optimizeStrCSpn(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || FT->getParamType(0) != B.getInt8PtrTy() ||
|
|
|
|
FT->getParamType(1) != FT->getParamType(0) ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
|
|
|
return nullptr;
|
2012-11-11 11:51:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
StringRef S1, S2;
|
|
|
|
bool HasS1 = getConstantStringInfo(CI->getArgOperand(0), S1);
|
|
|
|
bool HasS2 = getConstantStringInfo(CI->getArgOperand(1), S2);
|
2012-11-11 11:51:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strcspn("", s) -> 0
|
|
|
|
if (HasS1 && S1.empty())
|
|
|
|
return Constant::getNullValue(CI->getType());
|
2012-11-11 11:51:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Constant folding.
|
|
|
|
if (HasS1 && HasS2) {
|
|
|
|
size_t Pos = S1.find_first_of(S2);
|
|
|
|
if (Pos == StringRef::npos)
|
|
|
|
Pos = S1.size();
|
|
|
|
return ConstantInt::get(CI->getType(), Pos);
|
|
|
|
}
|
2012-11-11 11:51:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strcspn(s, "") -> strlen(s)
|
2015-03-10 10:37:25 +08:00
|
|
|
if (HasS2 && S2.empty())
|
2014-09-18 04:55:46 +08:00
|
|
|
return EmitStrLen(CI->getArgOperand(0), B, DL, TLI);
|
2012-11-11 11:51:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-11 11:51:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrStr(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
|
|
|
!FT->getReturnType()->isPointerTy())
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2012-11-11 11:51:48 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// fold strstr(x, x) -> x.
|
|
|
|
if (CI->getArgOperand(0) == CI->getArgOperand(1))
|
|
|
|
return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
|
|
|
|
|
|
|
|
// fold strstr(a, b) == a -> strncmp(a, b, strlen(b)) == 0
|
2015-03-10 10:37:25 +08:00
|
|
|
if (isOnlyUsedInEqualityComparison(CI, CI->getArgOperand(0))) {
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *StrLen = EmitStrLen(CI->getArgOperand(1), B, DL, TLI);
|
|
|
|
if (!StrLen)
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *StrNCmp = EmitStrNCmp(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
StrLen, B, DL, TLI);
|
|
|
|
if (!StrNCmp)
|
|
|
|
return nullptr;
|
|
|
|
for (auto UI = CI->user_begin(), UE = CI->user_end(); UI != UE;) {
|
|
|
|
ICmpInst *Old = cast<ICmpInst>(*UI++);
|
|
|
|
Value *Cmp =
|
|
|
|
B.CreateICmp(Old->getPredicate(), StrNCmp,
|
|
|
|
ConstantInt::getNullValue(StrNCmp->getType()), "cmp");
|
|
|
|
replaceAllUsesWith(Old, Cmp);
|
|
|
|
}
|
|
|
|
return CI;
|
|
|
|
}
|
2012-11-11 13:11:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// See if either input string is a constant string.
|
|
|
|
StringRef SearchStr, ToFindStr;
|
|
|
|
bool HasStr1 = getConstantStringInfo(CI->getArgOperand(0), SearchStr);
|
|
|
|
bool HasStr2 = getConstantStringInfo(CI->getArgOperand(1), ToFindStr);
|
2012-11-11 13:11:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// fold strstr(x, "") -> x.
|
|
|
|
if (HasStr2 && ToFindStr.empty())
|
|
|
|
return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
|
2012-11-11 13:11:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// If both strings are known, constant fold it.
|
|
|
|
if (HasStr1 && HasStr2) {
|
|
|
|
size_t Offset = SearchStr.find(ToFindStr);
|
2012-11-11 13:11:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (Offset == StringRef::npos) // strstr("foo", "bar") -> null
|
2012-11-11 13:11:20 +08:00
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strstr("abcd", "bc") -> gep((char*)"abcd", 1)
|
|
|
|
Value *Result = CastToCStr(CI->getArgOperand(0), B);
|
|
|
|
Result = B.CreateConstInBoundsGEP1_64(Result, Offset, "strstr");
|
|
|
|
return B.CreateBitCast(Result, CI->getType());
|
|
|
|
}
|
2012-11-11 13:11:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// fold strstr(x, "y") -> strchr(x, 'y').
|
|
|
|
if (HasStr2 && ToFindStr.size() == 1) {
|
2015-03-10 10:37:25 +08:00
|
|
|
Value *StrChr = EmitStrChr(CI->getArgOperand(0), ToFindStr[0], B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
return StrChr ? B.CreateBitCast(StrChr, CI->getType()) : nullptr;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-11 13:11:20 +08:00
|
|
|
|
2015-03-21 23:36:21 +08:00
|
|
|
Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 3 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isIntegerTy(32) ||
|
|
|
|
!FT->getParamType(2)->isIntegerTy() ||
|
|
|
|
!FT->getReturnType()->isPointerTy())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
Value *SrcStr = CI->getArgOperand(0);
|
|
|
|
ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
|
|
|
|
ConstantInt *LenC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
|
|
|
|
|
|
|
|
// memchr(x, y, 0) -> null
|
|
|
|
if (LenC && LenC->isNullValue())
|
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
[SimplifyLibCalls] Turn memchr(const, C, const) into a bitfield check.
strchr("123!", C) != nullptr is a common pattern to check if C is one
of 1, 2, 3 or !. If the largest element of the string is smaller than
the target's register size we can easily create a bitfield and just
do a simple test for set membership.
int foo(char C) { return strchr("123!", C) != nullptr; } now becomes
cmpl $64, %edi ## range check
sbbb %al, %al
movabsq $0xE000200000001, %rcx
btq %rdi, %rcx ## bit test
sbbb %cl, %cl
andb %al, %cl ## and the two conditions
andb $1, %cl
movzbl %cl, %eax ## returning an int
ret
(imho the backend should expand this into a series of branches, but
that's a different story)
The code is currently limited to bit fields that fit in a register, so
usually 64 or 32 bits. Sadly, this misses anything using alpha chars
or {}. This could be fixed by just emitting a i128 bit field, but that
can generate really ugly code so we have to find a better way. To some
degree this is also recreating switch lowering logic, but we can't
simply emit a switch instruction and thus change the CFG within
instcombine.
llvm-svn: 232902
2015-03-22 05:09:33 +08:00
|
|
|
// From now on we need at least constant length and string.
|
2015-03-21 23:36:21 +08:00
|
|
|
StringRef Str;
|
[SimplifyLibCalls] Turn memchr(const, C, const) into a bitfield check.
strchr("123!", C) != nullptr is a common pattern to check if C is one
of 1, 2, 3 or !. If the largest element of the string is smaller than
the target's register size we can easily create a bitfield and just
do a simple test for set membership.
int foo(char C) { return strchr("123!", C) != nullptr; } now becomes
cmpl $64, %edi ## range check
sbbb %al, %al
movabsq $0xE000200000001, %rcx
btq %rdi, %rcx ## bit test
sbbb %cl, %cl
andb %al, %cl ## and the two conditions
andb $1, %cl
movzbl %cl, %eax ## returning an int
ret
(imho the backend should expand this into a series of branches, but
that's a different story)
The code is currently limited to bit fields that fit in a register, so
usually 64 or 32 bits. Sadly, this misses anything using alpha chars
or {}. This could be fixed by just emitting a i128 bit field, but that
can generate really ugly code so we have to find a better way. To some
degree this is also recreating switch lowering logic, but we can't
simply emit a switch instruction and thus change the CFG within
instcombine.
llvm-svn: 232902
2015-03-22 05:09:33 +08:00
|
|
|
if (!LenC || !getConstantStringInfo(SrcStr, Str, 0, /*TrimAtNul=*/false))
|
2015-03-21 23:36:21 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Truncate the string to LenC. If Str is smaller than LenC we will still only
|
|
|
|
// scan the string, as reading past the end of it is undefined and we can just
|
|
|
|
// return null if we don't find the char.
|
|
|
|
Str = Str.substr(0, LenC->getZExtValue());
|
|
|
|
|
[SimplifyLibCalls] Turn memchr(const, C, const) into a bitfield check.
strchr("123!", C) != nullptr is a common pattern to check if C is one
of 1, 2, 3 or !. If the largest element of the string is smaller than
the target's register size we can easily create a bitfield and just
do a simple test for set membership.
int foo(char C) { return strchr("123!", C) != nullptr; } now becomes
cmpl $64, %edi ## range check
sbbb %al, %al
movabsq $0xE000200000001, %rcx
btq %rdi, %rcx ## bit test
sbbb %cl, %cl
andb %al, %cl ## and the two conditions
andb $1, %cl
movzbl %cl, %eax ## returning an int
ret
(imho the backend should expand this into a series of branches, but
that's a different story)
The code is currently limited to bit fields that fit in a register, so
usually 64 or 32 bits. Sadly, this misses anything using alpha chars
or {}. This could be fixed by just emitting a i128 bit field, but that
can generate really ugly code so we have to find a better way. To some
degree this is also recreating switch lowering logic, but we can't
simply emit a switch instruction and thus change the CFG within
instcombine.
llvm-svn: 232902
2015-03-22 05:09:33 +08:00
|
|
|
// If the char is variable but the input str and length are not we can turn
|
|
|
|
// this memchr call into a simple bit field test. Of course this only works
|
|
|
|
// when the return value is only checked against null.
|
|
|
|
//
|
|
|
|
// It would be really nice to reuse switch lowering here but we can't change
|
|
|
|
// the CFG at this point.
|
|
|
|
//
|
|
|
|
// memchr("\r\n", C, 2) != nullptr -> (C & ((1 << '\r') | (1 << '\n'))) != 0
|
|
|
|
// after bounds check.
|
|
|
|
if (!CharC && !Str.empty() && isOnlyUsedInZeroEqualityComparison(CI)) {
|
2015-03-22 06:04:26 +08:00
|
|
|
unsigned char Max =
|
|
|
|
*std::max_element(reinterpret_cast<const unsigned char *>(Str.begin()),
|
|
|
|
reinterpret_cast<const unsigned char *>(Str.end()));
|
[SimplifyLibCalls] Turn memchr(const, C, const) into a bitfield check.
strchr("123!", C) != nullptr is a common pattern to check if C is one
of 1, 2, 3 or !. If the largest element of the string is smaller than
the target's register size we can easily create a bitfield and just
do a simple test for set membership.
int foo(char C) { return strchr("123!", C) != nullptr; } now becomes
cmpl $64, %edi ## range check
sbbb %al, %al
movabsq $0xE000200000001, %rcx
btq %rdi, %rcx ## bit test
sbbb %cl, %cl
andb %al, %cl ## and the two conditions
andb $1, %cl
movzbl %cl, %eax ## returning an int
ret
(imho the backend should expand this into a series of branches, but
that's a different story)
The code is currently limited to bit fields that fit in a register, so
usually 64 or 32 bits. Sadly, this misses anything using alpha chars
or {}. This could be fixed by just emitting a i128 bit field, but that
can generate really ugly code so we have to find a better way. To some
degree this is also recreating switch lowering logic, but we can't
simply emit a switch instruction and thus change the CFG within
instcombine.
llvm-svn: 232902
2015-03-22 05:09:33 +08:00
|
|
|
|
|
|
|
// Make sure the bit field we're about to create fits in a register on the
|
|
|
|
// target.
|
|
|
|
// FIXME: On a 64 bit architecture this prevents us from using the
|
|
|
|
// interesting range of alpha ascii chars. We could do better by emitting
|
|
|
|
// two bitfields or shifting the range by 64 if no lower chars are used.
|
|
|
|
if (!DL.fitsInLegalInteger(Max + 1))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// For the bit field use a power-of-2 type with at least 8 bits to avoid
|
|
|
|
// creating unnecessary illegal types.
|
|
|
|
unsigned char Width = NextPowerOf2(std::max((unsigned char)7, Max));
|
|
|
|
|
|
|
|
// Now build the bit field.
|
|
|
|
APInt Bitfield(Width, 0);
|
|
|
|
for (char C : Str)
|
|
|
|
Bitfield.setBit((unsigned char)C);
|
|
|
|
Value *BitfieldC = B.getInt(Bitfield);
|
|
|
|
|
|
|
|
// First check that the bit field access is within bounds.
|
|
|
|
Value *C = B.CreateZExtOrTrunc(CI->getArgOperand(1), BitfieldC->getType());
|
|
|
|
Value *Bounds = B.CreateICmp(ICmpInst::ICMP_ULT, C, B.getIntN(Width, Width),
|
|
|
|
"memchr.bounds");
|
|
|
|
|
|
|
|
// Create code that checks if the given bit is set in the field.
|
|
|
|
Value *Shl = B.CreateShl(B.getIntN(Width, 1ULL), C);
|
|
|
|
Value *Bits = B.CreateIsNotNull(B.CreateAnd(Shl, BitfieldC), "memchr.bits");
|
|
|
|
|
|
|
|
// Finally merge both checks and cast to pointer type. The inttoptr
|
|
|
|
// implicitly zexts the i1 to intptr type.
|
|
|
|
return B.CreateIntToPtr(B.CreateAnd(Bounds, Bits, "memchr"), CI->getType());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if all arguments are constants. If so, we can constant fold.
|
|
|
|
if (!CharC)
|
|
|
|
return nullptr;
|
|
|
|
|
2015-03-21 23:36:21 +08:00
|
|
|
// Compute the offset.
|
|
|
|
size_t I = Str.find(CharC->getSExtValue() & 0xFF);
|
|
|
|
if (I == StringRef::npos) // Didn't find the char. memchr returns null.
|
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
|
|
|
// memchr(s+n,c,l) -> gep(s+n+i,c)
|
2015-03-31 04:42:56 +08:00
|
|
|
return B.CreateGEP(B.getInt8Ty(), SrcStr, B.getInt64(I), "memchr");
|
2015-03-21 23:36:21 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeMemCmp(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 3 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
|
|
|
!FT->getReturnType()->isIntegerTy(32))
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2012-11-11 13:11:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LHS = CI->getArgOperand(0), *RHS = CI->getArgOperand(1);
|
2012-11-11 13:54:34 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (LHS == RHS) // memcmp(s,s,x) -> 0
|
|
|
|
return Constant::getNullValue(CI->getType());
|
2012-11-11 13:54:34 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Make sure we have a constant length.
|
|
|
|
ConstantInt *LenC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
|
|
|
|
if (!LenC)
|
|
|
|
return nullptr;
|
|
|
|
uint64_t Len = LenC->getZExtValue();
|
|
|
|
|
|
|
|
if (Len == 0) // memcmp(s1,s2,0) -> 0
|
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
|
|
|
// memcmp(S1,S2,1) -> *(unsigned char*)LHS - *(unsigned char*)RHS
|
|
|
|
if (Len == 1) {
|
|
|
|
Value *LHSV = B.CreateZExt(B.CreateLoad(CastToCStr(LHS, B), "lhsc"),
|
|
|
|
CI->getType(), "lhsv");
|
|
|
|
Value *RHSV = B.CreateZExt(B.CreateLoad(CastToCStr(RHS, B), "rhsc"),
|
|
|
|
CI->getType(), "rhsv");
|
|
|
|
return B.CreateSub(LHSV, RHSV, "chardiff");
|
|
|
|
}
|
|
|
|
|
2015-08-29 02:30:18 +08:00
|
|
|
// memcmp(S1,S2,N/8)==0 -> (*(intN_t*)S1 != *(intN_t*)S2)==0
|
|
|
|
if (DL.isLegalInteger(Len * 8) && isOnlyUsedInZeroEqualityComparison(CI)) {
|
|
|
|
|
|
|
|
IntegerType *IntType = IntegerType::get(CI->getContext(), Len * 8);
|
|
|
|
unsigned PrefAlignment = DL.getPrefTypeAlignment(IntType);
|
|
|
|
|
|
|
|
if (getKnownAlignment(LHS, DL, CI) >= PrefAlignment &&
|
|
|
|
getKnownAlignment(RHS, DL, CI) >= PrefAlignment) {
|
|
|
|
|
|
|
|
Type *LHSPtrTy =
|
|
|
|
IntType->getPointerTo(LHS->getType()->getPointerAddressSpace());
|
|
|
|
Type *RHSPtrTy =
|
|
|
|
IntType->getPointerTo(RHS->getType()->getPointerAddressSpace());
|
|
|
|
|
|
|
|
Value *LHSV = B.CreateLoad(B.CreateBitCast(LHS, LHSPtrTy, "lhsc"), "lhsv");
|
|
|
|
Value *RHSV = B.CreateLoad(B.CreateBitCast(RHS, RHSPtrTy, "rhsc"), "rhsv");
|
|
|
|
|
|
|
|
return B.CreateZExt(B.CreateICmpNE(LHSV, RHSV), CI->getType(), "memcmp");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Constant folding: memcmp(x, y, l) -> cnst (all arguments are constant)
|
|
|
|
StringRef LHSStr, RHSStr;
|
|
|
|
if (getConstantStringInfo(LHS, LHSStr) &&
|
|
|
|
getConstantStringInfo(RHS, RHSStr)) {
|
|
|
|
// Make sure we're not reading out-of-bounds memory.
|
|
|
|
if (Len > LHSStr.size() || Len > RHSStr.size())
|
|
|
|
return nullptr;
|
|
|
|
// Fold the memcmp and normalize the result. This way we get consistent
|
|
|
|
// results across multiple platforms.
|
|
|
|
uint64_t Ret = 0;
|
|
|
|
int Cmp = memcmp(LHSStr.data(), RHSStr.data(), Len);
|
|
|
|
if (Cmp < 0)
|
|
|
|
Ret = -1;
|
|
|
|
else if (Cmp > 0)
|
|
|
|
Ret = 1;
|
|
|
|
return ConstantInt::get(CI->getType(), Ret);
|
2012-11-11 13:54:34 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-11 14:22:40 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
2012-11-11 14:22:40 +08:00
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memcpy))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
2012-11-11 14:22:40 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// memcpy(x, y, n) -> llvm.memcpy(x, y, n, 1)
|
|
|
|
B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
CI->getArgOperand(2), 1);
|
|
|
|
return CI->getArgOperand(0);
|
|
|
|
}
|
2012-11-11 14:49:03 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
2012-11-11 14:49:03 +08:00
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memmove))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// memmove(x, y, n) -> llvm.memmove(x, y, n, 1)
|
|
|
|
B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
CI->getArgOperand(2), 1);
|
|
|
|
return CI->getArgOperand(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memset))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// memset(p, v, n) -> llvm.memset(p, v, n, 1)
|
|
|
|
Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
|
|
|
|
B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
|
|
|
|
return CI->getArgOperand(0);
|
|
|
|
}
|
2012-11-11 14:49:03 +08:00
|
|
|
|
2012-11-13 12:16:17 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Math Library Optimizations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-12-04 05:46:33 +08:00
|
|
|
/// Return a variant of Val with float type.
|
|
|
|
/// Currently this works in two cases: If Val is an FPExtension of a float
|
|
|
|
/// value to something bigger, simply return the operand.
|
|
|
|
/// If Val is a ConstantFP but can be converted to a float ConstantFP without
|
|
|
|
/// loss of precision do so.
|
|
|
|
static Value *valueHasFloatPrecision(Value *Val) {
|
|
|
|
if (FPExtInst *Cast = dyn_cast<FPExtInst>(Val)) {
|
|
|
|
Value *Op = Cast->getOperand(0);
|
|
|
|
if (Op->getType()->isFloatTy())
|
|
|
|
return Op;
|
|
|
|
}
|
|
|
|
if (ConstantFP *Const = dyn_cast<ConstantFP>(Val)) {
|
|
|
|
APFloat F = Const->getValueAPF();
|
2014-12-04 06:10:39 +08:00
|
|
|
bool losesInfo;
|
2014-12-04 05:46:33 +08:00
|
|
|
(void)F.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
|
2014-12-04 06:10:39 +08:00
|
|
|
&losesInfo);
|
|
|
|
if (!losesInfo)
|
2014-12-04 05:46:33 +08:00
|
|
|
return ConstantFP::get(Const->getContext(), F);
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2012-11-13 12:16:17 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Double -> Float Shrinking Optimizations for Unary Functions like 'floor'
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeUnaryDoubleFP(CallInst *CI, IRBuilder<> &B,
|
|
|
|
bool CheckRetType) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 1 || !FT->getReturnType()->isDoubleTy() ||
|
|
|
|
!FT->getParamType(0)->isDoubleTy())
|
|
|
|
return nullptr;
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (CheckRetType) {
|
|
|
|
// Check if all the uses for function like 'sin' are converted to float.
|
|
|
|
for (User *U : CI->users()) {
|
|
|
|
FPTruncInst *Cast = dyn_cast<FPTruncInst>(U);
|
|
|
|
if (!Cast || !Cast->getType()->isFloatTy())
|
|
|
|
return nullptr;
|
2012-11-13 12:16:17 +08:00
|
|
|
}
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// If this is something like 'floor((double)floatval)', convert to floorf.
|
2014-12-04 05:46:33 +08:00
|
|
|
Value *V = valueHasFloatPrecision(CI->getArgOperand(0));
|
|
|
|
if (V == nullptr)
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// floor((double)floatval) -> (double)floorf(floatval)
|
2014-10-24 05:52:45 +08:00
|
|
|
if (Callee->isIntrinsic()) {
|
|
|
|
Module *M = CI->getParent()->getParent()->getParent();
|
2015-05-21 01:16:39 +08:00
|
|
|
Intrinsic::ID IID = Callee->getIntrinsicID();
|
2014-10-24 05:52:45 +08:00
|
|
|
Function *F = Intrinsic::getDeclaration(M, IID, B.getFloatTy());
|
|
|
|
V = B.CreateCall(F, V);
|
|
|
|
} else {
|
|
|
|
// The call is a library call rather than an intrinsic.
|
|
|
|
V = EmitUnaryFloatFnCall(V, Callee->getName(), B, Callee->getAttributes());
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return B.CreateFPExt(V, B.getDoubleTy());
|
|
|
|
}
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2013-12-17 06:42:40 +08:00
|
|
|
// Double -> Float Shrinking Optimizations for Binary Functions like 'fmin/fmax'
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeBinaryDoubleFP(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// Just make sure this has 2 arguments of the same FP type, which match the
|
|
|
|
// result type.
|
|
|
|
if (FT->getNumParams() != 2 || FT->getReturnType() != FT->getParamType(0) ||
|
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
|
|
|
!FT->getParamType(0)->isFloatingPointTy())
|
|
|
|
return nullptr;
|
2013-12-17 06:42:40 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// If this is something like 'fmin((double)floatval1, (double)floatval2)',
|
2014-12-04 05:46:33 +08:00
|
|
|
// or fmin(1.0, (double)floatval), then we convert it to fminf.
|
|
|
|
Value *V1 = valueHasFloatPrecision(CI->getArgOperand(0));
|
|
|
|
if (V1 == nullptr)
|
|
|
|
return nullptr;
|
|
|
|
Value *V2 = valueHasFloatPrecision(CI->getArgOperand(1));
|
|
|
|
if (V2 == nullptr)
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
2013-12-17 06:42:40 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// fmin((double)floatval1, (double)floatval2)
|
2014-12-04 05:46:33 +08:00
|
|
|
// -> (double)fminf(floatval1, floatval2)
|
2014-10-24 05:52:45 +08:00
|
|
|
// TODO: Handle intrinsics in the same way as in optimizeUnaryDoubleFP().
|
2014-12-04 05:46:33 +08:00
|
|
|
Value *V = EmitBinaryFloatFnCall(V1, V2, Callee->getName(), B,
|
|
|
|
Callee->getAttributes());
|
2014-09-18 04:55:46 +08:00
|
|
|
return B.CreateFPExt(V, B.getDoubleTy());
|
|
|
|
}
|
2013-12-17 06:42:40 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeCos(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
Value *Ret = nullptr;
|
|
|
|
if (UnsafeFPShrink && Callee->getName() == "cos" && TLI->has(LibFunc::cosf)) {
|
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
|
|
|
}
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// Just make sure this has 1 argument of FP type, which matches the
|
|
|
|
// result type.
|
|
|
|
if (FT->getNumParams() != 1 || FT->getReturnType() != FT->getParamType(0) ||
|
|
|
|
!FT->getParamType(0)->isFloatingPointTy())
|
2012-11-13 12:16:17 +08:00
|
|
|
return Ret;
|
2014-09-18 04:55:46 +08:00
|
|
|
|
|
|
|
// cos(-x) -> cos(x)
|
|
|
|
Value *Op1 = CI->getArgOperand(0);
|
|
|
|
if (BinaryOperator::isFNeg(Op1)) {
|
|
|
|
BinaryOperator *BinExpr = cast<BinaryOperator>(Op1);
|
|
|
|
return B.CreateCall(Callee, BinExpr->getOperand(1), "cos");
|
2012-11-13 12:16:17 +08:00
|
|
|
}
|
2014-09-18 04:55:46 +08:00
|
|
|
return Ret;
|
|
|
|
}
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizePow(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Ret = nullptr;
|
|
|
|
if (UnsafeFPShrink && Callee->getName() == "pow" && TLI->has(LibFunc::powf)) {
|
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
|
|
|
}
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// Just make sure this has 2 arguments of the same FP type, which match the
|
|
|
|
// result type.
|
|
|
|
if (FT->getNumParams() != 2 || FT->getReturnType() != FT->getParamType(0) ||
|
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
|
|
|
!FT->getParamType(0)->isFloatingPointTy())
|
|
|
|
return Ret;
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Op1 = CI->getArgOperand(0), *Op2 = CI->getArgOperand(1);
|
|
|
|
if (ConstantFP *Op1C = dyn_cast<ConstantFP>(Op1)) {
|
|
|
|
// pow(1.0, x) -> 1.0
|
|
|
|
if (Op1C->isExactlyValue(1.0))
|
|
|
|
return Op1C;
|
|
|
|
// pow(2.0, x) -> exp2(x)
|
|
|
|
if (Op1C->isExactlyValue(2.0) &&
|
|
|
|
hasUnaryFloatFn(TLI, Op1->getType(), LibFunc::exp2, LibFunc::exp2f,
|
|
|
|
LibFunc::exp2l))
|
|
|
|
return EmitUnaryFloatFnCall(Op2, "exp2", B, Callee->getAttributes());
|
|
|
|
// pow(10.0, x) -> exp10(x)
|
|
|
|
if (Op1C->isExactlyValue(10.0) &&
|
|
|
|
hasUnaryFloatFn(TLI, Op1->getType(), LibFunc::exp10, LibFunc::exp10f,
|
|
|
|
LibFunc::exp10l))
|
|
|
|
return EmitUnaryFloatFnCall(Op2, TLI->getName(LibFunc::exp10), B,
|
|
|
|
Callee->getAttributes());
|
|
|
|
}
|
|
|
|
|
|
|
|
ConstantFP *Op2C = dyn_cast<ConstantFP>(Op2);
|
|
|
|
if (!Op2C)
|
2012-11-13 12:16:17 +08:00
|
|
|
return Ret;
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (Op2C->getValueAPF().isZero()) // pow(x, 0.0) -> 1.0
|
|
|
|
return ConstantFP::get(CI->getType(), 1.0);
|
|
|
|
|
|
|
|
if (Op2C->isExactlyValue(0.5) &&
|
|
|
|
hasUnaryFloatFn(TLI, Op2->getType(), LibFunc::sqrt, LibFunc::sqrtf,
|
|
|
|
LibFunc::sqrtl) &&
|
|
|
|
hasUnaryFloatFn(TLI, Op2->getType(), LibFunc::fabs, LibFunc::fabsf,
|
|
|
|
LibFunc::fabsl)) {
|
|
|
|
// Expand pow(x, 0.5) to (x == -infinity ? +infinity : fabs(sqrt(x))).
|
|
|
|
// This is faster than calling pow, and still handles negative zero
|
|
|
|
// and negative infinity correctly.
|
|
|
|
// TODO: In fast-math mode, this could be just sqrt(x).
|
|
|
|
// TODO: In finite-only mode, this could be just fabs(sqrt(x)).
|
|
|
|
Value *Inf = ConstantFP::getInfinity(CI->getType());
|
|
|
|
Value *NegInf = ConstantFP::getInfinity(CI->getType(), true);
|
|
|
|
Value *Sqrt = EmitUnaryFloatFnCall(Op1, "sqrt", B, Callee->getAttributes());
|
|
|
|
Value *FAbs =
|
|
|
|
EmitUnaryFloatFnCall(Sqrt, "fabs", B, Callee->getAttributes());
|
|
|
|
Value *FCmp = B.CreateFCmpOEQ(Op1, NegInf);
|
|
|
|
Value *Sel = B.CreateSelect(FCmp, Inf, FAbs);
|
|
|
|
return Sel;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Op2C->isExactlyValue(1.0)) // pow(x, 1.0) -> x
|
|
|
|
return Op1;
|
|
|
|
if (Op2C->isExactlyValue(2.0)) // pow(x, 2.0) -> x*x
|
|
|
|
return B.CreateFMul(Op1, Op1, "pow2");
|
|
|
|
if (Op2C->isExactlyValue(-1.0)) // pow(x, -1.0) -> 1.0/x
|
|
|
|
return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), Op1, "powrecip");
|
|
|
|
return nullptr;
|
|
|
|
}
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeExp2(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
Function *Caller = CI->getParent()->getParent();
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Ret = nullptr;
|
|
|
|
if (UnsafeFPShrink && Callee->getName() == "exp2" &&
|
|
|
|
TLI->has(LibFunc::exp2f)) {
|
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
|
|
|
}
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// Just make sure this has 1 argument of FP type, which matches the
|
|
|
|
// result type.
|
|
|
|
if (FT->getNumParams() != 1 || FT->getReturnType() != FT->getParamType(0) ||
|
|
|
|
!FT->getParamType(0)->isFloatingPointTy())
|
|
|
|
return Ret;
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Op = CI->getArgOperand(0);
|
|
|
|
// Turn exp2(sitofp(x)) -> ldexp(1.0, sext(x)) if sizeof(x) <= 32
|
|
|
|
// Turn exp2(uitofp(x)) -> ldexp(1.0, zext(x)) if sizeof(x) < 32
|
|
|
|
LibFunc::Func LdExp = LibFunc::ldexpl;
|
|
|
|
if (Op->getType()->isFloatTy())
|
|
|
|
LdExp = LibFunc::ldexpf;
|
|
|
|
else if (Op->getType()->isDoubleTy())
|
|
|
|
LdExp = LibFunc::ldexp;
|
|
|
|
|
|
|
|
if (TLI->has(LdExp)) {
|
|
|
|
Value *LdExpArg = nullptr;
|
|
|
|
if (SIToFPInst *OpC = dyn_cast<SIToFPInst>(Op)) {
|
|
|
|
if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() <= 32)
|
|
|
|
LdExpArg = B.CreateSExt(OpC->getOperand(0), B.getInt32Ty());
|
|
|
|
} else if (UIToFPInst *OpC = dyn_cast<UIToFPInst>(Op)) {
|
|
|
|
if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() < 32)
|
|
|
|
LdExpArg = B.CreateZExt(OpC->getOperand(0), B.getInt32Ty());
|
|
|
|
}
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (LdExpArg) {
|
|
|
|
Constant *One = ConstantFP::get(CI->getContext(), APFloat(1.0f));
|
|
|
|
if (!Op->getType()->isFloatTy())
|
|
|
|
One = ConstantExpr::getFPExtend(One, Op->getType());
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Module *M = Caller->getParent();
|
|
|
|
Value *Callee =
|
|
|
|
M->getOrInsertFunction(TLI->getName(LdExp), Op->getType(),
|
2014-11-14 06:55:19 +08:00
|
|
|
Op->getType(), B.getInt32Ty(), nullptr);
|
2015-05-19 06:13:54 +08:00
|
|
|
CallInst *CI = B.CreateCall(Callee, {One, LdExpArg});
|
2014-09-18 04:55:46 +08:00
|
|
|
if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
|
|
|
|
CI->setCallingConv(F->getCallingConv());
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return CI;
|
2013-11-03 14:48:38 +08:00
|
|
|
}
|
|
|
|
}
|
2014-09-18 04:55:46 +08:00
|
|
|
return Ret;
|
|
|
|
}
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-10-15 04:43:11 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFabs(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
|
|
|
|
Value *Ret = nullptr;
|
|
|
|
if (Callee->getName() == "fabs" && TLI->has(LibFunc::fabsf)) {
|
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// Make sure this has 1 argument of FP type which matches the result type.
|
|
|
|
if (FT->getNumParams() != 1 || FT->getReturnType() != FT->getParamType(0) ||
|
|
|
|
!FT->getParamType(0)->isFloatingPointTy())
|
|
|
|
return Ret;
|
|
|
|
|
|
|
|
Value *Op = CI->getArgOperand(0);
|
|
|
|
if (Instruction *I = dyn_cast<Instruction>(Op)) {
|
|
|
|
// Fold fabs(x * x) -> x * x; any squared FP value must already be positive.
|
|
|
|
if (I->getOpcode() == Instruction::FMul)
|
|
|
|
if (I->getOperand(0) == I->getOperand(1))
|
|
|
|
return Op;
|
|
|
|
}
|
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
2015-08-17 04:18:19 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFMinFMax(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// If we can shrink the call to a float function rather than a double
|
|
|
|
// function, do that first.
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
if ((Callee->getName() == "fmin" && TLI->has(LibFunc::fminf)) ||
|
|
|
|
(Callee->getName() == "fmax" && TLI->has(LibFunc::fmaxf))) {
|
|
|
|
Value *Ret = optimizeBinaryDoubleFP(CI, B);
|
|
|
|
if (Ret)
|
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure this has 2 arguments of FP type which match the result type.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || FT->getReturnType() != FT->getParamType(0) ||
|
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
|
|
|
!FT->getParamType(0)->isFloatingPointTy())
|
|
|
|
return nullptr;
|
|
|
|
|
2015-08-17 05:16:37 +08:00
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
2015-08-17 04:18:19 +08:00
|
|
|
FastMathFlags FMF;
|
|
|
|
Function *F = CI->getParent()->getParent();
|
2015-10-29 10:58:44 +08:00
|
|
|
if (canUseUnsafeFPMath(F)) {
|
2015-08-17 04:18:19 +08:00
|
|
|
// Unsafe algebra sets all fast-math-flags to true.
|
|
|
|
FMF.setUnsafeAlgebra();
|
|
|
|
} else {
|
|
|
|
// At a minimum, no-nans-fp-math must be true.
|
2015-10-29 10:58:44 +08:00
|
|
|
Attribute Attr = F->getFnAttribute("no-nans-fp-math");
|
2015-08-17 04:18:19 +08:00
|
|
|
if (Attr.getValueAsString() != "true")
|
|
|
|
return nullptr;
|
|
|
|
// No-signed-zeros is implied by the definitions of fmax/fmin themselves:
|
|
|
|
// "Ideally, fmax would be sensitive to the sign of zero, for example
|
2015-09-07 08:26:54 +08:00
|
|
|
// fmax(-0. 0, +0. 0) would return +0; however, implementation in software
|
2015-08-17 04:18:19 +08:00
|
|
|
// might be impractical."
|
|
|
|
FMF.setNoSignedZeros();
|
|
|
|
FMF.setNoNaNs();
|
|
|
|
}
|
|
|
|
B.SetFastMathFlags(FMF);
|
|
|
|
|
|
|
|
// We have a relaxed floating-point environment. We can ignore NaN-handling
|
|
|
|
// and transform to a compare and select. We do not have to consider errno or
|
|
|
|
// exceptions, because fmin/fmax do not have those.
|
|
|
|
Value *Op0 = CI->getArgOperand(0);
|
|
|
|
Value *Op1 = CI->getArgOperand(1);
|
|
|
|
Value *Cmp = Callee->getName().startswith("fmin") ?
|
|
|
|
B.CreateFCmpOLT(Op0, Op1) : B.CreateFCmpOGT(Op0, Op1);
|
|
|
|
return B.CreateSelect(Cmp, Op0, Op1);
|
|
|
|
}
|
|
|
|
|
2014-10-17 02:48:17 +08:00
|
|
|
Value *LibCallSimplifier::optimizeSqrt(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
|
|
|
|
Value *Ret = nullptr;
|
2014-10-24 05:52:45 +08:00
|
|
|
if (TLI->has(LibFunc::sqrtf) && (Callee->getName() == "sqrt" ||
|
|
|
|
Callee->getIntrinsicID() == Intrinsic::sqrt))
|
2014-10-17 02:48:17 +08:00
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
2015-10-29 10:58:44 +08:00
|
|
|
if (!canUseUnsafeFPMath(CI->getParent()->getParent()))
|
|
|
|
return Ret;
|
2014-10-17 02:48:17 +08:00
|
|
|
|
|
|
|
Value *Op = CI->getArgOperand(0);
|
|
|
|
if (Instruction *I = dyn_cast<Instruction>(Op)) {
|
|
|
|
if (I->getOpcode() == Instruction::FMul && I->hasUnsafeAlgebra()) {
|
|
|
|
// We're looking for a repeated factor in a multiplication tree,
|
|
|
|
// so we can do this fold: sqrt(x * x) -> fabs(x);
|
|
|
|
// or this fold: sqrt(x * x * y) -> fabs(x) * sqrt(y).
|
|
|
|
Value *Op0 = I->getOperand(0);
|
|
|
|
Value *Op1 = I->getOperand(1);
|
|
|
|
Value *RepeatOp = nullptr;
|
|
|
|
Value *OtherOp = nullptr;
|
|
|
|
if (Op0 == Op1) {
|
|
|
|
// Simple match: the operands of the multiply are identical.
|
|
|
|
RepeatOp = Op0;
|
|
|
|
} else {
|
|
|
|
// Look for a more complicated pattern: one of the operands is itself
|
|
|
|
// a multiply, so search for a common factor in that multiply.
|
|
|
|
// Note: We don't bother looking any deeper than this first level or for
|
|
|
|
// variations of this pattern because instcombine's visitFMUL and/or the
|
|
|
|
// reassociation pass should give us this form.
|
|
|
|
Value *OtherMul0, *OtherMul1;
|
|
|
|
if (match(Op0, m_FMul(m_Value(OtherMul0), m_Value(OtherMul1)))) {
|
|
|
|
// Pattern: sqrt((x * y) * z)
|
|
|
|
if (OtherMul0 == OtherMul1) {
|
|
|
|
// Matched: sqrt((x * x) * z)
|
|
|
|
RepeatOp = OtherMul0;
|
|
|
|
OtherOp = Op1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (RepeatOp) {
|
|
|
|
// Fast math flags for any created instructions should match the sqrt
|
|
|
|
// and multiply.
|
|
|
|
// FIXME: We're not checking the sqrt because it doesn't have
|
|
|
|
// fast-math-flags (see earlier comment).
|
2015-08-17 05:16:37 +08:00
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
2014-10-17 02:48:17 +08:00
|
|
|
B.SetFastMathFlags(I->getFastMathFlags());
|
|
|
|
// If we found a repeated factor, hoist it out of the square root and
|
|
|
|
// replace it with the fabs of that factor.
|
|
|
|
Module *M = Callee->getParent();
|
|
|
|
Type *ArgType = Op->getType();
|
|
|
|
Value *Fabs = Intrinsic::getDeclaration(M, Intrinsic::fabs, ArgType);
|
|
|
|
Value *FabsCall = B.CreateCall(Fabs, RepeatOp, "fabs");
|
|
|
|
if (OtherOp) {
|
|
|
|
// If we found a non-repeated factor, we still need to get its square
|
|
|
|
// root. We then multiply that by the value that was simplified out
|
|
|
|
// of the square root calculation.
|
|
|
|
Value *Sqrt = Intrinsic::getDeclaration(M, Intrinsic::sqrt, ArgType);
|
|
|
|
Value *SqrtCall = B.CreateCall(Sqrt, OtherOp, "sqrt");
|
|
|
|
return B.CreateFMul(FabsCall, SqrtCall);
|
|
|
|
}
|
|
|
|
return FabsCall;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
static bool isTrigLibCall(CallInst *CI);
|
|
|
|
static void insertSinCosCall(IRBuilder<> &B, Function *OrigCallee, Value *Arg,
|
|
|
|
bool UseFloat, Value *&Sin, Value *&Cos,
|
|
|
|
Value *&SinCos);
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeSinCosPi(CallInst *CI, IRBuilder<> &B) {
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Make sure the prototype is as expected, otherwise the rest of the
|
|
|
|
// function is probably invalid and likely to abort.
|
|
|
|
if (!isTrigLibCall(CI))
|
|
|
|
return nullptr;
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Arg = CI->getArgOperand(0);
|
|
|
|
SmallVector<CallInst *, 1> SinCalls;
|
|
|
|
SmallVector<CallInst *, 1> CosCalls;
|
|
|
|
SmallVector<CallInst *, 1> SinCosCalls;
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
bool IsFloat = Arg->getType()->isFloatTy();
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Look for all compatible sinpi, cospi and sincospi calls with the same
|
|
|
|
// argument. If there are enough (in some sense) we can make the
|
|
|
|
// substitution.
|
|
|
|
for (User *U : Arg->users())
|
|
|
|
classifyArgUse(U, CI->getParent(), IsFloat, SinCalls, CosCalls,
|
|
|
|
SinCosCalls);
|
2012-11-26 04:45:27 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// It's only worthwhile if both sinpi and cospi are actually used.
|
|
|
|
if (SinCosCalls.empty() && (SinCalls.empty() || CosCalls.empty()))
|
|
|
|
return nullptr;
|
2012-11-26 04:45:27 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Sin, *Cos, *SinCos;
|
|
|
|
insertSinCosCall(B, CI->getCalledFunction(), Arg, IsFloat, Sin, Cos, SinCos);
|
2012-11-26 04:45:27 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
replaceTrigInsts(SinCalls, Sin);
|
|
|
|
replaceTrigInsts(CosCalls, Cos);
|
|
|
|
replaceTrigInsts(SinCosCalls, SinCos);
|
2012-11-26 04:45:27 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-26 08:24:07 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
static bool isTrigLibCall(CallInst *CI) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
|
|
|
|
// We can only hope to do anything useful if we can ignore things like errno
|
|
|
|
// and floating-point exceptions.
|
|
|
|
bool AttributesSafe =
|
|
|
|
CI->hasFnAttr(Attribute::NoUnwind) && CI->hasFnAttr(Attribute::ReadNone);
|
|
|
|
|
|
|
|
// Other than that we need float(float) or double(double)
|
|
|
|
return AttributesSafe && FT->getNumParams() == 1 &&
|
|
|
|
FT->getReturnType() == FT->getParamType(0) &&
|
|
|
|
(FT->getParamType(0)->isFloatTy() ||
|
|
|
|
FT->getParamType(0)->isDoubleTy());
|
|
|
|
}
|
2012-11-26 10:31:59 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
void
|
|
|
|
LibCallSimplifier::classifyArgUse(Value *Val, BasicBlock *BB, bool IsFloat,
|
|
|
|
SmallVectorImpl<CallInst *> &SinCalls,
|
|
|
|
SmallVectorImpl<CallInst *> &CosCalls,
|
|
|
|
SmallVectorImpl<CallInst *> &SinCosCalls) {
|
|
|
|
CallInst *CI = dyn_cast<CallInst>(Val);
|
|
|
|
|
|
|
|
if (!CI)
|
|
|
|
return;
|
2012-11-26 11:10:07 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
StringRef FuncName = Callee->getName();
|
|
|
|
LibFunc::Func Func;
|
|
|
|
if (!TLI->getLibFunc(FuncName, Func) || !TLI->has(Func) || !isTrigLibCall(CI))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (IsFloat) {
|
|
|
|
if (Func == LibFunc::sinpif)
|
|
|
|
SinCalls.push_back(CI);
|
|
|
|
else if (Func == LibFunc::cospif)
|
|
|
|
CosCalls.push_back(CI);
|
|
|
|
else if (Func == LibFunc::sincospif_stret)
|
|
|
|
SinCosCalls.push_back(CI);
|
|
|
|
} else {
|
|
|
|
if (Func == LibFunc::sinpi)
|
|
|
|
SinCalls.push_back(CI);
|
|
|
|
else if (Func == LibFunc::cospi)
|
|
|
|
CosCalls.push_back(CI);
|
|
|
|
else if (Func == LibFunc::sincospi_stret)
|
|
|
|
SinCosCalls.push_back(CI);
|
2012-11-26 11:10:07 +08:00
|
|
|
}
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
2012-11-26 11:10:07 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
void LibCallSimplifier::replaceTrigInsts(SmallVectorImpl<CallInst *> &Calls,
|
|
|
|
Value *Res) {
|
2015-10-27 12:17:51 +08:00
|
|
|
for (CallInst *C : Calls)
|
|
|
|
replaceAllUsesWith(C, Res);
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
2012-11-26 11:38:52 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
void insertSinCosCall(IRBuilder<> &B, Function *OrigCallee, Value *Arg,
|
|
|
|
bool UseFloat, Value *&Sin, Value *&Cos, Value *&SinCos) {
|
|
|
|
Type *ArgTy = Arg->getType();
|
|
|
|
Type *ResTy;
|
|
|
|
StringRef Name;
|
|
|
|
|
|
|
|
Triple T(OrigCallee->getParent()->getTargetTriple());
|
|
|
|
if (UseFloat) {
|
|
|
|
Name = "__sincospif_stret";
|
|
|
|
|
|
|
|
assert(T.getArch() != Triple::x86 && "x86 messy and unsupported for now");
|
|
|
|
// x86_64 can't use {float, float} since that would be returned in both
|
|
|
|
// xmm0 and xmm1, which isn't what a real struct would do.
|
|
|
|
ResTy = T.getArch() == Triple::x86_64
|
|
|
|
? static_cast<Type *>(VectorType::get(ArgTy, 2))
|
2014-11-14 06:55:19 +08:00
|
|
|
: static_cast<Type *>(StructType::get(ArgTy, ArgTy, nullptr));
|
2014-09-18 04:55:46 +08:00
|
|
|
} else {
|
|
|
|
Name = "__sincospi_stret";
|
2014-11-14 06:55:19 +08:00
|
|
|
ResTy = StructType::get(ArgTy, ArgTy, nullptr);
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Module *M = OrigCallee->getParent();
|
|
|
|
Value *Callee = M->getOrInsertFunction(Name, OrigCallee->getAttributes(),
|
2014-11-14 06:55:19 +08:00
|
|
|
ResTy, ArgTy, nullptr);
|
2014-09-18 04:55:46 +08:00
|
|
|
|
|
|
|
if (Instruction *ArgInst = dyn_cast<Instruction>(Arg)) {
|
|
|
|
// If the argument is an instruction, it must dominate all uses so put our
|
|
|
|
// sincos call there.
|
2015-10-13 10:39:05 +08:00
|
|
|
B.SetInsertPoint(ArgInst->getParent(), ++ArgInst->getIterator());
|
2014-09-18 04:55:46 +08:00
|
|
|
} else {
|
|
|
|
// Otherwise (e.g. for a constant) the beginning of the function is as
|
|
|
|
// good a place as any.
|
|
|
|
BasicBlock &EntryBB = B.GetInsertBlock()->getParent()->getEntryBlock();
|
|
|
|
B.SetInsertPoint(&EntryBB, EntryBB.begin());
|
|
|
|
}
|
|
|
|
|
|
|
|
SinCos = B.CreateCall(Callee, Arg, "sincospi");
|
|
|
|
|
|
|
|
if (SinCos->getType()->isStructTy()) {
|
|
|
|
Sin = B.CreateExtractValue(SinCos, 0, "sinpi");
|
|
|
|
Cos = B.CreateExtractValue(SinCos, 1, "cospi");
|
|
|
|
} else {
|
|
|
|
Sin = B.CreateExtractElement(SinCos, ConstantInt::get(B.getInt32Ty(), 0),
|
|
|
|
"sinpi");
|
|
|
|
Cos = B.CreateExtractElement(SinCos, ConstantInt::get(B.getInt32Ty(), 1),
|
|
|
|
"cospi");
|
2012-11-26 11:38:52 +08:00
|
|
|
}
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
2012-11-26 11:38:52 +08:00
|
|
|
|
2012-11-27 04:37:20 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2014-09-18 04:55:46 +08:00
|
|
|
// Integer Library Call Optimizations
|
2012-11-27 04:37:20 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-11-01 07:17:45 +08:00
|
|
|
static bool checkIntUnaryReturnAndParam(Function *Callee) {
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
2015-11-01 08:09:16 +08:00
|
|
|
return FT->getNumParams() == 1 && FT->getReturnType()->isIntegerTy(32) &&
|
|
|
|
FT->getParamType(0)->isIntegerTy();
|
2015-11-01 07:17:45 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFFS(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
2015-11-01 07:17:45 +08:00
|
|
|
if (!checkIntUnaryReturnAndParam(Callee))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
Value *Op = CI->getArgOperand(0);
|
2013-11-17 10:06:35 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Constant fold.
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
|
|
|
|
if (CI->isZero()) // ffs(0) -> 0.
|
|
|
|
return B.getInt32(0);
|
|
|
|
// ffs(c) -> cttz(c)+1
|
|
|
|
return B.getInt32(CI->getValue().countTrailingZeros() + 1);
|
|
|
|
}
|
2013-11-17 10:06:35 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// ffs(x) -> x != 0 ? (i32)llvm.cttz(x)+1 : 0
|
|
|
|
Type *ArgType = Op->getType();
|
|
|
|
Value *F =
|
|
|
|
Intrinsic::getDeclaration(Callee->getParent(), Intrinsic::cttz, ArgType);
|
[SimplifyLibCalls] Correctly set the is_zero_undef flag for llvm.cttz
If <src> is non-zero we can safely set the flag to true, and this
results in less code generated for, e.g. ffs(x) + 1 on FreeBSD.
Thanks to majnemer for suggesting the fix and reviewing.
Code generated before the patch was applied:
0: 0f bc c7 bsf %edi,%eax
3: b9 20 00 00 00 mov $0x20,%ecx
8: 0f 45 c8 cmovne %eax,%ecx
b: 83 c1 02 add $0x2,%ecx
e: b8 01 00 00 00 mov $0x1,%eax
13: 85 ff test %edi,%edi
15: 0f 45 c1 cmovne %ecx,%eax
18: c3 retq
Code generated after the patch was applied:
0: 0f bc cf bsf %edi,%ecx
3: 83 c1 02 add $0x2,%ecx
6: 85 ff test %edi,%edi
8: b8 01 00 00 00 mov $0x1,%eax
d: 0f 45 c1 cmovne %ecx,%eax
10: c3 retq
It seems we can still use cmove and save another 'test' instruction, but
that can be tackled separately.
Differential Revision: http://reviews.llvm.org/D11989
llvm-svn: 244947
2015-08-14 04:34:26 +08:00
|
|
|
Value *V = B.CreateCall(F, {Op, B.getTrue()}, "cttz");
|
2014-09-18 04:55:46 +08:00
|
|
|
V = B.CreateAdd(V, ConstantInt::get(V->getType(), 1));
|
|
|
|
V = B.CreateIntCast(V, B.getInt32Ty(), false);
|
2013-11-17 10:06:35 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Cond = B.CreateICmpNE(Op, Constant::getNullValue(ArgType));
|
|
|
|
return B.CreateSelect(Cond, V, B.getInt32(0));
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *LibCallSimplifier::optimizeAbs(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// We require integer(integer) where the types agree.
|
|
|
|
if (FT->getNumParams() != 1 || !FT->getReturnType()->isIntegerTy() ||
|
|
|
|
FT->getParamType(0) != FT->getReturnType())
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2013-11-17 10:06:35 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// abs(x) -> x >s -1 ? x : -x
|
|
|
|
Value *Op = CI->getArgOperand(0);
|
|
|
|
Value *Pos =
|
|
|
|
B.CreateICmpSGT(Op, Constant::getAllOnesValue(Op->getType()), "ispos");
|
|
|
|
Value *Neg = B.CreateNeg(Op, "neg");
|
|
|
|
return B.CreateSelect(Pos, Op, Neg);
|
|
|
|
}
|
2013-11-17 10:06:35 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeIsDigit(CallInst *CI, IRBuilder<> &B) {
|
2015-11-01 07:17:45 +08:00
|
|
|
if (!checkIntUnaryReturnAndParam(CI->getCalledFunction()))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
2013-11-17 10:06:35 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// isdigit(c) -> (c-'0') <u 10
|
|
|
|
Value *Op = CI->getArgOperand(0);
|
|
|
|
Op = B.CreateSub(Op, B.getInt32('0'), "isdigittmp");
|
|
|
|
Op = B.CreateICmpULT(Op, B.getInt32(10), "isdigit");
|
|
|
|
return B.CreateZExt(Op, CI->getType());
|
|
|
|
}
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeIsAscii(CallInst *CI, IRBuilder<> &B) {
|
2015-11-01 07:17:45 +08:00
|
|
|
if (!checkIntUnaryReturnAndParam(CI->getCalledFunction()))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// isascii(c) -> c <u 128
|
|
|
|
Value *Op = CI->getArgOperand(0);
|
|
|
|
Op = B.CreateICmpULT(Op, B.getInt32(128), "isascii");
|
|
|
|
return B.CreateZExt(Op, CI->getType());
|
|
|
|
}
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeToAscii(CallInst *CI, IRBuilder<> &B) {
|
2015-11-01 07:17:45 +08:00
|
|
|
if (!checkIntUnaryReturnAndParam(CI->getCalledFunction()))
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// toascii(c) -> c & 0x7f
|
|
|
|
return B.CreateAnd(CI->getArgOperand(0),
|
|
|
|
ConstantInt::get(CI->getType(), 0x7F));
|
|
|
|
}
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Formatting and IO Library Call Optimizations
|
|
|
|
//===----------------------------------------------------------------------===//
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg);
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
|
|
|
|
int StreamArg) {
|
|
|
|
// Error reporting calls should be cold, mark them as such.
|
|
|
|
// This applies even to non-builtin calls: it is only a hint and applies to
|
|
|
|
// functions that the frontend might not understand as builtins.
|
|
|
|
|
|
|
|
// This heuristic was suggested in:
|
|
|
|
// Improving Static Branch Prediction in a Compiler
|
|
|
|
// Brian L. Deitrich, Ben-Chung Cheng, Wen-mei W. Hwu
|
|
|
|
// Proceedings of PACT'98, Oct. 1998, IEEE
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
|
|
|
|
if (!CI->hasFnAttr(Attribute::Cold) &&
|
|
|
|
isReportingError(Callee, CI, StreamArg)) {
|
|
|
|
CI->addAttribute(AttributeSet::FunctionIndex, Attribute::Cold);
|
2012-11-27 04:37:20 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg) {
|
|
|
|
if (!ColdErrorCalls)
|
|
|
|
return false;
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (!Callee || !Callee->isDeclaration())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (StreamArg < 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// These functions might be considered cold, but only if their stream
|
|
|
|
// argument is stderr.
|
|
|
|
|
|
|
|
if (StreamArg >= (int)CI->getNumArgOperands())
|
|
|
|
return false;
|
|
|
|
LoadInst *LI = dyn_cast<LoadInst>(CI->getArgOperand(StreamArg));
|
|
|
|
if (!LI)
|
|
|
|
return false;
|
|
|
|
GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getPointerOperand());
|
|
|
|
if (!GV || !GV->isDeclaration())
|
|
|
|
return false;
|
|
|
|
return GV->getName() == "stderr";
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *LibCallSimplifier::optimizePrintFString(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// Check for a fixed format string.
|
|
|
|
StringRef FormatStr;
|
|
|
|
if (!getConstantStringInfo(CI->getArgOperand(0), FormatStr))
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2012-11-27 04:37:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Empty format string -> noop.
|
|
|
|
if (FormatStr.empty()) // Tolerate printf's declared void.
|
|
|
|
return CI->use_empty() ? (Value *)CI : ConstantInt::get(CI->getType(), 0);
|
2012-11-27 13:57:54 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Do not do any of the following transformations if the printf return value
|
|
|
|
// is used, in general the printf return value is not compatible with either
|
|
|
|
// putchar() or puts().
|
|
|
|
if (!CI->use_empty())
|
|
|
|
return nullptr;
|
2012-11-27 13:57:54 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// printf("x") -> putchar('x'), even for '%'.
|
|
|
|
if (FormatStr.size() == 1) {
|
2015-03-10 10:37:25 +08:00
|
|
|
Value *Res = EmitPutChar(B.getInt32(FormatStr[0]), B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
if (CI->use_empty() || !Res)
|
|
|
|
return Res;
|
|
|
|
return B.CreateIntCast(Res, CI->getType(), true);
|
|
|
|
}
|
2012-11-27 13:57:54 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// printf("foo\n") --> puts("foo")
|
|
|
|
if (FormatStr[FormatStr.size() - 1] == '\n' &&
|
|
|
|
FormatStr.find('%') == StringRef::npos) { // No format characters.
|
|
|
|
// Create a string literal with no \n on it. We expect the constant merge
|
|
|
|
// pass to be run after this pass, to merge duplicate strings.
|
|
|
|
FormatStr = FormatStr.drop_back();
|
|
|
|
Value *GV = B.CreateGlobalString(FormatStr, "str");
|
2015-03-10 10:37:25 +08:00
|
|
|
Value *NewCI = EmitPutS(GV, B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
return (CI->use_empty() || !NewCI)
|
|
|
|
? NewCI
|
|
|
|
: ConstantInt::get(CI->getType(), FormatStr.size() + 1);
|
|
|
|
}
|
2012-11-27 13:57:54 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Optimize specific format strings.
|
|
|
|
// printf("%c", chr) --> putchar(chr)
|
|
|
|
if (FormatStr == "%c" && CI->getNumArgOperands() > 1 &&
|
|
|
|
CI->getArgOperand(1)->getType()->isIntegerTy()) {
|
2015-03-10 10:37:25 +08:00
|
|
|
Value *Res = EmitPutChar(CI->getArgOperand(1), B, TLI);
|
2012-11-27 13:57:54 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (CI->use_empty() || !Res)
|
|
|
|
return Res;
|
|
|
|
return B.CreateIntCast(Res, CI->getType(), true);
|
|
|
|
}
|
2012-11-27 13:57:54 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// printf("%s\n", str) --> puts(str)
|
|
|
|
if (FormatStr == "%s\n" && CI->getNumArgOperands() > 1 &&
|
|
|
|
CI->getArgOperand(1)->getType()->isPointerTy()) {
|
2015-03-10 10:37:25 +08:00
|
|
|
return EmitPutS(CI->getArgOperand(1), B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-27 13:57:54 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizePrintF(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Require one fixed pointer argument and an integer/void result.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() < 1 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!(FT->getReturnType()->isIntegerTy() || FT->getReturnType()->isVoidTy()))
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2014-09-18 04:55:46 +08:00
|
|
|
|
|
|
|
if (Value *V = optimizePrintFString(CI, B)) {
|
|
|
|
return V;
|
2012-11-27 13:57:54 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// printf(format, ...) -> iprintf(format, ...) if no floating point
|
|
|
|
// arguments.
|
|
|
|
if (TLI->has(LibFunc::iprintf) && !callHasFloatingPointArgument(CI)) {
|
|
|
|
Module *M = B.GetInsertBlock()->getParent()->getParent();
|
|
|
|
Constant *IPrintFFn =
|
|
|
|
M->getOrInsertFunction("iprintf", FT, Callee->getAttributes());
|
|
|
|
CallInst *New = cast<CallInst>(CI->clone());
|
|
|
|
New->setCalledFunction(IPrintFFn);
|
|
|
|
B.Insert(New);
|
|
|
|
return New;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *LibCallSimplifier::optimizeSPrintFString(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// Check for a fixed format string.
|
|
|
|
StringRef FormatStr;
|
|
|
|
if (!getConstantStringInfo(CI->getArgOperand(1), FormatStr))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// If we just have a format string (nothing else crazy) transform it.
|
|
|
|
if (CI->getNumArgOperands() == 2) {
|
|
|
|
// Make sure there's no % in the constant array. We could try to handle
|
|
|
|
// %% -> % in the future if we cared.
|
|
|
|
for (unsigned i = 0, e = FormatStr.size(); i != e; ++i)
|
|
|
|
if (FormatStr[i] == '%')
|
|
|
|
return nullptr; // we found a format specifier, bail out.
|
|
|
|
|
|
|
|
// sprintf(str, fmt) -> llvm.memcpy(str, fmt, strlen(fmt)+1, 1)
|
2015-03-10 10:37:25 +08:00
|
|
|
B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
ConstantInt::get(DL.getIntPtrType(CI->getContext()),
|
|
|
|
FormatStr.size() + 1),
|
|
|
|
1); // Copy the null byte.
|
2014-09-18 04:55:46 +08:00
|
|
|
return ConstantInt::get(CI->getType(), FormatStr.size());
|
|
|
|
}
|
2012-11-27 13:57:54 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// The remaining optimizations require the format string to be "%s" or "%c"
|
|
|
|
// and have an extra operand.
|
|
|
|
if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
|
|
|
|
CI->getNumArgOperands() < 3)
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2014-09-18 04:55:46 +08:00
|
|
|
|
|
|
|
// Decode the second character of the format string.
|
|
|
|
if (FormatStr[1] == 'c') {
|
|
|
|
// sprintf(dst, "%c", chr) --> *(i8*)dst = chr; *((i8*)dst+1) = 0
|
|
|
|
if (!CI->getArgOperand(2)->getType()->isIntegerTy())
|
|
|
|
return nullptr;
|
|
|
|
Value *V = B.CreateTrunc(CI->getArgOperand(2), B.getInt8Ty(), "char");
|
|
|
|
Value *Ptr = CastToCStr(CI->getArgOperand(0), B);
|
|
|
|
B.CreateStore(V, Ptr);
|
2015-03-31 04:42:56 +08:00
|
|
|
Ptr = B.CreateGEP(B.getInt8Ty(), Ptr, B.getInt32(1), "nul");
|
2014-09-18 04:55:46 +08:00
|
|
|
B.CreateStore(B.getInt8(0), Ptr);
|
|
|
|
|
|
|
|
return ConstantInt::get(CI->getType(), 1);
|
2012-11-27 13:57:54 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (FormatStr[1] == 's') {
|
|
|
|
// sprintf(dest, "%s", str) -> llvm.memcpy(dest, str, strlen(str)+1, 1)
|
|
|
|
if (!CI->getArgOperand(2)->getType()->isPointerTy())
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2012-11-29 23:45:33 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Len = EmitStrLen(CI->getArgOperand(2), B, DL, TLI);
|
|
|
|
if (!Len)
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *IncLen =
|
|
|
|
B.CreateAdd(Len, ConstantInt::get(Len->getType(), 1), "leninc");
|
|
|
|
B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(2), IncLen, 1);
|
2013-04-17 10:01:10 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// The sprintf result is the unincremented number of bytes in the string.
|
|
|
|
return B.CreateIntCast(Len, CI->getType(), false);
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-29 23:45:33 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeSPrintF(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Require two fixed pointer arguments and an integer result.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
|
|
|
return nullptr;
|
2012-11-29 23:45:33 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (Value *V = optimizeSPrintFString(CI, B)) {
|
|
|
|
return V;
|
|
|
|
}
|
2012-11-29 23:45:33 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// sprintf(str, format, ...) -> siprintf(str, format, ...) if no floating
|
|
|
|
// point arguments.
|
|
|
|
if (TLI->has(LibFunc::siprintf) && !callHasFloatingPointArgument(CI)) {
|
|
|
|
Module *M = B.GetInsertBlock()->getParent()->getParent();
|
|
|
|
Constant *SIPrintFFn =
|
|
|
|
M->getOrInsertFunction("siprintf", FT, Callee->getAttributes());
|
|
|
|
CallInst *New = cast<CallInst>(CI->clone());
|
|
|
|
New->setCalledFunction(SIPrintFFn);
|
|
|
|
B.Insert(New);
|
|
|
|
return New;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-29 23:45:33 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFPrintFString(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
optimizeErrorReporting(CI, B, 0);
|
2012-11-29 23:45:33 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// All the optimizations depend on the format string.
|
|
|
|
StringRef FormatStr;
|
|
|
|
if (!getConstantStringInfo(CI->getArgOperand(1), FormatStr))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Do not do any of the following transformations if the fprintf return
|
|
|
|
// value is used, in general the fprintf return value is not compatible
|
|
|
|
// with fwrite(), fputc() or fputs().
|
|
|
|
if (!CI->use_empty())
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2014-09-18 04:55:46 +08:00
|
|
|
|
|
|
|
// fprintf(F, "foo") --> fwrite("foo", 3, 1, F)
|
|
|
|
if (CI->getNumArgOperands() == 2) {
|
|
|
|
for (unsigned i = 0, e = FormatStr.size(); i != e; ++i)
|
|
|
|
if (FormatStr[i] == '%') // Could handle %% -> % if we cared.
|
|
|
|
return nullptr; // We found a format specifier.
|
|
|
|
|
|
|
|
return EmitFWrite(
|
|
|
|
CI->getArgOperand(1),
|
2015-03-10 10:37:25 +08:00
|
|
|
ConstantInt::get(DL.getIntPtrType(CI->getContext()), FormatStr.size()),
|
2014-09-18 04:55:46 +08:00
|
|
|
CI->getArgOperand(0), B, DL, TLI);
|
2012-11-29 23:45:33 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// The remaining optimizations require the format string to be "%s" or "%c"
|
|
|
|
// and have an extra operand.
|
|
|
|
if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
|
|
|
|
CI->getNumArgOperands() < 3)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Decode the second character of the format string.
|
|
|
|
if (FormatStr[1] == 'c') {
|
|
|
|
// fprintf(F, "%c", chr) --> fputc(chr, F)
|
|
|
|
if (!CI->getArgOperand(2)->getType()->isIntegerTy())
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2015-03-10 10:37:25 +08:00
|
|
|
return EmitFPutC(CI->getArgOperand(2), CI->getArgOperand(0), B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
2012-11-29 23:45:33 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (FormatStr[1] == 's') {
|
|
|
|
// fprintf(F, "%s", str) --> fputs(str, F)
|
|
|
|
if (!CI->getArgOperand(2)->getType()->isPointerTy())
|
|
|
|
return nullptr;
|
2015-03-10 10:37:25 +08:00
|
|
|
return EmitFPutS(CI->getArgOperand(2), CI->getArgOperand(0), B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-29 23:45:33 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFPrintF(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Require two fixed paramters as pointers and integer result.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2014-09-18 04:55:46 +08:00
|
|
|
|
|
|
|
if (Value *V = optimizeFPrintFString(CI, B)) {
|
|
|
|
return V;
|
2012-11-29 23:45:33 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// fprintf(stream, format, ...) -> fiprintf(stream, format, ...) if no
|
|
|
|
// floating point arguments.
|
|
|
|
if (TLI->has(LibFunc::fiprintf) && !callHasFloatingPointArgument(CI)) {
|
|
|
|
Module *M = B.GetInsertBlock()->getParent()->getParent();
|
|
|
|
Constant *FIPrintFFn =
|
|
|
|
M->getOrInsertFunction("fiprintf", FT, Callee->getAttributes());
|
|
|
|
CallInst *New = cast<CallInst>(CI->clone());
|
|
|
|
New->setCalledFunction(FIPrintFFn);
|
|
|
|
B.Insert(New);
|
|
|
|
return New;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
2013-11-17 10:06:35 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFWrite(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
optimizeErrorReporting(CI, B, 3);
|
2012-11-29 23:45:39 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Require a pointer, an integer, an integer, a pointer, returning integer.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 4 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isIntegerTy() ||
|
|
|
|
!FT->getParamType(2)->isIntegerTy() ||
|
|
|
|
!FT->getParamType(3)->isPointerTy() ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
|
|
|
return nullptr;
|
2012-11-29 23:45:39 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Get the element size and count.
|
|
|
|
ConstantInt *SizeC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
|
|
|
|
ConstantInt *CountC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
|
|
|
|
if (!SizeC || !CountC)
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2014-09-18 04:55:46 +08:00
|
|
|
uint64_t Bytes = SizeC->getZExtValue() * CountC->getZExtValue();
|
2012-11-29 23:45:39 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// If this is writing zero records, remove the call (it's a noop).
|
|
|
|
if (Bytes == 0)
|
|
|
|
return ConstantInt::get(CI->getType(), 0);
|
2013-11-17 10:06:35 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// If this is writing one byte, turn it into fputc.
|
|
|
|
// This optimisation is only valid, if the return value is unused.
|
|
|
|
if (Bytes == 1 && CI->use_empty()) { // fwrite(S,1,1,F) -> fputc(S[0],F)
|
|
|
|
Value *Char = B.CreateLoad(CastToCStr(CI->getArgOperand(0), B), "char");
|
2015-03-10 10:37:25 +08:00
|
|
|
Value *NewCI = EmitFPutC(Char, CI->getArgOperand(3), B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
return NewCI ? ConstantInt::get(CI->getType(), 1) : nullptr;
|
|
|
|
}
|
2012-11-29 23:45:43 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-11-29 23:45:43 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFPuts(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
optimizeErrorReporting(CI, B, 1);
|
2012-11-30 03:15:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
2012-11-30 03:15:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Require two pointers. Also, we can't optimize if return value is used.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() || !CI->use_empty())
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2012-11-30 03:15:17 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// fputs(s,F) --> fwrite(s,1,strlen(s),F)
|
|
|
|
uint64_t Len = GetStringLength(CI->getArgOperand(0));
|
|
|
|
if (!Len)
|
|
|
|
return nullptr;
|
2012-10-14 00:45:24 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Known to have no uses (see above).
|
|
|
|
return EmitFWrite(
|
|
|
|
CI->getArgOperand(0),
|
2015-03-10 10:37:25 +08:00
|
|
|
ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len - 1),
|
2014-09-18 04:55:46 +08:00
|
|
|
CI->getArgOperand(1), B, DL, TLI);
|
|
|
|
}
|
2012-10-14 00:45:24 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizePuts(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
// Require one fixed pointer argument and an integer/void result.
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() < 1 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!(FT->getReturnType()->isIntegerTy() || FT->getReturnType()->isVoidTy()))
|
|
|
|
return nullptr;
|
2012-11-11 13:11:20 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// Check for a constant string.
|
|
|
|
StringRef Str;
|
|
|
|
if (!getConstantStringInfo(CI->getArgOperand(0), Str))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (Str.empty() && CI->use_empty()) {
|
|
|
|
// puts("") -> putchar('\n')
|
2015-03-10 10:37:25 +08:00
|
|
|
Value *Res = EmitPutChar(B.getInt32('\n'), B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
if (CI->use_empty() || !Res)
|
|
|
|
return Res;
|
|
|
|
return B.CreateIntCast(Res, CI->getType(), true);
|
2012-10-14 00:45:24 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2012-10-14 00:45:24 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
bool LibCallSimplifier::hasFloatVersion(StringRef FuncName) {
|
2013-03-12 08:08:29 +08:00
|
|
|
LibFunc::Func Func;
|
|
|
|
SmallString<20> FloatFuncName = FuncName;
|
|
|
|
FloatFuncName += 'f';
|
|
|
|
if (TLI->getLibFunc(FloatFuncName, Func))
|
|
|
|
return TLI->has(Func);
|
|
|
|
return false;
|
|
|
|
}
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2015-01-13 01:20:06 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStringMemoryLibCall(CallInst *CI,
|
|
|
|
IRBuilder<> &Builder) {
|
2013-03-12 08:08:29 +08:00
|
|
|
LibFunc::Func Func;
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
StringRef FuncName = Callee->getName();
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2015-01-13 01:20:06 +08:00
|
|
|
// Check for string/memory library functions.
|
2013-03-12 08:08:29 +08:00
|
|
|
if (TLI->getLibFunc(FuncName, Func) && TLI->has(Func)) {
|
2015-01-13 01:20:06 +08:00
|
|
|
// Make sure we never change the calling convention.
|
|
|
|
assert((ignoreCallingConv(Func) ||
|
|
|
|
CI->getCallingConv() == llvm::CallingConv::C) &&
|
|
|
|
"Optimizing string/memory libcall would change the calling convention");
|
2013-03-12 08:08:29 +08:00
|
|
|
switch (Func) {
|
2014-09-18 04:55:46 +08:00
|
|
|
case LibFunc::strcat:
|
|
|
|
return optimizeStrCat(CI, Builder);
|
|
|
|
case LibFunc::strncat:
|
|
|
|
return optimizeStrNCat(CI, Builder);
|
|
|
|
case LibFunc::strchr:
|
|
|
|
return optimizeStrChr(CI, Builder);
|
|
|
|
case LibFunc::strrchr:
|
|
|
|
return optimizeStrRChr(CI, Builder);
|
|
|
|
case LibFunc::strcmp:
|
|
|
|
return optimizeStrCmp(CI, Builder);
|
|
|
|
case LibFunc::strncmp:
|
|
|
|
return optimizeStrNCmp(CI, Builder);
|
|
|
|
case LibFunc::strcpy:
|
|
|
|
return optimizeStrCpy(CI, Builder);
|
|
|
|
case LibFunc::stpcpy:
|
|
|
|
return optimizeStpCpy(CI, Builder);
|
|
|
|
case LibFunc::strncpy:
|
|
|
|
return optimizeStrNCpy(CI, Builder);
|
|
|
|
case LibFunc::strlen:
|
|
|
|
return optimizeStrLen(CI, Builder);
|
|
|
|
case LibFunc::strpbrk:
|
|
|
|
return optimizeStrPBrk(CI, Builder);
|
|
|
|
case LibFunc::strtol:
|
|
|
|
case LibFunc::strtod:
|
|
|
|
case LibFunc::strtof:
|
|
|
|
case LibFunc::strtoul:
|
|
|
|
case LibFunc::strtoll:
|
|
|
|
case LibFunc::strtold:
|
|
|
|
case LibFunc::strtoull:
|
|
|
|
return optimizeStrTo(CI, Builder);
|
|
|
|
case LibFunc::strspn:
|
|
|
|
return optimizeStrSpn(CI, Builder);
|
|
|
|
case LibFunc::strcspn:
|
|
|
|
return optimizeStrCSpn(CI, Builder);
|
|
|
|
case LibFunc::strstr:
|
|
|
|
return optimizeStrStr(CI, Builder);
|
2015-03-21 23:36:21 +08:00
|
|
|
case LibFunc::memchr:
|
|
|
|
return optimizeMemChr(CI, Builder);
|
2014-09-18 04:55:46 +08:00
|
|
|
case LibFunc::memcmp:
|
|
|
|
return optimizeMemCmp(CI, Builder);
|
|
|
|
case LibFunc::memcpy:
|
|
|
|
return optimizeMemCpy(CI, Builder);
|
|
|
|
case LibFunc::memmove:
|
|
|
|
return optimizeMemMove(CI, Builder);
|
|
|
|
case LibFunc::memset:
|
|
|
|
return optimizeMemSet(CI, Builder);
|
2015-01-13 01:20:06 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *LibCallSimplifier::optimizeCall(CallInst *CI) {
|
|
|
|
if (CI->isNoBuiltin())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
LibFunc::Func Func;
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
StringRef FuncName = Callee->getName();
|
|
|
|
IRBuilder<> Builder(CI);
|
|
|
|
bool isCallingConvC = CI->getCallingConv() == llvm::CallingConv::C;
|
|
|
|
|
|
|
|
// Command-line parameter overrides function attribute.
|
|
|
|
if (EnableUnsafeFPShrink.getNumOccurrences() > 0)
|
|
|
|
UnsafeFPShrink = EnableUnsafeFPShrink;
|
2015-10-29 10:58:44 +08:00
|
|
|
else if (canUseUnsafeFPMath(Callee))
|
|
|
|
UnsafeFPShrink = true;
|
2015-01-13 01:20:06 +08:00
|
|
|
|
|
|
|
// First, check for intrinsics.
|
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI)) {
|
|
|
|
if (!isCallingConvC)
|
|
|
|
return nullptr;
|
|
|
|
switch (II->getIntrinsicID()) {
|
|
|
|
case Intrinsic::pow:
|
|
|
|
return optimizePow(CI, Builder);
|
|
|
|
case Intrinsic::exp2:
|
|
|
|
return optimizeExp2(CI, Builder);
|
|
|
|
case Intrinsic::fabs:
|
|
|
|
return optimizeFabs(CI, Builder);
|
|
|
|
case Intrinsic::sqrt:
|
|
|
|
return optimizeSqrt(CI, Builder);
|
|
|
|
default:
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-13 01:22:43 +08:00
|
|
|
// Also try to simplify calls to fortified library functions.
|
|
|
|
if (Value *SimplifiedFortifiedCI = FortifiedSimplifier.optimizeCall(CI)) {
|
|
|
|
// Try to further simplify the result.
|
2015-01-14 08:55:05 +08:00
|
|
|
CallInst *SimplifiedCI = dyn_cast<CallInst>(SimplifiedFortifiedCI);
|
2015-10-02 06:43:53 +08:00
|
|
|
if (SimplifiedCI && SimplifiedCI->getCalledFunction()) {
|
|
|
|
// Use an IR Builder from SimplifiedCI if available instead of CI
|
|
|
|
// to guarantee we reach all uses we might replace later on.
|
|
|
|
IRBuilder<> TmpBuilder(SimplifiedCI);
|
|
|
|
if (Value *V = optimizeStringMemoryLibCall(SimplifiedCI, TmpBuilder)) {
|
[SimplifyLibCalls] Don't confuse strcpy_chk for stpcpy_chk.
This was introduced in a faulty refactoring (r225640, mea culpa):
the tests weren't testing the return values, so, for both
__strcpy_chk and __stpcpy_chk, we would return the end of the
buffer (matching stpcpy) instead of the beginning (for strcpy).
The root cause was the prefix "__" being ignored when comparing,
which made us always pick LibFunc::stpcpy_chk.
Pass the LibFunc::Func directly to avoid this kind of error.
Also, make the testcases as explicit as possible to prevent this.
The now-useful testcases expose another, entangled, stpcpy problem,
with the further simplification. This was introduced in a
refactoring (r225640) to match the original behavior.
However, this leads to problems when successive simplifications
generate several similar instructions, none of which are removed
by the custom replaceAllUsesWith.
For instance, InstCombine (the main user) doesn't erase the
instruction in its custom RAUW. When trying to simplify say
__stpcpy_chk:
- first, an stpcpy is created (fortified simplifier),
- second, a memcpy is created (normal simplifier), but the
stpcpy call isn't removed.
- third, InstCombine later revisits the instructions,
and simplifies the first stpcpy to a memcpy. We now have
two memcpys.
llvm-svn: 227250
2015-01-28 05:52:16 +08:00
|
|
|
// If we were able to further simplify, remove the now redundant call.
|
|
|
|
SimplifiedCI->replaceAllUsesWith(V);
|
|
|
|
SimplifiedCI->eraseFromParent();
|
2015-01-13 01:22:43 +08:00
|
|
|
return V;
|
[SimplifyLibCalls] Don't confuse strcpy_chk for stpcpy_chk.
This was introduced in a faulty refactoring (r225640, mea culpa):
the tests weren't testing the return values, so, for both
__strcpy_chk and __stpcpy_chk, we would return the end of the
buffer (matching stpcpy) instead of the beginning (for strcpy).
The root cause was the prefix "__" being ignored when comparing,
which made us always pick LibFunc::stpcpy_chk.
Pass the LibFunc::Func directly to avoid this kind of error.
Also, make the testcases as explicit as possible to prevent this.
The now-useful testcases expose another, entangled, stpcpy problem,
with the further simplification. This was introduced in a
refactoring (r225640) to match the original behavior.
However, this leads to problems when successive simplifications
generate several similar instructions, none of which are removed
by the custom replaceAllUsesWith.
For instance, InstCombine (the main user) doesn't erase the
instruction in its custom RAUW. When trying to simplify say
__stpcpy_chk:
- first, an stpcpy is created (fortified simplifier),
- second, a memcpy is created (normal simplifier), but the
stpcpy call isn't removed.
- third, InstCombine later revisits the instructions,
and simplifies the first stpcpy to a memcpy. We now have
two memcpys.
llvm-svn: 227250
2015-01-28 05:52:16 +08:00
|
|
|
}
|
2015-10-02 06:43:53 +08:00
|
|
|
}
|
2015-01-13 01:22:43 +08:00
|
|
|
return SimplifiedFortifiedCI;
|
|
|
|
}
|
|
|
|
|
2015-01-13 01:20:06 +08:00
|
|
|
// Then check for known library functions.
|
|
|
|
if (TLI->getLibFunc(FuncName, Func) && TLI->has(Func)) {
|
|
|
|
// We never change the calling convention.
|
|
|
|
if (!ignoreCallingConv(Func) && !isCallingConvC)
|
|
|
|
return nullptr;
|
|
|
|
if (Value *V = optimizeStringMemoryLibCall(CI, Builder))
|
|
|
|
return V;
|
|
|
|
switch (Func) {
|
2014-09-18 04:55:46 +08:00
|
|
|
case LibFunc::cosf:
|
|
|
|
case LibFunc::cos:
|
|
|
|
case LibFunc::cosl:
|
|
|
|
return optimizeCos(CI, Builder);
|
|
|
|
case LibFunc::sinpif:
|
|
|
|
case LibFunc::sinpi:
|
|
|
|
case LibFunc::cospif:
|
|
|
|
case LibFunc::cospi:
|
|
|
|
return optimizeSinCosPi(CI, Builder);
|
|
|
|
case LibFunc::powf:
|
|
|
|
case LibFunc::pow:
|
|
|
|
case LibFunc::powl:
|
|
|
|
return optimizePow(CI, Builder);
|
|
|
|
case LibFunc::exp2l:
|
|
|
|
case LibFunc::exp2:
|
|
|
|
case LibFunc::exp2f:
|
|
|
|
return optimizeExp2(CI, Builder);
|
2014-10-15 04:43:11 +08:00
|
|
|
case LibFunc::fabsf:
|
|
|
|
case LibFunc::fabs:
|
|
|
|
case LibFunc::fabsl:
|
|
|
|
return optimizeFabs(CI, Builder);
|
2014-10-17 02:48:17 +08:00
|
|
|
case LibFunc::sqrtf:
|
|
|
|
case LibFunc::sqrt:
|
|
|
|
case LibFunc::sqrtl:
|
|
|
|
return optimizeSqrt(CI, Builder);
|
2014-09-18 04:55:46 +08:00
|
|
|
case LibFunc::ffs:
|
|
|
|
case LibFunc::ffsl:
|
|
|
|
case LibFunc::ffsll:
|
|
|
|
return optimizeFFS(CI, Builder);
|
|
|
|
case LibFunc::abs:
|
|
|
|
case LibFunc::labs:
|
|
|
|
case LibFunc::llabs:
|
|
|
|
return optimizeAbs(CI, Builder);
|
|
|
|
case LibFunc::isdigit:
|
|
|
|
return optimizeIsDigit(CI, Builder);
|
|
|
|
case LibFunc::isascii:
|
|
|
|
return optimizeIsAscii(CI, Builder);
|
|
|
|
case LibFunc::toascii:
|
|
|
|
return optimizeToAscii(CI, Builder);
|
|
|
|
case LibFunc::printf:
|
|
|
|
return optimizePrintF(CI, Builder);
|
|
|
|
case LibFunc::sprintf:
|
|
|
|
return optimizeSPrintF(CI, Builder);
|
|
|
|
case LibFunc::fprintf:
|
|
|
|
return optimizeFPrintF(CI, Builder);
|
|
|
|
case LibFunc::fwrite:
|
|
|
|
return optimizeFWrite(CI, Builder);
|
|
|
|
case LibFunc::fputs:
|
|
|
|
return optimizeFPuts(CI, Builder);
|
|
|
|
case LibFunc::puts:
|
|
|
|
return optimizePuts(CI, Builder);
|
|
|
|
case LibFunc::perror:
|
|
|
|
return optimizeErrorReporting(CI, Builder);
|
|
|
|
case LibFunc::vfprintf:
|
|
|
|
case LibFunc::fiprintf:
|
|
|
|
return optimizeErrorReporting(CI, Builder, 0);
|
|
|
|
case LibFunc::fputc:
|
|
|
|
return optimizeErrorReporting(CI, Builder, 1);
|
|
|
|
case LibFunc::ceil:
|
|
|
|
case LibFunc::floor:
|
|
|
|
case LibFunc::rint:
|
|
|
|
case LibFunc::round:
|
|
|
|
case LibFunc::nearbyint:
|
|
|
|
case LibFunc::trunc:
|
|
|
|
if (hasFloatVersion(FuncName))
|
|
|
|
return optimizeUnaryDoubleFP(CI, Builder, false);
|
|
|
|
return nullptr;
|
|
|
|
case LibFunc::acos:
|
|
|
|
case LibFunc::acosh:
|
|
|
|
case LibFunc::asin:
|
|
|
|
case LibFunc::asinh:
|
|
|
|
case LibFunc::atan:
|
|
|
|
case LibFunc::atanh:
|
|
|
|
case LibFunc::cbrt:
|
|
|
|
case LibFunc::cosh:
|
|
|
|
case LibFunc::exp:
|
|
|
|
case LibFunc::exp10:
|
|
|
|
case LibFunc::expm1:
|
|
|
|
case LibFunc::log:
|
|
|
|
case LibFunc::log10:
|
|
|
|
case LibFunc::log1p:
|
|
|
|
case LibFunc::log2:
|
|
|
|
case LibFunc::logb:
|
|
|
|
case LibFunc::sin:
|
|
|
|
case LibFunc::sinh:
|
|
|
|
case LibFunc::tan:
|
|
|
|
case LibFunc::tanh:
|
|
|
|
if (UnsafeFPShrink && hasFloatVersion(FuncName))
|
|
|
|
return optimizeUnaryDoubleFP(CI, Builder, true);
|
|
|
|
return nullptr;
|
2014-12-04 05:46:29 +08:00
|
|
|
case LibFunc::copysign:
|
2014-09-18 04:55:46 +08:00
|
|
|
if (hasFloatVersion(FuncName))
|
|
|
|
return optimizeBinaryDoubleFP(CI, Builder);
|
|
|
|
return nullptr;
|
2015-08-17 04:18:19 +08:00
|
|
|
case LibFunc::fminf:
|
|
|
|
case LibFunc::fmin:
|
|
|
|
case LibFunc::fminl:
|
|
|
|
case LibFunc::fmaxf:
|
|
|
|
case LibFunc::fmax:
|
|
|
|
case LibFunc::fmaxl:
|
|
|
|
return optimizeFMinFMax(CI, Builder);
|
2014-11-13 05:23:34 +08:00
|
|
|
default:
|
|
|
|
return nullptr;
|
|
|
|
}
|
2013-03-12 08:08:29 +08:00
|
|
|
}
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2012-10-14 00:45:24 +08:00
|
|
|
}
|
|
|
|
|
2015-01-21 10:11:59 +08:00
|
|
|
LibCallSimplifier::LibCallSimplifier(
|
2015-03-10 10:37:25 +08:00
|
|
|
const DataLayout &DL, const TargetLibraryInfo *TLI,
|
2015-01-21 10:11:59 +08:00
|
|
|
function_ref<void(Instruction *, Value *)> Replacer)
|
2015-03-10 10:37:25 +08:00
|
|
|
: FortifiedSimplifier(TLI), DL(DL), TLI(TLI), UnsafeFPShrink(false),
|
2015-01-21 10:11:59 +08:00
|
|
|
Replacer(Replacer) {}
|
|
|
|
|
|
|
|
void LibCallSimplifier::replaceAllUsesWith(Instruction *I, Value *With) {
|
|
|
|
// Indirect through the replacer used in this instance.
|
|
|
|
Replacer(I, With);
|
2012-10-14 00:45:24 +08:00
|
|
|
}
|
|
|
|
|
2013-06-21 03:48:07 +08:00
|
|
|
// TODO:
|
|
|
|
// Additional cases that we need to add to this file:
|
|
|
|
//
|
|
|
|
// cbrt:
|
|
|
|
// * cbrt(expN(X)) -> expN(x/3)
|
|
|
|
// * cbrt(sqrt(x)) -> pow(x,1/6)
|
2015-08-27 02:30:16 +08:00
|
|
|
// * cbrt(cbrt(x)) -> pow(x,1/9)
|
2013-06-21 03:48:07 +08:00
|
|
|
//
|
|
|
|
// exp, expf, expl:
|
|
|
|
// * exp(log(x)) -> x
|
|
|
|
//
|
|
|
|
// log, logf, logl:
|
|
|
|
// * log(exp(x)) -> x
|
|
|
|
// * log(x**y) -> y*log(x)
|
|
|
|
// * log(exp(y)) -> y*log(e)
|
|
|
|
// * log(exp2(y)) -> y*log(2)
|
|
|
|
// * log(exp10(y)) -> y*log(10)
|
|
|
|
// * log(sqrt(x)) -> 0.5*log(x)
|
|
|
|
// * log(pow(x,y)) -> y*log(x)
|
|
|
|
//
|
|
|
|
// lround, lroundf, lroundl:
|
|
|
|
// * lround(cnst) -> cnst'
|
|
|
|
//
|
|
|
|
// pow, powf, powl:
|
|
|
|
// * pow(exp(x),y) -> exp(x*y)
|
|
|
|
// * pow(sqrt(x),y) -> pow(x,y*0.5)
|
|
|
|
// * pow(pow(x,y),z)-> pow(x,y*z)
|
|
|
|
//
|
|
|
|
// round, roundf, roundl:
|
|
|
|
// * round(cnst) -> cnst'
|
|
|
|
//
|
|
|
|
// signbit:
|
|
|
|
// * signbit(cnst) -> cnst'
|
|
|
|
// * signbit(nncst) -> 0 (if pstv is a non-negative constant)
|
|
|
|
//
|
|
|
|
// sqrt, sqrtf, sqrtl:
|
|
|
|
// * sqrt(expN(x)) -> expN(x*0.5)
|
|
|
|
// * sqrt(Nroot(x)) -> pow(x,1/(2*N))
|
|
|
|
// * sqrt(pow(x,y)) -> pow(|x|,y*0.5)
|
|
|
|
//
|
|
|
|
// tan, tanf, tanl:
|
|
|
|
// * tan(atan(x)) -> x
|
|
|
|
//
|
|
|
|
// trunc, truncf, truncl:
|
|
|
|
// * trunc(cnst) -> cnst'
|
|
|
|
//
|
|
|
|
//
|
2015-01-13 01:22:43 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Fortified Library Call Optimizations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
bool FortifiedLibCallSimplifier::isFortifiedCallFoldable(CallInst *CI,
|
|
|
|
unsigned ObjSizeOp,
|
|
|
|
unsigned SizeOp,
|
|
|
|
bool isString) {
|
|
|
|
if (CI->getArgOperand(ObjSizeOp) == CI->getArgOperand(SizeOp))
|
|
|
|
return true;
|
|
|
|
if (ConstantInt *ObjSizeCI =
|
|
|
|
dyn_cast<ConstantInt>(CI->getArgOperand(ObjSizeOp))) {
|
|
|
|
if (ObjSizeCI->isAllOnesValue())
|
|
|
|
return true;
|
|
|
|
// If the object size wasn't -1 (unknown), bail out if we were asked to.
|
|
|
|
if (OnlyLowerUnknownSize)
|
|
|
|
return false;
|
|
|
|
if (isString) {
|
|
|
|
uint64_t Len = GetStringLength(CI->getArgOperand(SizeOp));
|
|
|
|
// If the length is 0 we don't know how long it is and so we can't
|
|
|
|
// remove the check.
|
|
|
|
if (Len == 0)
|
|
|
|
return false;
|
|
|
|
return ObjSizeCI->getZExtValue() >= Len;
|
|
|
|
}
|
|
|
|
if (ConstantInt *SizeCI = dyn_cast<ConstantInt>(CI->getArgOperand(SizeOp)))
|
|
|
|
return ObjSizeCI->getZExtValue() >= SizeCI->getZExtValue();
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memcpy_chk))
|
2015-01-13 01:22:43 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (isFortifiedCallFoldable(CI, 3, 2, false)) {
|
|
|
|
B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
CI->getArgOperand(2), 1);
|
|
|
|
return CI->getArgOperand(0);
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memmove_chk))
|
2015-01-13 01:22:43 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (isFortifiedCallFoldable(CI, 3, 2, false)) {
|
|
|
|
B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
CI->getArgOperand(2), 1);
|
|
|
|
return CI->getArgOperand(0);
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memset_chk))
|
2015-01-13 01:22:43 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (isFortifiedCallFoldable(CI, 3, 2, false)) {
|
|
|
|
Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
|
|
|
|
B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
|
|
|
|
return CI->getArgOperand(0);
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
[SimplifyLibCalls] Don't confuse strcpy_chk for stpcpy_chk.
This was introduced in a faulty refactoring (r225640, mea culpa):
the tests weren't testing the return values, so, for both
__strcpy_chk and __stpcpy_chk, we would return the end of the
buffer (matching stpcpy) instead of the beginning (for strcpy).
The root cause was the prefix "__" being ignored when comparing,
which made us always pick LibFunc::stpcpy_chk.
Pass the LibFunc::Func directly to avoid this kind of error.
Also, make the testcases as explicit as possible to prevent this.
The now-useful testcases expose another, entangled, stpcpy problem,
with the further simplification. This was introduced in a
refactoring (r225640) to match the original behavior.
However, this leads to problems when successive simplifications
generate several similar instructions, none of which are removed
by the custom replaceAllUsesWith.
For instance, InstCombine (the main user) doesn't erase the
instruction in its custom RAUW. When trying to simplify say
__stpcpy_chk:
- first, an stpcpy is created (fortified simplifier),
- second, a memcpy is created (normal simplifier), but the
stpcpy call isn't removed.
- third, InstCombine later revisits the instructions,
and simplifies the first stpcpy to a memcpy. We now have
two memcpys.
llvm-svn: 227250
2015-01-28 05:52:16 +08:00
|
|
|
Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI,
|
|
|
|
IRBuilder<> &B,
|
|
|
|
LibFunc::Func Func) {
|
2015-01-13 01:22:43 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
StringRef Name = Callee->getName();
|
2015-03-10 10:37:25 +08:00
|
|
|
const DataLayout &DL = CI->getModule()->getDataLayout();
|
2015-01-13 01:22:43 +08:00
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, Func))
|
2015-01-13 01:22:43 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1),
|
|
|
|
*ObjSize = CI->getArgOperand(2);
|
|
|
|
|
|
|
|
// __stpcpy_chk(x,x,...) -> x+strlen(x)
|
[SimplifyLibCalls] Don't confuse strcpy_chk for stpcpy_chk.
This was introduced in a faulty refactoring (r225640, mea culpa):
the tests weren't testing the return values, so, for both
__strcpy_chk and __stpcpy_chk, we would return the end of the
buffer (matching stpcpy) instead of the beginning (for strcpy).
The root cause was the prefix "__" being ignored when comparing,
which made us always pick LibFunc::stpcpy_chk.
Pass the LibFunc::Func directly to avoid this kind of error.
Also, make the testcases as explicit as possible to prevent this.
The now-useful testcases expose another, entangled, stpcpy problem,
with the further simplification. This was introduced in a
refactoring (r225640) to match the original behavior.
However, this leads to problems when successive simplifications
generate several similar instructions, none of which are removed
by the custom replaceAllUsesWith.
For instance, InstCombine (the main user) doesn't erase the
instruction in its custom RAUW. When trying to simplify say
__stpcpy_chk:
- first, an stpcpy is created (fortified simplifier),
- second, a memcpy is created (normal simplifier), but the
stpcpy call isn't removed.
- third, InstCombine later revisits the instructions,
and simplifies the first stpcpy to a memcpy. We now have
two memcpys.
llvm-svn: 227250
2015-01-28 05:52:16 +08:00
|
|
|
if (Func == LibFunc::stpcpy_chk && !OnlyLowerUnknownSize && Dst == Src) {
|
2015-01-13 01:22:43 +08:00
|
|
|
Value *StrLen = EmitStrLen(Src, B, DL, TLI);
|
2015-04-04 05:33:42 +08:00
|
|
|
return StrLen ? B.CreateInBoundsGEP(B.getInt8Ty(), Dst, StrLen) : nullptr;
|
2015-01-13 01:22:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If a) we don't have any length information, or b) we know this will
|
|
|
|
// fit then just lower to a plain st[rp]cpy. Otherwise we'll keep our
|
|
|
|
// st[rp]cpy_chk call which may fail at runtime if the size is too long.
|
|
|
|
// TODO: It might be nice to get a maximum length out of the possible
|
|
|
|
// string lengths for varying.
|
2015-04-04 05:32:06 +08:00
|
|
|
if (isFortifiedCallFoldable(CI, 2, 1, true))
|
|
|
|
return EmitStrCpy(Dst, Src, B, TLI, Name.substr(2, 6));
|
2015-01-13 01:22:43 +08:00
|
|
|
|
2015-04-04 05:32:06 +08:00
|
|
|
if (OnlyLowerUnknownSize)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Maybe we can stil fold __st[rp]cpy_chk to __memcpy_chk.
|
|
|
|
uint64_t Len = GetStringLength(Src);
|
|
|
|
if (Len == 0)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
Type *SizeTTy = DL.getIntPtrType(CI->getContext());
|
|
|
|
Value *LenV = ConstantInt::get(SizeTTy, Len);
|
|
|
|
Value *Ret = EmitMemCpyChk(Dst, Src, LenV, ObjSize, B, DL, TLI);
|
|
|
|
// If the function was an __stpcpy_chk, and we were able to fold it into
|
|
|
|
// a __memcpy_chk, we still need to return the correct end pointer.
|
|
|
|
if (Ret && Func == LibFunc::stpcpy_chk)
|
|
|
|
return B.CreateGEP(B.getInt8Ty(), Dst, ConstantInt::get(SizeTTy, Len - 1));
|
|
|
|
return Ret;
|
2015-01-13 01:22:43 +08:00
|
|
|
}
|
|
|
|
|
[SimplifyLibCalls] Don't confuse strcpy_chk for stpcpy_chk.
This was introduced in a faulty refactoring (r225640, mea culpa):
the tests weren't testing the return values, so, for both
__strcpy_chk and __stpcpy_chk, we would return the end of the
buffer (matching stpcpy) instead of the beginning (for strcpy).
The root cause was the prefix "__" being ignored when comparing,
which made us always pick LibFunc::stpcpy_chk.
Pass the LibFunc::Func directly to avoid this kind of error.
Also, make the testcases as explicit as possible to prevent this.
The now-useful testcases expose another, entangled, stpcpy problem,
with the further simplification. This was introduced in a
refactoring (r225640) to match the original behavior.
However, this leads to problems when successive simplifications
generate several similar instructions, none of which are removed
by the custom replaceAllUsesWith.
For instance, InstCombine (the main user) doesn't erase the
instruction in its custom RAUW. When trying to simplify say
__stpcpy_chk:
- first, an stpcpy is created (fortified simplifier),
- second, a memcpy is created (normal simplifier), but the
stpcpy call isn't removed.
- third, InstCombine later revisits the instructions,
and simplifies the first stpcpy to a memcpy. We now have
two memcpys.
llvm-svn: 227250
2015-01-28 05:52:16 +08:00
|
|
|
Value *FortifiedLibCallSimplifier::optimizeStrpNCpyChk(CallInst *CI,
|
|
|
|
IRBuilder<> &B,
|
|
|
|
LibFunc::Func Func) {
|
2015-01-13 01:22:43 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
StringRef Name = Callee->getName();
|
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!checkStringCopyLibFuncSignature(Callee, Func))
|
2015-01-13 01:22:43 +08:00
|
|
|
return nullptr;
|
|
|
|
if (isFortifiedCallFoldable(CI, 3, 2, false)) {
|
2015-03-10 10:37:25 +08:00
|
|
|
Value *Ret = EmitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
CI->getArgOperand(2), B, TLI, Name.substr(2, 7));
|
2015-01-13 01:22:43 +08:00
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *FortifiedLibCallSimplifier::optimizeCall(CallInst *CI) {
|
2015-04-01 08:45:09 +08:00
|
|
|
// FIXME: We shouldn't be changing "nobuiltin" or TLI unavailable calls here.
|
|
|
|
// Some clang users checked for _chk libcall availability using:
|
|
|
|
// __has_builtin(__builtin___memcpy_chk)
|
|
|
|
// When compiling with -fno-builtin, this is always true.
|
|
|
|
// When passing -ffreestanding/-mkernel, which both imply -fno-builtin, we
|
|
|
|
// end up with fortified libcalls, which isn't acceptable in a freestanding
|
|
|
|
// environment which only provides their non-fortified counterparts.
|
|
|
|
//
|
|
|
|
// Until we change clang and/or teach external users to check for availability
|
|
|
|
// differently, disregard the "nobuiltin" attribute and TLI::has.
|
|
|
|
//
|
|
|
|
// PR23093.
|
2015-01-13 01:22:43 +08:00
|
|
|
|
|
|
|
LibFunc::Func Func;
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
StringRef FuncName = Callee->getName();
|
|
|
|
IRBuilder<> Builder(CI);
|
|
|
|
bool isCallingConvC = CI->getCallingConv() == llvm::CallingConv::C;
|
|
|
|
|
|
|
|
// First, check that this is a known library functions.
|
2015-04-01 08:45:09 +08:00
|
|
|
if (!TLI->getLibFunc(FuncName, Func))
|
2015-01-13 01:22:43 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// We never change the calling convention.
|
|
|
|
if (!ignoreCallingConv(Func) && !isCallingConvC)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
switch (Func) {
|
|
|
|
case LibFunc::memcpy_chk:
|
|
|
|
return optimizeMemCpyChk(CI, Builder);
|
|
|
|
case LibFunc::memmove_chk:
|
|
|
|
return optimizeMemMoveChk(CI, Builder);
|
|
|
|
case LibFunc::memset_chk:
|
|
|
|
return optimizeMemSetChk(CI, Builder);
|
|
|
|
case LibFunc::stpcpy_chk:
|
|
|
|
case LibFunc::strcpy_chk:
|
[SimplifyLibCalls] Don't confuse strcpy_chk for stpcpy_chk.
This was introduced in a faulty refactoring (r225640, mea culpa):
the tests weren't testing the return values, so, for both
__strcpy_chk and __stpcpy_chk, we would return the end of the
buffer (matching stpcpy) instead of the beginning (for strcpy).
The root cause was the prefix "__" being ignored when comparing,
which made us always pick LibFunc::stpcpy_chk.
Pass the LibFunc::Func directly to avoid this kind of error.
Also, make the testcases as explicit as possible to prevent this.
The now-useful testcases expose another, entangled, stpcpy problem,
with the further simplification. This was introduced in a
refactoring (r225640) to match the original behavior.
However, this leads to problems when successive simplifications
generate several similar instructions, none of which are removed
by the custom replaceAllUsesWith.
For instance, InstCombine (the main user) doesn't erase the
instruction in its custom RAUW. When trying to simplify say
__stpcpy_chk:
- first, an stpcpy is created (fortified simplifier),
- second, a memcpy is created (normal simplifier), but the
stpcpy call isn't removed.
- third, InstCombine later revisits the instructions,
and simplifies the first stpcpy to a memcpy. We now have
two memcpys.
llvm-svn: 227250
2015-01-28 05:52:16 +08:00
|
|
|
return optimizeStrpCpyChk(CI, Builder, Func);
|
2015-01-13 01:22:43 +08:00
|
|
|
case LibFunc::stpncpy_chk:
|
|
|
|
case LibFunc::strncpy_chk:
|
[SimplifyLibCalls] Don't confuse strcpy_chk for stpcpy_chk.
This was introduced in a faulty refactoring (r225640, mea culpa):
the tests weren't testing the return values, so, for both
__strcpy_chk and __stpcpy_chk, we would return the end of the
buffer (matching stpcpy) instead of the beginning (for strcpy).
The root cause was the prefix "__" being ignored when comparing,
which made us always pick LibFunc::stpcpy_chk.
Pass the LibFunc::Func directly to avoid this kind of error.
Also, make the testcases as explicit as possible to prevent this.
The now-useful testcases expose another, entangled, stpcpy problem,
with the further simplification. This was introduced in a
refactoring (r225640) to match the original behavior.
However, this leads to problems when successive simplifications
generate several similar instructions, none of which are removed
by the custom replaceAllUsesWith.
For instance, InstCombine (the main user) doesn't erase the
instruction in its custom RAUW. When trying to simplify say
__stpcpy_chk:
- first, an stpcpy is created (fortified simplifier),
- second, a memcpy is created (normal simplifier), but the
stpcpy call isn't removed.
- third, InstCombine later revisits the instructions,
and simplifies the first stpcpy to a memcpy. We now have
two memcpys.
llvm-svn: 227250
2015-01-28 05:52:16 +08:00
|
|
|
return optimizeStrpNCpyChk(CI, Builder, Func);
|
2015-01-13 01:22:43 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
FortifiedLibCallSimplifier::FortifiedLibCallSimplifier(
|
|
|
|
const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize)
|
|
|
|
: TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {}
|