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"
|
2017-07-27 03:03:18 +08:00
|
|
|
#include "llvm/Analysis/OptimizationDiagnosticInfo.h"
|
2015-11-25 02:57:06 +08:00
|
|
|
#include "llvm/Analysis/TargetLibraryInfo.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"
|
|
|
|
#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-11-17 10:06:35 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2017-04-27 00:39:58 +08:00
|
|
|
#include "llvm/Support/KnownBits.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
|
|
|
|
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
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
static bool ignoreCallingConv(LibFunc Func) {
|
|
|
|
return Func == LibFunc_abs || Func == LibFunc_labs ||
|
|
|
|
Func == LibFunc_llabs || Func == LibFunc_strlen;
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
|
|
|
|
2016-09-13 20:10:14 +08:00
|
|
|
static bool isCallingConvCCompatible(CallInst *CI) {
|
|
|
|
switch(CI->getCallingConv()) {
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
case llvm::CallingConv::C:
|
|
|
|
return true;
|
|
|
|
case llvm::CallingConv::ARM_APCS:
|
|
|
|
case llvm::CallingConv::ARM_AAPCS:
|
|
|
|
case llvm::CallingConv::ARM_AAPCS_VFP: {
|
|
|
|
|
|
|
|
// The iOS ABI diverges from the standard in some cases, so for now don't
|
|
|
|
// try to simplify those calls.
|
|
|
|
if (Triple(CI->getModule()->getTargetTriple()).isiOS())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
auto *FuncTy = CI->getFunctionType();
|
|
|
|
|
|
|
|
if (!FuncTy->getReturnType()->isPointerTy() &&
|
|
|
|
!FuncTy->getReturnType()->isIntegerTy() &&
|
|
|
|
!FuncTy->getReturnType()->isVoidTy())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (auto Param : FuncTy->params()) {
|
|
|
|
if (!Param->isPointerTy() && !Param->isIntegerTy())
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-01-01 00:10:49 +08:00
|
|
|
/// Return true if it is only used in equality comparisons with With.
|
2012-11-11 11:51:48 +08:00
|
|
|
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) {
|
2016-08-12 05:15:00 +08:00
|
|
|
return any_of(CI->operands(), [](const Use &OI) {
|
2015-11-29 06:27:48 +08:00
|
|
|
return OI->getType()->isFloatingPointTy();
|
|
|
|
});
|
2012-11-27 04:37:20 +08:00
|
|
|
}
|
|
|
|
|
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,
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc DoubleFn, LibFunc FloatFn,
|
|
|
|
LibFunc LongDoubleFn) {
|
2013-09-01 02:19:35 +08:00
|
|
|
switch (Ty->getTypeID()) {
|
|
|
|
case Type::FloatTyID:
|
|
|
|
return TLI->has(FloatFn);
|
|
|
|
case Type::DoubleTyID:
|
|
|
|
return TLI->has(DoubleFn);
|
|
|
|
default:
|
|
|
|
return TLI->has(LongDoubleFn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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) {
|
|
|
|
// 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.
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *DstLen = emitStrLen(Dst, B, DL, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
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),
|
2015-11-19 13:56:52 +08:00
|
|
|
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) {
|
2016-01-01 00:10:49 +08:00
|
|
|
// Extract some information from the instruction.
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Dst = CI->getArgOperand(0);
|
|
|
|
Value *Src = CI->getArgOperand(1);
|
|
|
|
uint64_t Len;
|
2012-10-14 00:45:32 +08:00
|
|
|
|
2016-01-01 00:10:49 +08:00
|
|
|
// We don't do anything if length is not constant.
|
2014-09-18 04:55:46 +08:00
|
|
|
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
|
|
|
|
2016-01-01 00:10:49 +08:00
|
|
|
// We don't optimize this case.
|
2014-09-18 04:55:46 +08:00
|
|
|
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)
|
2016-01-01 00:10:49 +08:00
|
|
|
// s is constant so the strcat can be optimized further.
|
2014-09-18 04:55:46 +08:00
|
|
|
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();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
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
|
|
|
|
2016-01-20 03:46:10 +08:00
|
|
|
return emitMemChr(SrcStr, CI->getArgOperand(1), // include nul.
|
2015-03-10 10:37:25 +08:00
|
|
|
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)
|
2016-01-20 03:46:10 +08:00
|
|
|
return B.CreateGEP(B.getInt8Ty(), SrcStr, emitStrLen(SrcStr, B, DL, TLI),
|
2016-01-01 00:10:49 +08:00
|
|
|
"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) {
|
|
|
|
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())
|
2016-01-20 03:46:10 +08:00
|
|
|
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) {
|
|
|
|
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) {
|
2016-01-20 03:46:10 +08:00
|
|
|
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) {
|
|
|
|
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)
|
2016-01-20 03:46:10 +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) {
|
|
|
|
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-11-19 13:56:52 +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();
|
|
|
|
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
|
|
|
|
if (Dst == Src) { // stpcpy(x,x) -> x+strlen(x)
|
2016-01-20 03:46:10 +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;
|
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
|
|
|
|
2015-11-03 07:07:14 +08:00
|
|
|
Type *PT = Callee->getFunctionType()->getParamType(0);
|
2015-03-10 10:37:25 +08:00
|
|
|
Value *LenV = ConstantInt::get(DL.getIntPtrType(PT), Len);
|
2016-01-01 00:10:49 +08:00
|
|
|
Value *DstEnd = 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.
|
2015-11-19 13:56:52 +08:00
|
|
|
B.CreateMemCpy(Dst, Src, LenV, 1);
|
2014-09-18 04:55:46 +08:00
|
|
|
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();
|
|
|
|
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
|
|
|
|
2015-11-03 07:07:14 +08:00
|
|
|
Type *PT = Callee->getFunctionType()->getParamType(0);
|
2014-09-18 04:55:46 +08:00
|
|
|
// strncpy(x, s, c) -> memcpy(x, s, c, 1) [s and c are constant]
|
2015-11-19 13:56:52 +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
|
|
|
|
2017-05-20 06:37:09 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilder<> &B,
|
|
|
|
unsigned CharSize) {
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *Src = CI->getArgOperand(0);
|
|
|
|
|
|
|
|
// Constant folding: strlen("xyz") -> 3
|
2017-05-20 06:37:09 +08:00
|
|
|
if (uint64_t Len = GetStringLength(Src, CharSize))
|
2014-09-18 04:55:46 +08:00
|
|
|
return ConstantInt::get(CI->getType(), Len - 1);
|
|
|
|
|
2016-04-13 22:31:06 +08:00
|
|
|
// If s is a constant pointer pointing to a string literal, we can fold
|
2017-05-20 06:37:09 +08:00
|
|
|
// strlen(s + x) to strlen(s) - x, when x is known to be in the range
|
2016-04-13 22:31:06 +08:00
|
|
|
// [0, strlen(s)] or the string has a single null terminator '\0' at the end.
|
2017-05-20 06:37:09 +08:00
|
|
|
// We only try to simplify strlen when the pointer s points to an array
|
2016-04-13 22:31:06 +08:00
|
|
|
// of i8. Otherwise, we would need to scale the offset x before doing the
|
2017-05-20 06:37:09 +08:00
|
|
|
// subtraction. This will make the optimization more complex, and it's not
|
|
|
|
// very useful because calling strlen for a pointer of other types is
|
2016-04-13 22:31:06 +08:00
|
|
|
// very uncommon.
|
|
|
|
if (GEPOperator *GEP = dyn_cast<GEPOperator>(Src)) {
|
2017-05-20 06:37:09 +08:00
|
|
|
if (!isGEPBasedOnPointerToString(GEP, CharSize))
|
2016-04-13 22:31:06 +08:00
|
|
|
return nullptr;
|
|
|
|
|
2017-05-20 06:37:09 +08:00
|
|
|
ConstantDataArraySlice Slice;
|
|
|
|
if (getConstantDataArrayInfo(GEP->getOperand(0), Slice, CharSize)) {
|
|
|
|
uint64_t NullTermIdx;
|
|
|
|
if (Slice.Array == nullptr) {
|
|
|
|
NullTermIdx = 0;
|
|
|
|
} else {
|
|
|
|
NullTermIdx = ~((uint64_t)0);
|
|
|
|
for (uint64_t I = 0, E = Slice.Length; I < E; ++I) {
|
|
|
|
if (Slice.Array->getElementAsInteger(I + Slice.Offset) == 0) {
|
|
|
|
NullTermIdx = I;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If the string does not have '\0', leave it to strlen to compute
|
|
|
|
// its length.
|
|
|
|
if (NullTermIdx == ~((uint64_t)0))
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-04-13 22:31:06 +08:00
|
|
|
Value *Offset = GEP->getOperand(2);
|
2017-05-25 00:53:07 +08:00
|
|
|
KnownBits Known = computeKnownBits(Offset, DL, 0, nullptr, CI, nullptr);
|
2017-04-27 00:39:58 +08:00
|
|
|
Known.Zero.flipAllBits();
|
2017-05-20 06:37:09 +08:00
|
|
|
uint64_t ArrSize =
|
2016-04-13 22:31:06 +08:00
|
|
|
cast<ArrayType>(GEP->getSourceElementType())->getNumElements();
|
|
|
|
|
2017-05-20 06:37:09 +08:00
|
|
|
// KnownZero's bits are flipped, so zeros in KnownZero now represent
|
|
|
|
// bits known to be zeros in Offset, and ones in KnowZero represent
|
2016-04-13 22:31:06 +08:00
|
|
|
// bits unknown in Offset. Therefore, Offset is known to be in range
|
2017-05-20 06:37:09 +08:00
|
|
|
// [0, NullTermIdx] when the flipped KnownZero is non-negative and
|
2016-04-13 22:31:06 +08:00
|
|
|
// unsigned-less-than NullTermIdx.
|
|
|
|
//
|
2017-05-20 06:37:09 +08:00
|
|
|
// If Offset is not provably in the range [0, NullTermIdx], we can still
|
|
|
|
// optimize if we can prove that the program has undefined behavior when
|
|
|
|
// Offset is outside that range. That is the case when GEP->getOperand(0)
|
2016-04-13 22:31:06 +08:00
|
|
|
// is a pointer to an object whose memory extent is NullTermIdx+1.
|
2017-05-20 06:37:09 +08:00
|
|
|
if ((Known.Zero.isNonNegative() && Known.Zero.ule(NullTermIdx)) ||
|
2016-04-13 22:31:06 +08:00
|
|
|
(GEP->isInBounds() && isa<GlobalVariable>(GEP->getOperand(0)) &&
|
2017-05-20 06:37:09 +08:00
|
|
|
NullTermIdx == ArrSize - 1)) {
|
|
|
|
Offset = B.CreateSExtOrTrunc(Offset, CI->getType());
|
|
|
|
return B.CreateSub(ConstantInt::get(CI->getType(), NullTermIdx),
|
2016-04-13 22:31:06 +08:00
|
|
|
Offset);
|
2017-05-20 06:37:09 +08:00
|
|
|
}
|
2016-04-13 22:31:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// strlen(x?"foo":"bars") --> x ? 3 : 4
|
|
|
|
if (SelectInst *SI = dyn_cast<SelectInst>(Src)) {
|
2017-05-20 06:37:09 +08:00
|
|
|
uint64_t LenTrue = GetStringLength(SI->getTrueValue(), CharSize);
|
|
|
|
uint64_t LenFalse = GetStringLength(SI->getFalseValue(), CharSize);
|
2014-09-18 04:55:46 +08:00
|
|
|
if (LenTrue && LenFalse) {
|
2017-07-27 03:03:18 +08:00
|
|
|
ORE.emit(OptimizationRemark("instcombine", "simplify-libcalls", CI)
|
|
|
|
<< "folded strlen(select) to select of constants");
|
2014-09-18 04:55:46 +08:00
|
|
|
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
|
|
|
|
2017-05-20 06:37:09 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrLen(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
return optimizeStringLength(CI, B, 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *LibCallSimplifier::optimizeWcslen(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Module &M = *CI->getParent()->getParent()->getParent();
|
|
|
|
unsigned WCharSize = TLI->getWCharSize(M) * 8;
|
|
|
|
|
|
|
|
return optimizeStringLength(CI, B, WCharSize);
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeStrPBrk(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
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());
|
|
|
|
|
2016-01-01 00:10:49 +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)
|
2016-01-20 03:46:10 +08:00
|
|
|
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) {
|
|
|
|
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.
|
2017-05-04 02:17:31 +08:00
|
|
|
CI->addParamAttr(0, Attribute::NoCapture);
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
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) {
|
|
|
|
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) {
|
|
|
|
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())
|
2016-01-20 03:46:10 +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) {
|
|
|
|
// 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))) {
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *StrLen = emitStrLen(CI->getArgOperand(1), B, DL, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
if (!StrLen)
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *StrNCmp = emitStrNCmp(CI->getArgOperand(0), CI->getArgOperand(1),
|
2014-09-18 04:55:46 +08:00
|
|
|
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)
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *Result = castToCStr(CI->getArgOperand(0), B);
|
2014-09-18 04:55:46 +08:00
|
|
|
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) {
|
2016-01-20 03:46:10 +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) {
|
|
|
|
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
|
2017-07-07 02:39:47 +08:00
|
|
|
if (LenC && LenC->isZero())
|
2015-03-21 23:36:21 +08:00
|
|
|
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) {
|
|
|
|
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;
|
|
|
|
|
2017-06-09 22:22:03 +08:00
|
|
|
uint64_t Len = LenC->getZExtValue();
|
2014-09-18 04:55:46 +08:00
|
|
|
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) {
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *LHSV = B.CreateZExt(B.CreateLoad(castToCStr(LHS, B), "lhsc"),
|
2014-09-18 04:55:46 +08:00
|
|
|
CI->getType(), "lhsv");
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *RHSV = B.CreateZExt(B.CreateLoad(castToCStr(RHS, B), "rhsc"),
|
2014-09-18 04:55:46 +08:00
|
|
|
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());
|
|
|
|
|
2016-01-01 00:10:49 +08:00
|
|
|
Value *LHSV =
|
|
|
|
B.CreateLoad(B.CreateBitCast(LHS, LHSPtrTy, "lhsc"), "lhsv");
|
|
|
|
Value *RHSV =
|
|
|
|
B.CreateLoad(B.CreateBitCast(RHS, RHSPtrTy, "rhsc"), "rhsv");
|
2015-08-29 02:30:18 +08:00
|
|
|
|
|
|
|
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) {
|
|
|
|
// memcpy(x, y, n) -> llvm.memcpy(x, y, n, 1)
|
|
|
|
B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
|
2015-11-19 13:56:52 +08:00
|
|
|
CI->getArgOperand(2), 1);
|
2014-09-18 04:55:46 +08:00
|
|
|
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) {
|
|
|
|
// memmove(x, y, n) -> llvm.memmove(x, y, n, 1)
|
|
|
|
B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
|
2015-11-19 13:56:52 +08:00
|
|
|
CI->getArgOperand(2), 1);
|
2014-09-18 04:55:46 +08:00
|
|
|
return CI->getArgOperand(0);
|
|
|
|
}
|
|
|
|
|
2016-01-27 00:17:24 +08:00
|
|
|
// TODO: Does this belong in BuildLibCalls or should all of those similar
|
|
|
|
// functions be moved here?
|
Rename AttributeSet to AttributeList
Summary:
This class is a list of AttributeSetNodes corresponding the function
prototype of a call or function declaration. This class used to be
called ParamAttrListPtr, then AttrListPtr, then AttributeSet. It is
typically accessed by parameter and return value index, so
"AttributeList" seems like a more intuitive name.
Rename AttributeSetImpl to AttributeListImpl to follow suit.
It's useful to rename this class so that we can rename AttributeSetNode
to AttributeSet later. AttributeSet is the set of attributes that apply
to a single function, argument, or return value.
Reviewers: sanjoy, javed.absar, chandlerc, pete
Reviewed By: pete
Subscribers: pete, jholewinski, arsenm, dschuff, mehdi_amini, jfb, nhaehnle, sbc100, void, llvm-commits
Differential Revision: https://reviews.llvm.org/D31102
llvm-svn: 298393
2017-03-22 00:57:19 +08:00
|
|
|
static Value *emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs,
|
2016-01-27 00:17:24 +08:00
|
|
|
IRBuilder<> &B, const TargetLibraryInfo &TLI) {
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2016-01-27 00:17:24 +08:00
|
|
|
if (!TLI.getLibFunc("calloc", Func) || !TLI.has(Func))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
Module *M = B.GetInsertBlock()->getModule();
|
|
|
|
const DataLayout &DL = M->getDataLayout();
|
|
|
|
IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
|
|
|
|
Value *Calloc = M->getOrInsertFunction("calloc", Attrs, B.getInt8PtrTy(),
|
2017-04-11 23:01:18 +08:00
|
|
|
PtrType, PtrType);
|
2016-01-27 00:17:24 +08:00
|
|
|
CallInst *CI = B.CreateCall(Calloc, { Num, Size }, "calloc");
|
|
|
|
|
|
|
|
if (const auto *F = dyn_cast<Function>(Calloc->stripPointerCasts()))
|
|
|
|
CI->setCallingConv(F->getCallingConv());
|
|
|
|
|
|
|
|
return CI;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Fold memset[_chk](malloc(n), 0, n) --> calloc(1, n).
|
|
|
|
static Value *foldMallocMemset(CallInst *Memset, IRBuilder<> &B,
|
|
|
|
const TargetLibraryInfo &TLI) {
|
|
|
|
// This has to be a memset of zeros (bzero).
|
|
|
|
auto *FillValue = dyn_cast<ConstantInt>(Memset->getArgOperand(1));
|
|
|
|
if (!FillValue || FillValue->getZExtValue() != 0)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// TODO: We should handle the case where the malloc has more than one use.
|
|
|
|
// This is necessary to optimize common patterns such as when the result of
|
|
|
|
// the malloc is checked against null or when a memset intrinsic is used in
|
|
|
|
// place of a memset library call.
|
|
|
|
auto *Malloc = dyn_cast<CallInst>(Memset->getArgOperand(0));
|
|
|
|
if (!Malloc || !Malloc->hasOneUse())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Is the inner call really malloc()?
|
|
|
|
Function *InnerCallee = Malloc->getCalledFunction();
|
2017-04-26 03:44:25 +08:00
|
|
|
if (!InnerCallee)
|
|
|
|
return nullptr;
|
|
|
|
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2016-04-28 03:04:35 +08:00
|
|
|
if (!TLI.getLibFunc(*InnerCallee, Func) || !TLI.has(Func) ||
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
Func != LibFunc_malloc)
|
2016-01-27 00:17:24 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// The memset must cover the same number of bytes that are malloc'd.
|
|
|
|
if (Memset->getArgOperand(2) != Malloc->getArgOperand(0))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Replace the malloc with a calloc. We need the data layout to know what the
|
|
|
|
// actual size of a 'size_t' parameter is.
|
|
|
|
B.SetInsertPoint(Malloc->getParent(), ++Malloc->getIterator());
|
|
|
|
const DataLayout &DL = Malloc->getModule()->getDataLayout();
|
|
|
|
IntegerType *SizeType = DL.getIntPtrType(B.GetInsertBlock()->getContext());
|
|
|
|
Value *Calloc = emitCalloc(ConstantInt::get(SizeType, 1),
|
|
|
|
Malloc->getArgOperand(0), Malloc->getAttributes(),
|
|
|
|
B, TLI);
|
|
|
|
if (!Calloc)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
Malloc->replaceAllUsesWith(Calloc);
|
|
|
|
Malloc->eraseFromParent();
|
|
|
|
|
|
|
|
return Calloc;
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilder<> &B) {
|
2016-01-27 00:17:24 +08:00
|
|
|
if (auto *Calloc = foldMallocMemset(CI, B, *TLI))
|
|
|
|
return Calloc;
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// 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;
|
2016-12-14 19:57:17 +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;
|
|
|
|
}
|
|
|
|
|
2016-01-22 02:01:57 +08:00
|
|
|
/// Shrink double -> float for unary functions like 'floor'.
|
|
|
|
static Value *optimizeUnaryDoubleFP(CallInst *CI, IRBuilder<> &B,
|
|
|
|
bool CheckRetType) {
|
2014-09-18 04:55:46 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
2016-04-28 03:04:35 +08:00
|
|
|
// We know this libcall has a valid prototype, but we don't know which.
|
|
|
|
if (!CI->getType()->isDoubleTy())
|
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
|
|
|
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;
|
2016-01-01 05:52:31 +08:00
|
|
|
|
2017-04-25 20:36:14 +08:00
|
|
|
// If call isn't an intrinsic, check that it isn't within a function with the
|
|
|
|
// same name as the float version of this call.
|
|
|
|
//
|
|
|
|
// e.g. inline float expf(float val) { return (float) exp((double) val); }
|
|
|
|
//
|
|
|
|
// A similar such definition exists in the MinGW-w64 math.h header file which
|
|
|
|
// when compiled with -O2 -ffast-math causes the generation of infinite loops
|
|
|
|
// where expf is called.
|
|
|
|
if (!Callee->isIntrinsic()) {
|
|
|
|
const Function *F = CI->getFunction();
|
|
|
|
StringRef FName = F->getName();
|
|
|
|
StringRef CalleeName = Callee->getName();
|
|
|
|
if ((FName.size() == (CalleeName.size() + 1)) &&
|
|
|
|
(FName.back() == 'f') &&
|
|
|
|
FName.startswith(CalleeName))
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-01-01 05:52:31 +08:00
|
|
|
// Propagate fast-math flags from the existing call to the new call.
|
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
2016-01-13 02:03:37 +08:00
|
|
|
B.setFastMathFlags(CI->getFastMathFlags());
|
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()) {
|
2015-12-15 01:24:23 +08:00
|
|
|
Module *M = CI->getModule();
|
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.
|
2016-01-20 03:46:10 +08:00
|
|
|
V = emitUnaryFloatFnCall(V, Callee->getName(), B, Callee->getAttributes());
|
2014-10-24 05:52:45 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
return B.CreateFPExt(V, B.getDoubleTy());
|
|
|
|
}
|
2012-11-13 12:16:17 +08:00
|
|
|
|
2017-01-24 07:55:08 +08:00
|
|
|
// Replace a libcall \p CI with a call to intrinsic \p IID
|
|
|
|
static Value *replaceUnaryCall(CallInst *CI, IRBuilder<> &B, Intrinsic::ID IID) {
|
|
|
|
// Propagate fast-math flags from the existing call to the new call.
|
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
|
|
|
B.setFastMathFlags(CI->getFastMathFlags());
|
|
|
|
|
|
|
|
Module *M = CI->getModule();
|
|
|
|
Value *V = CI->getArgOperand(0);
|
|
|
|
Function *F = Intrinsic::getDeclaration(M, IID, CI->getType());
|
|
|
|
CallInst *NewCall = B.CreateCall(F, V);
|
|
|
|
NewCall->takeName(CI);
|
|
|
|
return NewCall;
|
|
|
|
}
|
|
|
|
|
2016-01-22 02:01:57 +08:00
|
|
|
/// Shrink double -> float for binary functions like 'fmin/fmax'.
|
|
|
|
static Value *optimizeBinaryDoubleFP(CallInst *CI, IRBuilder<> &B) {
|
2014-09-18 04:55:46 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
2016-04-28 03:04:35 +08:00
|
|
|
// We know this libcall has a valid prototype, but we don't know which.
|
|
|
|
if (!CI->getType()->isDoubleTy())
|
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
|
|
|
// 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
|
|
|
|
2016-01-01 07:40:59 +08:00
|
|
|
// Propagate fast-math flags from the existing call to the new call.
|
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
2016-01-13 02:03:37 +08:00
|
|
|
B.setFastMathFlags(CI->getFastMathFlags());
|
2016-01-01 07:40:59 +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().
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *V = emitBinaryFloatFnCall(V1, V2, Callee->getName(), B,
|
2014-12-04 05:46:33 +08:00
|
|
|
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;
|
2015-11-06 03:18:23 +08:00
|
|
|
StringRef Name = Callee->getName();
|
|
|
|
if (UnsafeFPShrink && Name == "cos" && hasFloatVersion(Name))
|
2014-09-18 04:55:46 +08:00
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
2012-11-13 12:16:17 +08:00
|
|
|
|
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
|
|
|
|
[SimplifyLibCalls] Optimization for pow(x, n) where n is some constant
Summary:
In order to avoid calling pow function we generate repeated fmul when n is a
positive or negative whole number.
For each exponent we pre-compute Addition Chains in order to minimize the no.
of fmuls.
Refer: http://wwwhomes.uni-bielefeld.de/achim/addition_chain.html
We pre-compute addition chains for exponents upto 32 (which results in a max of
7 fmuls).
For eg:
4 = 2+2
5 = 2+3
6 = 3+3 and so on
Hence,
pow(x, 4.0) ==> y = fmul x, x
x = fmul y, y
ret x
For negative exponents, we simply compute the reciprocal of the final result.
Note: This transformation is only enabled under fast-math.
Patch by Mandeep Singh Grang <mgrang@codeaurora.org>
Reviewers: weimingz, majnemer, escha, davide, scanon, joerg
Subscribers: probinson, escha, llvm-commits
Differential Revision: http://reviews.llvm.org/D13994
llvm-svn: 254776
2015-12-05 06:00:47 +08:00
|
|
|
static Value *getPow(Value *InnerChain[33], unsigned Exp, IRBuilder<> &B) {
|
|
|
|
// Multiplications calculated using Addition Chains.
|
|
|
|
// Refer: http://wwwhomes.uni-bielefeld.de/achim/addition_chain.html
|
|
|
|
|
|
|
|
assert(Exp != 0 && "Incorrect exponent 0 not handled");
|
|
|
|
|
|
|
|
if (InnerChain[Exp])
|
|
|
|
return InnerChain[Exp];
|
|
|
|
|
|
|
|
static const unsigned AddChain[33][2] = {
|
|
|
|
{0, 0}, // Unused.
|
|
|
|
{0, 0}, // Unused (base case = pow1).
|
|
|
|
{1, 1}, // Unused (pre-computed).
|
|
|
|
{1, 2}, {2, 2}, {2, 3}, {3, 3}, {2, 5}, {4, 4},
|
|
|
|
{1, 8}, {5, 5}, {1, 10}, {6, 6}, {4, 9}, {7, 7},
|
|
|
|
{3, 12}, {8, 8}, {8, 9}, {2, 16}, {1, 18}, {10, 10},
|
|
|
|
{6, 15}, {11, 11}, {3, 20}, {12, 12}, {8, 17}, {13, 13},
|
|
|
|
{3, 24}, {14, 14}, {4, 25}, {15, 15}, {3, 28}, {16, 16},
|
|
|
|
};
|
|
|
|
|
|
|
|
InnerChain[Exp] = B.CreateFMul(getPow(InnerChain, AddChain[Exp][0], B),
|
|
|
|
getPow(InnerChain, AddChain[Exp][1], B));
|
|
|
|
return InnerChain[Exp];
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizePow(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
Value *Ret = nullptr;
|
2015-11-06 03:18:23 +08:00
|
|
|
StringRef Name = Callee->getName();
|
|
|
|
if (UnsafeFPShrink && Name == "pow" && hasFloatVersion(Name))
|
2014-09-18 04:55:46 +08:00
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
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);
|
2016-08-08 04:27:03 +08:00
|
|
|
|
|
|
|
// pow(1.0, x) -> 1.0
|
|
|
|
if (match(Op1, m_SpecificFP(1.0)))
|
|
|
|
return Op1;
|
|
|
|
// pow(2.0, x) -> llvm.exp2(x)
|
|
|
|
if (match(Op1, m_SpecificFP(2.0))) {
|
|
|
|
Value *Exp2 = Intrinsic::getDeclaration(CI->getModule(), Intrinsic::exp2,
|
|
|
|
CI->getType());
|
|
|
|
return B.CreateCall(Exp2, Op2, "exp2");
|
|
|
|
}
|
|
|
|
|
|
|
|
// There's no llvm.exp10 intrinsic yet, but, maybe, some day there will
|
|
|
|
// be one.
|
2014-09-18 04:55:46 +08:00
|
|
|
if (ConstantFP *Op1C = dyn_cast<ConstantFP>(Op1)) {
|
|
|
|
// pow(10.0, x) -> exp10(x)
|
|
|
|
if (Op1C->isExactlyValue(10.0) &&
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
hasUnaryFloatFn(TLI, Op1->getType(), LibFunc_exp10, LibFunc_exp10f,
|
|
|
|
LibFunc_exp10l))
|
|
|
|
return emitUnaryFloatFnCall(Op2, TLI->getName(LibFunc_exp10), B,
|
2014-09-18 04:55:46 +08:00
|
|
|
Callee->getAttributes());
|
|
|
|
}
|
|
|
|
|
2016-01-13 01:30:37 +08:00
|
|
|
// pow(exp(x), y) -> exp(x * y)
|
2015-11-04 04:32:23 +08:00
|
|
|
// pow(exp2(x), y) -> exp2(x * y)
|
2016-01-13 01:30:37 +08:00
|
|
|
// We enable these only with fast-math. Besides rounding differences, the
|
|
|
|
// transformation changes overflow and underflow behavior quite dramatically.
|
2015-11-04 04:32:23 +08:00
|
|
|
// Example: x = 1000, y = 0.001.
|
|
|
|
// pow(exp(x), y) = pow(inf, 0.001) = inf, whereas exp(x*y) = exp(1).
|
2016-01-13 01:30:37 +08:00
|
|
|
auto *OpC = dyn_cast<CallInst>(Op1);
|
|
|
|
if (OpC && OpC->hasUnsafeAlgebra() && CI->hasUnsafeAlgebra()) {
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2016-01-13 01:30:37 +08:00
|
|
|
Function *OpCCallee = OpC->getCalledFunction();
|
|
|
|
if (OpCCallee && TLI->getLibFunc(OpCCallee->getName(), Func) &&
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
TLI->has(Func) && (Func == LibFunc_exp || Func == LibFunc_exp2)) {
|
2015-11-04 04:32:23 +08:00
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
2016-01-13 02:03:37 +08:00
|
|
|
B.setFastMathFlags(CI->getFastMathFlags());
|
2016-01-13 01:30:37 +08:00
|
|
|
Value *FMul = B.CreateFMul(OpC->getArgOperand(0), Op2, "mul");
|
2016-01-20 03:46:10 +08:00
|
|
|
return emitUnaryFloatFnCall(FMul, OpCCallee->getName(), B,
|
2016-01-13 01:30:37 +08:00
|
|
|
OpCCallee->getAttributes());
|
2015-11-04 04:32:23 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
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);
|
|
|
|
|
2017-01-10 05:55:23 +08:00
|
|
|
if (Op2C->isExactlyValue(-0.5) &&
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
hasUnaryFloatFn(TLI, Op2->getType(), LibFunc_sqrt, LibFunc_sqrtf,
|
|
|
|
LibFunc_sqrtl)) {
|
2017-01-10 05:55:23 +08:00
|
|
|
// If -ffast-math:
|
|
|
|
// pow(x, -0.5) -> 1.0 / sqrt(x)
|
|
|
|
if (CI->hasUnsafeAlgebra()) {
|
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
|
|
|
B.setFastMathFlags(CI->getFastMathFlags());
|
|
|
|
|
[LangRef] Make @llvm.sqrt(x) return undef, rather than have UB, for negative x.
Summary:
Some frontends emit a speculate-and-select idiom for sqrt, wherein they compute
sqrt(x), check if x is negative, and select NaN if it is:
%cmp = fcmp olt double %a, -0.000000e+00
%sqrt = call double @llvm.sqrt.f64(double %a)
%ret = select i1 %cmp, double 0x7FF8000000000000, double %sqrt
This is technically UB as the LangRef is written today if %a is ever less than
-0. But emitting code that's compliant with the current definition of sqrt
would require a branch, which would then prevent us from matching this idiom in
SelectionDAG (which we do today -- ISD::FSQRT has defined behavior on negative
inputs), because SelectionDAG looks at one BB at a time.
Nothing in LLVM takes advantage of this undefined behavior, as far as we can
tell, and the fact that llvm.sqrt has UB dates from its initial addition to the
LangRef.
Reviewers: arsenm, mehdi_amini, hfinkel
Subscribers: wdng, llvm-commits
Differential Revision: https://reviews.llvm.org/D28797
llvm-svn: 293242
2017-01-27 08:58:03 +08:00
|
|
|
// TODO: If the pow call is an intrinsic, we should lower to the sqrt
|
|
|
|
// intrinsic, so we match errno semantics. We also should check that the
|
|
|
|
// target can in fact lower the sqrt intrinsic -- we currently have no way
|
|
|
|
// to ask this question other than asking whether the target has a sqrt
|
|
|
|
// libcall, which is a sufficient but not necessary condition.
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
Value *Sqrt = emitUnaryFloatFnCall(Op1, TLI->getName(LibFunc_sqrt), B,
|
2017-01-10 05:55:23 +08:00
|
|
|
Callee->getAttributes());
|
|
|
|
|
|
|
|
return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), Sqrt, "sqrtrecip");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
if (Op2C->isExactlyValue(0.5) &&
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
hasUnaryFloatFn(TLI, Op2->getType(), LibFunc_sqrt, LibFunc_sqrtf,
|
|
|
|
LibFunc_sqrtl)) {
|
2015-11-19 07:21:32 +08:00
|
|
|
|
|
|
|
// In -ffast-math, pow(x, 0.5) -> sqrt(x).
|
2016-01-13 03:06:35 +08:00
|
|
|
if (CI->hasUnsafeAlgebra()) {
|
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
|
|
|
B.setFastMathFlags(CI->getFastMathFlags());
|
2016-08-10 14:33:32 +08:00
|
|
|
|
[LangRef] Make @llvm.sqrt(x) return undef, rather than have UB, for negative x.
Summary:
Some frontends emit a speculate-and-select idiom for sqrt, wherein they compute
sqrt(x), check if x is negative, and select NaN if it is:
%cmp = fcmp olt double %a, -0.000000e+00
%sqrt = call double @llvm.sqrt.f64(double %a)
%ret = select i1 %cmp, double 0x7FF8000000000000, double %sqrt
This is technically UB as the LangRef is written today if %a is ever less than
-0. But emitting code that's compliant with the current definition of sqrt
would require a branch, which would then prevent us from matching this idiom in
SelectionDAG (which we do today -- ISD::FSQRT has defined behavior on negative
inputs), because SelectionDAG looks at one BB at a time.
Nothing in LLVM takes advantage of this undefined behavior, as far as we can
tell, and the fact that llvm.sqrt has UB dates from its initial addition to the
LangRef.
Reviewers: arsenm, mehdi_amini, hfinkel
Subscribers: wdng, llvm-commits
Differential Revision: https://reviews.llvm.org/D28797
llvm-svn: 293242
2017-01-27 08:58:03 +08:00
|
|
|
// TODO: As above, we should lower to the sqrt intrinsic if the pow is an
|
|
|
|
// intrinsic, to match errno semantics.
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
return emitUnaryFloatFnCall(Op1, TLI->getName(LibFunc_sqrt), B,
|
2016-08-10 14:33:32 +08:00
|
|
|
Callee->getAttributes());
|
2016-01-13 03:06:35 +08:00
|
|
|
}
|
2015-11-19 07:21:32 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
// 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 finite-only mode, this could be just fabs(sqrt(x)).
|
|
|
|
Value *Inf = ConstantFP::getInfinity(CI->getType());
|
|
|
|
Value *NegInf = ConstantFP::getInfinity(CI->getType(), true);
|
[LangRef] Make @llvm.sqrt(x) return undef, rather than have UB, for negative x.
Summary:
Some frontends emit a speculate-and-select idiom for sqrt, wherein they compute
sqrt(x), check if x is negative, and select NaN if it is:
%cmp = fcmp olt double %a, -0.000000e+00
%sqrt = call double @llvm.sqrt.f64(double %a)
%ret = select i1 %cmp, double 0x7FF8000000000000, double %sqrt
This is technically UB as the LangRef is written today if %a is ever less than
-0. But emitting code that's compliant with the current definition of sqrt
would require a branch, which would then prevent us from matching this idiom in
SelectionDAG (which we do today -- ISD::FSQRT has defined behavior on negative
inputs), because SelectionDAG looks at one BB at a time.
Nothing in LLVM takes advantage of this undefined behavior, as far as we can
tell, and the fact that llvm.sqrt has UB dates from its initial addition to the
LangRef.
Reviewers: arsenm, mehdi_amini, hfinkel
Subscribers: wdng, llvm-commits
Differential Revision: https://reviews.llvm.org/D28797
llvm-svn: 293242
2017-01-27 08:58:03 +08:00
|
|
|
|
|
|
|
// TODO: As above, we should lower to the sqrt intrinsic if the pow is an
|
|
|
|
// intrinsic, to match errno semantics.
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *Sqrt = emitUnaryFloatFnCall(Op1, "sqrt", B, Callee->getAttributes());
|
2017-01-17 08:30:31 +08:00
|
|
|
|
|
|
|
Module *M = Callee->getParent();
|
|
|
|
Function *FabsF = Intrinsic::getDeclaration(M, Intrinsic::fabs,
|
|
|
|
CI->getType());
|
|
|
|
Value *FAbs = B.CreateCall(FabsF, Sqrt);
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
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");
|
[SimplifyLibCalls] Optimization for pow(x, n) where n is some constant
Summary:
In order to avoid calling pow function we generate repeated fmul when n is a
positive or negative whole number.
For each exponent we pre-compute Addition Chains in order to minimize the no.
of fmuls.
Refer: http://wwwhomes.uni-bielefeld.de/achim/addition_chain.html
We pre-compute addition chains for exponents upto 32 (which results in a max of
7 fmuls).
For eg:
4 = 2+2
5 = 2+3
6 = 3+3 and so on
Hence,
pow(x, 4.0) ==> y = fmul x, x
x = fmul y, y
ret x
For negative exponents, we simply compute the reciprocal of the final result.
Note: This transformation is only enabled under fast-math.
Patch by Mandeep Singh Grang <mgrang@codeaurora.org>
Reviewers: weimingz, majnemer, escha, davide, scanon, joerg
Subscribers: probinson, escha, llvm-commits
Differential Revision: http://reviews.llvm.org/D13994
llvm-svn: 254776
2015-12-05 06:00:47 +08:00
|
|
|
|
|
|
|
// In -ffast-math, generate repeated fmul instead of generating pow(x, n).
|
2016-01-20 02:15:12 +08:00
|
|
|
if (CI->hasUnsafeAlgebra()) {
|
[SimplifyLibCalls] Optimization for pow(x, n) where n is some constant
Summary:
In order to avoid calling pow function we generate repeated fmul when n is a
positive or negative whole number.
For each exponent we pre-compute Addition Chains in order to minimize the no.
of fmuls.
Refer: http://wwwhomes.uni-bielefeld.de/achim/addition_chain.html
We pre-compute addition chains for exponents upto 32 (which results in a max of
7 fmuls).
For eg:
4 = 2+2
5 = 2+3
6 = 3+3 and so on
Hence,
pow(x, 4.0) ==> y = fmul x, x
x = fmul y, y
ret x
For negative exponents, we simply compute the reciprocal of the final result.
Note: This transformation is only enabled under fast-math.
Patch by Mandeep Singh Grang <mgrang@codeaurora.org>
Reviewers: weimingz, majnemer, escha, davide, scanon, joerg
Subscribers: probinson, escha, llvm-commits
Differential Revision: http://reviews.llvm.org/D13994
llvm-svn: 254776
2015-12-05 06:00:47 +08:00
|
|
|
APFloat V = abs(Op2C->getValueAPF());
|
|
|
|
// We limit to a max of 7 fmul(s). Thus max exponent is 32.
|
|
|
|
// This transformation applies to integer exponents only.
|
|
|
|
if (V.compare(APFloat(V.getSemantics(), 32.0)) == APFloat::cmpGreaterThan ||
|
|
|
|
!V.isInteger())
|
|
|
|
return nullptr;
|
|
|
|
|
2017-01-11 02:02:05 +08:00
|
|
|
// Propagate fast math flags.
|
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
|
|
|
B.setFastMathFlags(CI->getFastMathFlags());
|
|
|
|
|
[SimplifyLibCalls] Optimization for pow(x, n) where n is some constant
Summary:
In order to avoid calling pow function we generate repeated fmul when n is a
positive or negative whole number.
For each exponent we pre-compute Addition Chains in order to minimize the no.
of fmuls.
Refer: http://wwwhomes.uni-bielefeld.de/achim/addition_chain.html
We pre-compute addition chains for exponents upto 32 (which results in a max of
7 fmuls).
For eg:
4 = 2+2
5 = 2+3
6 = 3+3 and so on
Hence,
pow(x, 4.0) ==> y = fmul x, x
x = fmul y, y
ret x
For negative exponents, we simply compute the reciprocal of the final result.
Note: This transformation is only enabled under fast-math.
Patch by Mandeep Singh Grang <mgrang@codeaurora.org>
Reviewers: weimingz, majnemer, escha, davide, scanon, joerg
Subscribers: probinson, escha, llvm-commits
Differential Revision: http://reviews.llvm.org/D13994
llvm-svn: 254776
2015-12-05 06:00:47 +08:00
|
|
|
// We will memoize intermediate products of the Addition Chain.
|
|
|
|
Value *InnerChain[33] = {nullptr};
|
|
|
|
InnerChain[1] = Op1;
|
|
|
|
InnerChain[2] = B.CreateFMul(Op1, Op1);
|
|
|
|
|
|
|
|
// We cannot readily convert a non-double type (like float) to a double.
|
|
|
|
// So we first convert V to something which could be converted to double.
|
|
|
|
bool ignored;
|
2016-12-14 19:57:17 +08:00
|
|
|
V.convert(APFloat::IEEEdouble(), APFloat::rmTowardZero, &ignored);
|
2016-01-20 02:15:12 +08:00
|
|
|
|
[SimplifyLibCalls] Optimization for pow(x, n) where n is some constant
Summary:
In order to avoid calling pow function we generate repeated fmul when n is a
positive or negative whole number.
For each exponent we pre-compute Addition Chains in order to minimize the no.
of fmuls.
Refer: http://wwwhomes.uni-bielefeld.de/achim/addition_chain.html
We pre-compute addition chains for exponents upto 32 (which results in a max of
7 fmuls).
For eg:
4 = 2+2
5 = 2+3
6 = 3+3 and so on
Hence,
pow(x, 4.0) ==> y = fmul x, x
x = fmul y, y
ret x
For negative exponents, we simply compute the reciprocal of the final result.
Note: This transformation is only enabled under fast-math.
Patch by Mandeep Singh Grang <mgrang@codeaurora.org>
Reviewers: weimingz, majnemer, escha, davide, scanon, joerg
Subscribers: probinson, escha, llvm-commits
Differential Revision: http://reviews.llvm.org/D13994
llvm-svn: 254776
2015-12-05 06:00:47 +08:00
|
|
|
Value *FMul = getPow(InnerChain, V.convertToDouble(), B);
|
|
|
|
// For negative exponents simply compute the reciprocal.
|
|
|
|
if (Op2C->isNegative())
|
|
|
|
FMul = B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), FMul);
|
|
|
|
return FMul;
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
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();
|
|
|
|
Value *Ret = nullptr;
|
2015-11-06 03:18:23 +08:00
|
|
|
StringRef Name = Callee->getName();
|
|
|
|
if (UnsafeFPShrink && Name == "exp2" && hasFloatVersion(Name))
|
2014-09-18 04:55:46 +08:00
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
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
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc LdExp = LibFunc_ldexpl;
|
2014-09-18 04:55:46 +08:00
|
|
|
if (Op->getType()->isFloatTy())
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LdExp = LibFunc_ldexpf;
|
2014-09-18 04:55:46 +08:00
|
|
|
else if (Op->getType()->isDoubleTy())
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LdExp = LibFunc_ldexp;
|
2014-09-18 04:55:46 +08:00
|
|
|
|
|
|
|
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
|
|
|
|
2016-01-22 06:31:18 +08:00
|
|
|
Module *M = CI->getModule();
|
2017-04-07 04:23:57 +08:00
|
|
|
Value *NewCallee =
|
|
|
|
M->getOrInsertFunction(TLI->getName(LdExp), Op->getType(),
|
2017-04-11 23:01:18 +08:00
|
|
|
Op->getType(), B.getInt32Ty());
|
2016-01-22 06:41:16 +08:00
|
|
|
CallInst *CI = B.CreateCall(NewCallee, {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
|
|
|
|
2015-08-17 04:18:19 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFMinFMax(CallInst *CI, IRBuilder<> &B) {
|
2016-01-22 06:58:01 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
2015-08-17 04:18:19 +08:00
|
|
|
// If we can shrink the call to a float function rather than a double
|
|
|
|
// function, do that first.
|
2015-11-06 03:18:23 +08:00
|
|
|
StringRef Name = Callee->getName();
|
2016-01-06 08:32:15 +08:00
|
|
|
if ((Name == "fmin" || Name == "fmax") && hasFloatVersion(Name))
|
|
|
|
if (Value *Ret = optimizeBinaryDoubleFP(CI, B))
|
2015-08-17 04:18:19 +08:00
|
|
|
return Ret;
|
|
|
|
|
2015-08-17 05:16:37 +08:00
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
2015-08-17 04:18:19 +08:00
|
|
|
FastMathFlags FMF;
|
2016-01-06 04:46:19 +08:00
|
|
|
if (CI->hasUnsafeAlgebra()) {
|
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.
|
2016-01-06 04:46:19 +08:00
|
|
|
if (!CI->hasNoNaNs())
|
2015-08-17 04:18:19 +08:00
|
|
|
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();
|
|
|
|
}
|
2016-01-13 02:03:37 +08:00
|
|
|
B.setFastMathFlags(FMF);
|
2015-08-17 04:18:19 +08:00
|
|
|
|
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
|
2015-11-30 04:58:04 +08:00
|
|
|
Value *LibCallSimplifier::optimizeLog(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
Value *Ret = nullptr;
|
|
|
|
StringRef Name = Callee->getName();
|
|
|
|
if (UnsafeFPShrink && hasFloatVersion(Name))
|
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
|
|
|
|
2016-01-12 07:31:48 +08:00
|
|
|
if (!CI->hasUnsafeAlgebra())
|
2015-11-30 04:58:04 +08:00
|
|
|
return Ret;
|
|
|
|
Value *Op1 = CI->getArgOperand(0);
|
|
|
|
auto *OpC = dyn_cast<CallInst>(Op1);
|
2016-01-12 07:31:48 +08:00
|
|
|
|
|
|
|
// The earlier call must also be unsafe in order to do these transforms.
|
|
|
|
if (!OpC || !OpC->hasUnsafeAlgebra())
|
2015-11-30 04:58:04 +08:00
|
|
|
return Ret;
|
|
|
|
|
|
|
|
// log(pow(x,y)) -> y*log(x)
|
|
|
|
// This is only applicable to log, log2, log10.
|
|
|
|
if (Name != "log" && Name != "log2" && Name != "log10")
|
|
|
|
return Ret;
|
|
|
|
|
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
|
|
|
FastMathFlags FMF;
|
|
|
|
FMF.setUnsafeAlgebra();
|
2016-01-13 02:03:37 +08:00
|
|
|
B.setFastMathFlags(FMF);
|
2015-11-30 04:58:04 +08:00
|
|
|
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2015-11-30 04:58:04 +08:00
|
|
|
Function *F = OpC->getCalledFunction();
|
2015-11-30 05:58:56 +08:00
|
|
|
if (F && ((TLI->getLibFunc(F->getName(), Func) && TLI->has(Func) &&
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
Func == LibFunc_pow) || F->getIntrinsicID() == Intrinsic::pow))
|
2015-11-30 04:58:04 +08:00
|
|
|
return B.CreateFMul(OpC->getArgOperand(1),
|
2016-01-20 03:46:10 +08:00
|
|
|
emitUnaryFloatFnCall(OpC->getOperand(0), Callee->getName(), B,
|
2015-11-30 04:58:04 +08:00
|
|
|
Callee->getAttributes()), "mul");
|
2015-12-01 03:36:35 +08:00
|
|
|
|
|
|
|
// log(exp2(y)) -> y*log(2)
|
|
|
|
if (F && Name == "log" && TLI->getLibFunc(F->getName(), Func) &&
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
TLI->has(Func) && Func == LibFunc_exp2)
|
2015-12-01 03:36:35 +08:00
|
|
|
return B.CreateFMul(
|
|
|
|
OpC->getArgOperand(0),
|
2016-01-20 03:46:10 +08:00
|
|
|
emitUnaryFloatFnCall(ConstantFP::get(CI->getType(), 2.0),
|
2015-12-01 03:36:35 +08:00
|
|
|
Callee->getName(), B, Callee->getAttributes()),
|
|
|
|
"logmul");
|
2015-11-30 04:58:04 +08:00
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
2014-10-17 02:48:17 +08:00
|
|
|
Value *LibCallSimplifier::optimizeSqrt(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
Value *Ret = nullptr;
|
[LangRef] Make @llvm.sqrt(x) return undef, rather than have UB, for negative x.
Summary:
Some frontends emit a speculate-and-select idiom for sqrt, wherein they compute
sqrt(x), check if x is negative, and select NaN if it is:
%cmp = fcmp olt double %a, -0.000000e+00
%sqrt = call double @llvm.sqrt.f64(double %a)
%ret = select i1 %cmp, double 0x7FF8000000000000, double %sqrt
This is technically UB as the LangRef is written today if %a is ever less than
-0. But emitting code that's compliant with the current definition of sqrt
would require a branch, which would then prevent us from matching this idiom in
SelectionDAG (which we do today -- ISD::FSQRT has defined behavior on negative
inputs), because SelectionDAG looks at one BB at a time.
Nothing in LLVM takes advantage of this undefined behavior, as far as we can
tell, and the fact that llvm.sqrt has UB dates from its initial addition to the
LangRef.
Reviewers: arsenm, mehdi_amini, hfinkel
Subscribers: wdng, llvm-commits
Differential Revision: https://reviews.llvm.org/D28797
llvm-svn: 293242
2017-01-27 08:58:03 +08:00
|
|
|
// TODO: Once we have a way (other than checking for the existince of the
|
|
|
|
// libcall) to tell whether our target can lower @llvm.sqrt, relax the
|
|
|
|
// condition below.
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
if (TLI->has(LibFunc_sqrtf) && (Callee->getName() == "sqrt" ||
|
[LangRef] Make @llvm.sqrt(x) return undef, rather than have UB, for negative x.
Summary:
Some frontends emit a speculate-and-select idiom for sqrt, wherein they compute
sqrt(x), check if x is negative, and select NaN if it is:
%cmp = fcmp olt double %a, -0.000000e+00
%sqrt = call double @llvm.sqrt.f64(double %a)
%ret = select i1 %cmp, double 0x7FF8000000000000, double %sqrt
This is technically UB as the LangRef is written today if %a is ever less than
-0. But emitting code that's compliant with the current definition of sqrt
would require a branch, which would then prevent us from matching this idiom in
SelectionDAG (which we do today -- ISD::FSQRT has defined behavior on negative
inputs), because SelectionDAG looks at one BB at a time.
Nothing in LLVM takes advantage of this undefined behavior, as far as we can
tell, and the fact that llvm.sqrt has UB dates from its initial addition to the
LangRef.
Reviewers: arsenm, mehdi_amini, hfinkel
Subscribers: wdng, llvm-commits
Differential Revision: https://reviews.llvm.org/D28797
llvm-svn: 293242
2017-01-27 08:58:03 +08:00
|
|
|
Callee->getIntrinsicID() == Intrinsic::sqrt))
|
2014-10-17 02:48:17 +08:00
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
2016-01-12 06:34:19 +08:00
|
|
|
|
|
|
|
if (!CI->hasUnsafeAlgebra())
|
2015-10-29 10:58:44 +08:00
|
|
|
return Ret;
|
2014-10-17 02:48:17 +08:00
|
|
|
|
2016-01-07 04:52:21 +08:00
|
|
|
Instruction *I = dyn_cast<Instruction>(CI->getArgOperand(0));
|
|
|
|
if (!I || I->getOpcode() != Instruction::FMul || !I->hasUnsafeAlgebra())
|
|
|
|
return Ret;
|
|
|
|
|
|
|
|
// We're looking for a repeated factor in a multiplication tree,
|
|
|
|
// so we can do this fold: sqrt(x * x) -> fabs(x);
|
2016-01-12 06:34:19 +08:00
|
|
|
// or this fold: sqrt((x * x) * y) -> fabs(x) * sqrt(y).
|
2016-01-07 04:52:21 +08:00
|
|
|
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)
|
2016-01-12 06:50:36 +08:00
|
|
|
if (OtherMul0 == OtherMul1 &&
|
|
|
|
cast<Instruction>(Op0)->hasUnsafeAlgebra()) {
|
2016-01-07 04:52:21 +08:00
|
|
|
// Matched: sqrt((x * x) * z)
|
|
|
|
RepeatOp = OtherMul0;
|
|
|
|
OtherOp = Op1;
|
2014-10-17 02:48:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-01-07 04:52:21 +08:00
|
|
|
if (!RepeatOp)
|
|
|
|
return Ret;
|
|
|
|
|
|
|
|
// Fast math flags for any created instructions should match the sqrt
|
|
|
|
// and multiply.
|
|
|
|
IRBuilder<>::FastMathFlagGuard Guard(B);
|
2016-01-13 02:03:37 +08:00
|
|
|
B.setFastMathFlags(I->getFastMathFlags());
|
2016-01-12 06:35:39 +08:00
|
|
|
|
2016-01-07 04:52:21 +08:00
|
|
|
// 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 = I->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;
|
2014-10-17 02:48:17 +08:00
|
|
|
}
|
|
|
|
|
2016-01-07 03:23:35 +08:00
|
|
|
// TODO: Generalize to handle any trig function and its inverse.
|
2015-11-05 07:36:56 +08:00
|
|
|
Value *LibCallSimplifier::optimizeTan(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
Value *Ret = nullptr;
|
2015-11-06 03:18:23 +08:00
|
|
|
StringRef Name = Callee->getName();
|
|
|
|
if (UnsafeFPShrink && Name == "tan" && hasFloatVersion(Name))
|
2015-11-05 07:36:56 +08:00
|
|
|
Ret = optimizeUnaryDoubleFP(CI, B, true);
|
|
|
|
|
|
|
|
Value *Op1 = CI->getArgOperand(0);
|
|
|
|
auto *OpC = dyn_cast<CallInst>(Op1);
|
|
|
|
if (!OpC)
|
|
|
|
return Ret;
|
|
|
|
|
2016-01-07 03:23:35 +08:00
|
|
|
// Both calls must allow unsafe optimizations in order to remove them.
|
|
|
|
if (!CI->hasUnsafeAlgebra() || !OpC->hasUnsafeAlgebra())
|
|
|
|
return Ret;
|
|
|
|
|
2015-11-05 07:36:56 +08:00
|
|
|
// tan(atan(x)) -> x
|
|
|
|
// tanf(atanf(x)) -> x
|
|
|
|
// tanl(atanl(x)) -> x
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2015-11-05 07:36:56 +08:00
|
|
|
Function *F = OpC->getCalledFunction();
|
2015-11-26 17:51:17 +08:00
|
|
|
if (F && TLI->getLibFunc(F->getName(), Func) && TLI->has(Func) &&
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
((Func == LibFunc_atan && Callee->getName() == "tan") ||
|
|
|
|
(Func == LibFunc_atanf && Callee->getName() == "tanf") ||
|
|
|
|
(Func == LibFunc_atanl && Callee->getName() == "tanl")))
|
2015-11-05 07:36:56 +08:00
|
|
|
Ret = OpC->getArgOperand(0);
|
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:38:43 +08:00
|
|
|
static bool isTrigLibCall(CallInst *CI) {
|
|
|
|
// We can only hope to do anything useful if we can ignore things like errno
|
|
|
|
// and floating-point exceptions.
|
2016-04-28 03:04:35 +08:00
|
|
|
// We already checked the prototype.
|
|
|
|
return CI->hasFnAttr(Attribute::NoUnwind) &&
|
|
|
|
CI->hasFnAttr(Attribute::ReadNone);
|
2016-01-22 07:38:43 +08:00
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
static void insertSinCosCall(IRBuilder<> &B, Function *OrigCallee, Value *Arg,
|
|
|
|
bool UseFloat, Value *&Sin, Value *&Cos,
|
2016-01-22 07:38:43 +08:00
|
|
|
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
|
2017-05-10 03:31:13 +08:00
|
|
|
? static_cast<Type *>(VectorType::get(ArgTy, 2))
|
|
|
|
: static_cast<Type *>(StructType::get(ArgTy, ArgTy));
|
2016-01-22 07:38:43 +08:00
|
|
|
} else {
|
|
|
|
Name = "__sincospi_stret";
|
2017-05-10 03:31:13 +08:00
|
|
|
ResTy = StructType::get(ArgTy, ArgTy);
|
2016-01-22 07:38:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Module *M = OrigCallee->getParent();
|
2017-04-07 04:23:57 +08:00
|
|
|
Value *Callee = M->getOrInsertFunction(Name, OrigCallee->getAttributes(),
|
2017-04-11 23:01:18 +08:00
|
|
|
ResTy, ArgTy);
|
2016-01-22 07:38:43 +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.
|
|
|
|
B.SetInsertPoint(ArgInst->getParent(), ++ArgInst->getIterator());
|
|
|
|
} 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");
|
|
|
|
}
|
|
|
|
}
|
2013-11-03 14:48:38 +08:00
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeSinCosPi(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// 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.
|
2016-03-19 12:53:02 +08:00
|
|
|
Function *F = CI->getFunction();
|
2014-09-18 04:55:46 +08:00
|
|
|
for (User *U : Arg->users())
|
2016-03-19 12:53:02 +08:00
|
|
|
classifyArgUse(U, F, 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
|
|
|
|
2016-12-16 10:28:38 +08:00
|
|
|
auto replaceTrigInsts = [this](SmallVectorImpl<CallInst *> &Calls,
|
|
|
|
Value *Res) {
|
|
|
|
for (CallInst *C : Calls)
|
|
|
|
replaceAllUsesWith(C, Res);
|
|
|
|
};
|
|
|
|
|
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
|
|
|
|
2016-03-19 12:53:02 +08:00
|
|
|
void LibCallSimplifier::classifyArgUse(
|
|
|
|
Value *Val, Function *F, bool IsFloat,
|
|
|
|
SmallVectorImpl<CallInst *> &SinCalls,
|
|
|
|
SmallVectorImpl<CallInst *> &CosCalls,
|
|
|
|
SmallVectorImpl<CallInst *> &SinCosCalls) {
|
2014-09-18 04:55:46 +08:00
|
|
|
CallInst *CI = dyn_cast<CallInst>(Val);
|
|
|
|
|
|
|
|
if (!CI)
|
|
|
|
return;
|
2012-11-26 11:10:07 +08:00
|
|
|
|
2016-03-19 12:53:02 +08:00
|
|
|
// Don't consider calls in other functions.
|
|
|
|
if (CI->getFunction() != F)
|
|
|
|
return;
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2016-04-28 03:04:35 +08:00
|
|
|
if (!Callee || !TLI->getLibFunc(*Callee, Func) || !TLI->has(Func) ||
|
2015-11-29 05:43:12 +08:00
|
|
|
!isTrigLibCall(CI))
|
2014-09-18 04:55:46 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (IsFloat) {
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
if (Func == LibFunc_sinpif)
|
2014-09-18 04:55:46 +08:00
|
|
|
SinCalls.push_back(CI);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
else if (Func == LibFunc_cospif)
|
2014-09-18 04:55:46 +08:00
|
|
|
CosCalls.push_back(CI);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
else if (Func == LibFunc_sincospif_stret)
|
2014-09-18 04:55:46 +08:00
|
|
|
SinCosCalls.push_back(CI);
|
|
|
|
} else {
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
if (Func == LibFunc_sinpi)
|
2014-09-18 04:55:46 +08:00
|
|
|
SinCalls.push_back(CI);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
else if (Func == LibFunc_cospi)
|
2014-09-18 04:55:46 +08:00
|
|
|
CosCalls.push_back(CI);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
else if (Func == LibFunc_sincospi_stret)
|
2014-09-18 04:55:46 +08:00
|
|
|
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
|
|
|
|
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
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFFS(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// ffs(x) -> x != 0 ? (i32)llvm.cttz(x)+1 : 0
|
2016-12-16 07:11:00 +08:00
|
|
|
Value *Op = CI->getArgOperand(0);
|
2014-09-18 04:55:46 +08:00
|
|
|
Type *ArgType = Op->getType();
|
2016-12-16 07:11:00 +08:00
|
|
|
Value *F = Intrinsic::getDeclaration(CI->getCalledFunction()->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));
|
|
|
|
}
|
|
|
|
|
2016-12-16 07:45:11 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFls(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// fls(x) -> (i32)(sizeInBits(x) - llvm.ctlz(x, false))
|
|
|
|
Value *Op = CI->getArgOperand(0);
|
|
|
|
Type *ArgType = Op->getType();
|
|
|
|
Value *F = Intrinsic::getDeclaration(CI->getCalledFunction()->getParent(),
|
|
|
|
Intrinsic::ctlz, ArgType);
|
|
|
|
Value *V = B.CreateCall(F, {Op, B.getFalse()}, "ctlz");
|
|
|
|
V = B.CreateSub(ConstantInt::get(V->getType(), ArgType->getIntegerBitWidth()),
|
|
|
|
V);
|
|
|
|
return B.CreateIntCast(V, CI->getType(), false);
|
|
|
|
}
|
|
|
|
|
2014-09-18 04:55:46 +08:00
|
|
|
Value *LibCallSimplifier::optimizeAbs(CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// 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) {
|
|
|
|
// 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) {
|
|
|
|
// 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) {
|
|
|
|
// 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) {
|
2016-04-28 03:04:35 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
2014-09-18 04:55:46 +08:00
|
|
|
// 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
|
|
|
|
if (!CI->hasFnAttr(Attribute::Cold) &&
|
|
|
|
isReportingError(Callee, CI, StreamArg)) {
|
Rename AttributeSet to AttributeList
Summary:
This class is a list of AttributeSetNodes corresponding the function
prototype of a call or function declaration. This class used to be
called ParamAttrListPtr, then AttrListPtr, then AttributeSet. It is
typically accessed by parameter and return value index, so
"AttributeList" seems like a more intuitive name.
Rename AttributeSetImpl to AttributeListImpl to follow suit.
It's useful to rename this class so that we can rename AttributeSetNode
to AttributeSet later. AttributeSet is the set of attributes that apply
to a single function, argument, or return value.
Reviewers: sanjoy, javed.absar, chandlerc, pete
Reviewed By: pete
Subscribers: pete, jholewinski, arsenm, dschuff, mehdi_amini, jfb, nhaehnle, sbc100, void, llvm-commits
Differential Revision: https://reviews.llvm.org/D31102
llvm-svn: 298393
2017-03-22 00:57:19 +08:00
|
|
|
CI->addAttribute(AttributeList::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) {
|
2017-04-25 11:48:47 +08:00
|
|
|
if (!Callee || !Callee->isDeclaration())
|
2014-09-18 04:55:46 +08:00
|
|
|
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
|
|
|
|
2016-05-09 22:36:16 +08:00
|
|
|
// printf("x") -> putchar('x'), even for "%" and "%%".
|
|
|
|
if (FormatStr.size() == 1 || FormatStr == "%%")
|
2016-04-03 09:46:52 +08:00
|
|
|
return emitPutChar(B.getInt32(FormatStr[0]), B, TLI);
|
2012-11-27 13:57:54 +08:00
|
|
|
|
2016-03-28 23:54:01 +08:00
|
|
|
// printf("%s", "a") --> putchar('a')
|
|
|
|
if (FormatStr == "%s" && CI->getNumArgOperands() > 1) {
|
|
|
|
StringRef ChrStr;
|
|
|
|
if (!getConstantStringInfo(CI->getOperand(1), ChrStr))
|
|
|
|
return nullptr;
|
|
|
|
if (ChrStr.size() != 1)
|
|
|
|
return nullptr;
|
2016-04-03 09:46:52 +08:00
|
|
|
return emitPutChar(B.getInt32(ChrStr[0]), B, TLI);
|
2016-03-28 23:54:01 +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");
|
2016-04-03 09:46:52 +08:00
|
|
|
return emitPutS(GV, B, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
}
|
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 &&
|
2016-04-03 09:46:52 +08:00
|
|
|
CI->getArgOperand(1)->getType()->isIntegerTy())
|
|
|
|
return emitPutChar(CI->getArgOperand(1), B, TLI);
|
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 &&
|
2016-04-03 09:46:52 +08:00
|
|
|
CI->getArgOperand(1)->getType()->isPointerTy())
|
2016-01-20 03:46:10 +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();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
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.
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
if (TLI->has(LibFunc_iprintf) && !callHasFloatingPointArgument(CI)) {
|
2014-09-18 04:55:46 +08:00
|
|
|
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),
|
2015-11-19 13:56:52 +08:00
|
|
|
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");
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *Ptr = castToCStr(CI->getArgOperand(0), B);
|
2014-09-18 04:55:46 +08:00
|
|
|
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
|
|
|
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *Len = emitStrLen(CI->getArgOperand(2), B, DL, TLI);
|
2014-09-18 04:55:46 +08:00
|
|
|
if (!Len)
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2016-04-27 05:04:47 +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();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
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.
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
if (TLI->has(LibFunc_siprintf) && !callHasFloatingPointArgument(CI)) {
|
2014-09-18 04:55:46 +08:00
|
|
|
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.
|
|
|
|
|
2016-01-20 03:46:10 +08:00
|
|
|
return emitFWrite(
|
2014-09-18 04:55:46 +08:00
|
|
|
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;
|
2016-01-20 03:46:10 +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;
|
2016-01-20 03:46:10 +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();
|
|
|
|
FunctionType *FT = Callee->getFunctionType();
|
|
|
|
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.
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
if (TLI->has(LibFunc_fiprintf) && !callHasFloatingPointArgument(CI)) {
|
2014-09-18 04:55:46 +08:00
|
|
|
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
|
|
|
// 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)
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *Char = B.CreateLoad(castToCStr(CI->getArgOperand(0), B), "char");
|
|
|
|
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
|
|
|
|
2016-07-07 22:31:19 +08:00
|
|
|
// Don't rewrite fputs to fwrite when optimising for size because fwrite
|
|
|
|
// requires more arguments and thus extra MOVs are required.
|
|
|
|
if (CI->getParent()->getParent()->optForSize())
|
|
|
|
return nullptr;
|
|
|
|
|
2016-04-28 03:04:35 +08:00
|
|
|
// We can't optimize if return value is used.
|
|
|
|
if (!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).
|
2016-01-20 03:46:10 +08:00
|
|
|
return emitFWrite(
|
2014-09-18 04:55:46 +08:00
|
|
|
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) {
|
|
|
|
// Check for a constant string.
|
|
|
|
StringRef Str;
|
|
|
|
if (!getConstantStringInfo(CI->getArgOperand(0), Str))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (Str.empty() && CI->use_empty()) {
|
|
|
|
// puts("") -> putchar('\n')
|
2016-01-20 03:46:10 +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) {
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2013-03-12 08:08:29 +08:00
|
|
|
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) {
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2013-03-12 08:08:29 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
2015-01-13 01:20:06 +08:00
|
|
|
// Check for string/memory library functions.
|
2016-04-28 03:04:35 +08:00
|
|
|
if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) {
|
2015-01-13 01:20:06 +08:00
|
|
|
// Make sure we never change the calling convention.
|
|
|
|
assert((ignoreCallingConv(Func) ||
|
2016-09-13 20:10:14 +08:00
|
|
|
isCallingConvCCompatible(CI)) &&
|
2015-01-13 01:20:06 +08:00
|
|
|
"Optimizing string/memory libcall would change the calling convention");
|
2013-03-12 08:08:29 +08:00
|
|
|
switch (Func) {
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strcat:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrCat(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strncat:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrNCat(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strchr:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrChr(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strrchr:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrRChr(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strcmp:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrCmp(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strncmp:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrNCmp(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strcpy:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrCpy(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_stpcpy:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStpCpy(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strncpy:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrNCpy(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strlen:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrLen(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strpbrk:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrPBrk(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strtol:
|
|
|
|
case LibFunc_strtod:
|
|
|
|
case LibFunc_strtof:
|
|
|
|
case LibFunc_strtoul:
|
|
|
|
case LibFunc_strtoll:
|
|
|
|
case LibFunc_strtold:
|
|
|
|
case LibFunc_strtoull:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrTo(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strspn:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrSpn(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strcspn:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrCSpn(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_strstr:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeStrStr(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_memchr:
|
2015-03-21 23:36:21 +08:00
|
|
|
return optimizeMemChr(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_memcmp:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeMemCmp(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_memcpy:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeMemCpy(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_memmove:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeMemMove(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_memset:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeMemSet(CI, Builder);
|
2017-05-20 06:37:09 +08:00
|
|
|
case LibFunc_wcslen:
|
|
|
|
return optimizeWcslen(CI, Builder);
|
2015-01-13 01:20:06 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2017-08-15 05:15:13 +08:00
|
|
|
Value *LibCallSimplifier::optimizeFloatingPointLibCall(CallInst *CI,
|
|
|
|
LibFunc Func,
|
|
|
|
IRBuilder<> &Builder) {
|
|
|
|
// Don't optimize calls that require strict floating point semantics.
|
|
|
|
if (CI->isStrictFP())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
switch (Func) {
|
|
|
|
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);
|
|
|
|
case LibFunc_fabsf:
|
|
|
|
case LibFunc_fabs:
|
|
|
|
case LibFunc_fabsl:
|
|
|
|
return replaceUnaryCall(CI, Builder, Intrinsic::fabs);
|
|
|
|
case LibFunc_sqrtf:
|
|
|
|
case LibFunc_sqrt:
|
|
|
|
case LibFunc_sqrtl:
|
|
|
|
return optimizeSqrt(CI, Builder);
|
|
|
|
case LibFunc_log:
|
|
|
|
case LibFunc_log10:
|
|
|
|
case LibFunc_log1p:
|
|
|
|
case LibFunc_log2:
|
|
|
|
case LibFunc_logb:
|
|
|
|
return optimizeLog(CI, Builder);
|
|
|
|
case LibFunc_tan:
|
|
|
|
case LibFunc_tanf:
|
|
|
|
case LibFunc_tanl:
|
|
|
|
return optimizeTan(CI, Builder);
|
|
|
|
case LibFunc_ceil:
|
|
|
|
return replaceUnaryCall(CI, Builder, Intrinsic::ceil);
|
|
|
|
case LibFunc_floor:
|
|
|
|
return replaceUnaryCall(CI, Builder, Intrinsic::floor);
|
|
|
|
case LibFunc_round:
|
|
|
|
return replaceUnaryCall(CI, Builder, Intrinsic::round);
|
|
|
|
case LibFunc_nearbyint:
|
|
|
|
return replaceUnaryCall(CI, Builder, Intrinsic::nearbyint);
|
|
|
|
case LibFunc_rint:
|
|
|
|
return replaceUnaryCall(CI, Builder, Intrinsic::rint);
|
|
|
|
case LibFunc_trunc:
|
|
|
|
return replaceUnaryCall(CI, Builder, Intrinsic::trunc);
|
|
|
|
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_sin:
|
|
|
|
case LibFunc_sinh:
|
|
|
|
case LibFunc_tanh:
|
|
|
|
if (UnsafeFPShrink && hasFloatVersion(CI->getCalledFunction()->getName()))
|
|
|
|
return optimizeUnaryDoubleFP(CI, Builder, true);
|
|
|
|
return nullptr;
|
|
|
|
case LibFunc_copysign:
|
|
|
|
if (hasFloatVersion(CI->getCalledFunction()->getName()))
|
|
|
|
return optimizeBinaryDoubleFP(CI, Builder);
|
|
|
|
return nullptr;
|
|
|
|
case LibFunc_fminf:
|
|
|
|
case LibFunc_fmin:
|
|
|
|
case LibFunc_fminl:
|
|
|
|
case LibFunc_fmaxf:
|
|
|
|
case LibFunc_fmax:
|
|
|
|
case LibFunc_fmaxl:
|
|
|
|
return optimizeFMinFMax(CI, Builder);
|
|
|
|
default:
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-13 01:20:06 +08:00
|
|
|
Value *LibCallSimplifier::optimizeCall(CallInst *CI) {
|
2017-08-15 05:15:13 +08:00
|
|
|
// TODO: Split out the code below that operates on FP calls so that
|
|
|
|
// we can all non-FP calls with the StrictFP attribute to be
|
|
|
|
// optimized.
|
2015-01-13 01:20:06 +08:00
|
|
|
if (CI->isNoBuiltin())
|
|
|
|
return nullptr;
|
|
|
|
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2015-01-13 01:20:06 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
2016-01-06 13:01:34 +08:00
|
|
|
|
|
|
|
SmallVector<OperandBundleDef, 2> OpBundles;
|
|
|
|
CI->getOperandBundlesAsDefs(OpBundles);
|
|
|
|
IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles);
|
2016-09-13 20:10:14 +08:00
|
|
|
bool isCallingConvC = isCallingConvCCompatible(CI);
|
2015-01-13 01:20:06 +08:00
|
|
|
|
2016-01-20 02:38:52 +08:00
|
|
|
// Command-line parameter overrides instruction attribute.
|
2017-08-15 05:15:13 +08:00
|
|
|
// This can't be moved to optimizeFloatingPointLibCall() because it may be
|
|
|
|
// used by the intrinsic optimizations.
|
2015-01-13 01:20:06 +08:00
|
|
|
if (EnableUnsafeFPShrink.getNumOccurrences() > 0)
|
|
|
|
UnsafeFPShrink = EnableUnsafeFPShrink;
|
2016-01-20 02:38:52 +08:00
|
|
|
else if (isa<FPMathOperator>(CI) && CI->hasUnsafeAlgebra())
|
2015-10-29 10:58:44 +08:00
|
|
|
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;
|
2017-08-15 05:15:13 +08:00
|
|
|
// The FP intrinsics have corresponding constrained versions so we don't
|
|
|
|
// need to check for the StrictFP attribute here.
|
2015-01-13 01:20:06 +08:00
|
|
|
switch (II->getIntrinsicID()) {
|
|
|
|
case Intrinsic::pow:
|
|
|
|
return optimizePow(CI, Builder);
|
|
|
|
case Intrinsic::exp2:
|
|
|
|
return optimizeExp2(CI, Builder);
|
2015-11-30 04:58:04 +08:00
|
|
|
case Intrinsic::log:
|
|
|
|
return optimizeLog(CI, Builder);
|
2015-01-13 01:20:06 +08:00
|
|
|
case Intrinsic::sqrt:
|
|
|
|
return optimizeSqrt(CI, Builder);
|
2016-01-27 00:17:24 +08:00
|
|
|
// TODO: Use foldMallocMemset() with memset intrinsic.
|
2015-01-13 01:20:06 +08:00
|
|
|
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.
|
2016-04-28 03:04:35 +08:00
|
|
|
if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) {
|
2015-01-13 01:20:06 +08:00
|
|
|
// We never change the calling convention.
|
|
|
|
if (!ignoreCallingConv(Func) && !isCallingConvC)
|
|
|
|
return nullptr;
|
|
|
|
if (Value *V = optimizeStringMemoryLibCall(CI, Builder))
|
|
|
|
return V;
|
2017-08-15 05:15:13 +08:00
|
|
|
if (Value *V = optimizeFloatingPointLibCall(CI, Func, Builder))
|
|
|
|
return V;
|
2015-01-13 01:20:06 +08:00
|
|
|
switch (Func) {
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_ffs:
|
|
|
|
case LibFunc_ffsl:
|
|
|
|
case LibFunc_ffsll:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeFFS(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_fls:
|
|
|
|
case LibFunc_flsl:
|
|
|
|
case LibFunc_flsll:
|
2016-12-16 07:45:11 +08:00
|
|
|
return optimizeFls(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_abs:
|
|
|
|
case LibFunc_labs:
|
|
|
|
case LibFunc_llabs:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeAbs(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_isdigit:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeIsDigit(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_isascii:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeIsAscii(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_toascii:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeToAscii(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_printf:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizePrintF(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_sprintf:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeSPrintF(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_fprintf:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeFPrintF(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_fwrite:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeFWrite(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_fputs:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeFPuts(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_puts:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizePuts(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_perror:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeErrorReporting(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_vfprintf:
|
|
|
|
case LibFunc_fiprintf:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeErrorReporting(CI, Builder, 0);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_fputc:
|
2014-09-18 04:55:46 +08:00
|
|
|
return optimizeErrorReporting(CI, Builder, 1);
|
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,
|
2017-07-27 03:03:18 +08:00
|
|
|
OptimizationRemarkEmitter &ORE,
|
2015-01-21 10:11:59 +08:00
|
|
|
function_ref<void(Instruction *, Value *)> Replacer)
|
2017-07-27 03:03:18 +08:00
|
|
|
: FortifiedSimplifier(TLI), DL(DL), TLI(TLI), ORE(ORE),
|
|
|
|
UnsafeFPShrink(false), Replacer(Replacer) {}
|
2015-01-21 10:11:59 +08:00
|
|
|
|
|
|
|
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(exp(y)) -> y*log(e)
|
|
|
|
// * log(exp10(y)) -> y*log(10)
|
|
|
|
// * log(sqrt(x)) -> 0.5*log(x)
|
|
|
|
//
|
|
|
|
// pow, powf, powl:
|
|
|
|
// * pow(sqrt(x),y) -> pow(x,y*0.5)
|
|
|
|
// * pow(pow(x,y),z)-> pow(x,y*z)
|
|
|
|
//
|
|
|
|
// 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)
|
|
|
|
//
|
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))) {
|
2017-07-07 02:39:47 +08:00
|
|
|
if (ObjSizeCI->isMinusOne())
|
2015-01-13 01:22:43 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-01-01 00:10:49 +08:00
|
|
|
Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI,
|
|
|
|
IRBuilder<> &B) {
|
2015-01-13 01:22:43 +08:00
|
|
|
if (isFortifiedCallFoldable(CI, 3, 2, false)) {
|
|
|
|
B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
|
2015-11-19 13:56:52 +08:00
|
|
|
CI->getArgOperand(2), 1);
|
2015-01-13 01:22:43 +08:00
|
|
|
return CI->getArgOperand(0);
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-01-01 00:10:49 +08:00
|
|
|
Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI,
|
|
|
|
IRBuilder<> &B) {
|
2015-01-13 01:22:43 +08:00
|
|
|
if (isFortifiedCallFoldable(CI, 3, 2, false)) {
|
|
|
|
B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
|
2015-11-19 13:56:52 +08:00
|
|
|
CI->getArgOperand(2), 1);
|
2015-01-13 01:22:43 +08:00
|
|
|
return CI->getArgOperand(0);
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-01-01 00:10:49 +08:00
|
|
|
Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI,
|
|
|
|
IRBuilder<> &B) {
|
2016-01-27 00:17:24 +08:00
|
|
|
// TODO: Try foldMallocMemset() here.
|
|
|
|
|
2015-01-13 01:22:43 +08:00
|
|
|
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,
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc 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
|
|
|
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1),
|
|
|
|
*ObjSize = CI->getArgOperand(2);
|
|
|
|
|
|
|
|
// __stpcpy_chk(x,x,...) -> x+strlen(x)
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
if (Func == LibFunc_stpcpy_chk && !OnlyLowerUnknownSize && Dst == Src) {
|
2016-01-20 03:46:10 +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))
|
2016-01-20 03:46:10 +08:00
|
|
|
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);
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *Ret = emitMemCpyChk(Dst, Src, LenV, ObjSize, B, DL, TLI);
|
2015-04-04 05:32:06 +08:00
|
|
|
// 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.
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
if (Ret && Func == LibFunc_stpcpy_chk)
|
2015-04-04 05:32:06 +08:00
|
|
|
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,
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func) {
|
2015-01-13 01:22:43 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
StringRef Name = Callee->getName();
|
|
|
|
if (isFortifiedCallFoldable(CI, 3, 2, false)) {
|
2016-01-20 03:46:10 +08:00
|
|
|
Value *Ret = emitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
|
2015-03-10 10:37:25 +08:00
|
|
|
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
|
|
|
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
LibFunc Func;
|
2015-01-13 01:22:43 +08:00
|
|
|
Function *Callee = CI->getCalledFunction();
|
2016-01-06 13:01:34 +08:00
|
|
|
|
|
|
|
SmallVector<OperandBundleDef, 2> OpBundles;
|
|
|
|
CI->getOperandBundlesAsDefs(OpBundles);
|
|
|
|
IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles);
|
2016-09-13 20:10:14 +08:00
|
|
|
bool isCallingConvC = isCallingConvCCompatible(CI);
|
2015-01-13 01:22:43 +08:00
|
|
|
|
2016-04-28 03:04:35 +08:00
|
|
|
// First, check that this is a known library functions and that the prototype
|
|
|
|
// is correct.
|
|
|
|
if (!TLI->getLibFunc(*Callee, 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) {
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_memcpy_chk:
|
2015-01-13 01:22:43 +08:00
|
|
|
return optimizeMemCpyChk(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_memmove_chk:
|
2015-01-13 01:22:43 +08:00
|
|
|
return optimizeMemMoveChk(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
case LibFunc_memset_chk:
|
2015-01-13 01:22:43 +08:00
|
|
|
return optimizeMemSetChk(CI, Builder);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +08:00
|
|
|
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);
|
[Analysis] Add LibFunc_ prefix to enums in TargetLibraryInfo. (NFC)
Summary:
The LibFunc::Func enum holds enumerators named for libc functions.
Unfortunately, there are real situations, including libc implementations, where
function names are actually macros (musl uses "#define fopen64 fopen", for
example; any other transitively visible macro would have similar effects).
Strictly speaking, a conforming C++ Standard Library should provide any such
macros as functions instead (via <cstdio>). However, there are some "library"
functions which are not part of the standard, and thus not subject to this
rule (fopen64, for example). So, in order to be both portable and consistent,
the enum should not use the bare function names.
The old enum naming used a namespace LibFunc and an enum Func, with bare
enumerators. This patch changes LibFunc to be an enum with enumerators prefixed
with "LibFFunc_". (Unfortunately, a scoped enum is not sufficient to override
macros.)
There are additional changes required in clang.
Reviewers: rsmith
Subscribers: mehdi_amini, mzolotukhin, nemanjai, llvm-commits
Differential Revision: https://reviews.llvm.org/D28476
llvm-svn: 292848
2017-01-24 07:16:46 +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) {}
|