2008-05-01 06:25:24 +00:00
|
|
|
//===- SimplifyLibCalls.cpp - Optimize specific well-known library calls --===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements a simple pass that applies a variety of small
|
|
|
|
// optimizations for calls to specific well-known function calls (e.g. runtime
|
2009-09-03 05:19:59 +00:00
|
|
|
// library functions). Any optimization that takes the very simple form
|
|
|
|
// "replace call to library function with simpler code that provides the same
|
|
|
|
// result" belongs in this file.
|
2008-05-01 06:25:24 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#define DEBUG_TYPE "simplify-libcalls"
|
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2010-03-05 22:25:30 +00:00
|
|
|
#include "llvm/Transforms/Utils/BuildLibCalls.h"
|
2008-05-01 06:25:24 +00:00
|
|
|
#include "llvm/Intrinsics.h"
|
2009-07-03 19:42:02 +00:00
|
|
|
#include "llvm/LLVMContext.h"
|
2008-05-01 06:25:24 +00:00
|
|
|
#include "llvm/Module.h"
|
|
|
|
#include "llvm/Pass.h"
|
|
|
|
#include "llvm/Support/IRBuilder.h"
|
2008-06-30 07:31:25 +00:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2008-05-01 06:25:24 +00:00
|
|
|
#include "llvm/Target/TargetData.h"
|
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
|
|
#include "llvm/ADT/StringMap.h"
|
|
|
|
#include "llvm/ADT/Statistic.h"
|
2009-07-29 22:00:43 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2008-05-01 06:39:12 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-26 08:34:35 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2008-05-01 06:25:24 +00:00
|
|
|
#include "llvm/Config/config.h"
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
STATISTIC(NumSimplified, "Number of library calls simplified");
|
2009-01-04 20:27:34 +00:00
|
|
|
STATISTIC(NumAnnotated, "Number of attributes added to library functions");
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Optimizer Base Class
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// This class is the abstract base class for the set of optimizations that
|
|
|
|
/// corresponds to one library call.
|
|
|
|
namespace {
|
2009-09-02 06:11:42 +00:00
|
|
|
class LibCallOptimization {
|
2008-05-01 06:25:24 +00:00
|
|
|
protected:
|
|
|
|
Function *Caller;
|
|
|
|
const TargetData *TD;
|
2009-07-03 19:42:02 +00:00
|
|
|
LLVMContext* Context;
|
2008-05-01 06:25:24 +00:00
|
|
|
public:
|
2010-03-24 20:19:04 +00:00
|
|
|
LibCallOptimization() { }
|
2008-05-01 06:25:24 +00:00
|
|
|
virtual ~LibCallOptimization() {}
|
|
|
|
|
|
|
|
/// CallOptimizer - This pure virtual method is implemented by base classes to
|
|
|
|
/// do various optimizations. If this returns null then no transformation was
|
|
|
|
/// performed. If it returns CI, then it transformed the call and CI is to be
|
|
|
|
/// deleted. If it returns something else, replace CI with the new value and
|
|
|
|
/// delete CI.
|
2009-10-07 21:14:25 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B)
|
2008-08-08 19:39:37 +00:00
|
|
|
=0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-08-18 00:48:13 +00:00
|
|
|
Value *OptimizeCall(CallInst *CI, const TargetData *TD, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
Caller = CI->getParent()->getParent();
|
2009-08-18 00:48:13 +00:00
|
|
|
this->TD = TD;
|
2009-07-03 19:42:02 +00:00
|
|
|
if (CI->getCalledFunction())
|
2009-07-22 00:24:57 +00:00
|
|
|
Context = &CI->getCalledFunction()->getContext();
|
2010-06-16 19:34:01 +00:00
|
|
|
|
|
|
|
// We never change the calling convention.
|
|
|
|
if (CI->getCallingConv() != llvm::CallingConv::C)
|
|
|
|
return NULL;
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
return CallOptimizer(CI->getCalledFunction(), CI, B);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // End anonymous namespace.
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Helper Functions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// IsOnlyUsedInZeroEqualityComparison - Return true if it only matters that the
|
2009-10-07 21:14:25 +00:00
|
|
|
/// value is equal or not-equal to zero.
|
2008-05-01 06:25:24 +00:00
|
|
|
static bool IsOnlyUsedInZeroEqualityComparison(Value *V) {
|
|
|
|
for (Value::use_iterator UI = V->use_begin(), E = V->use_end();
|
|
|
|
UI != E; ++UI) {
|
|
|
|
if (ICmpInst *IC = dyn_cast<ICmpInst>(*UI))
|
|
|
|
if (IC->isEquality())
|
|
|
|
if (Constant *C = dyn_cast<Constant>(IC->getOperand(1)))
|
|
|
|
if (C->isNullValue())
|
|
|
|
continue;
|
|
|
|
// Unknown instruction.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-06-15 21:34:25 +00:00
|
|
|
/// IsOnlyUsedInEqualityComparison - Return true if it is only used in equality
|
|
|
|
/// comparisons with With.
|
|
|
|
static bool IsOnlyUsedInEqualityComparison(Value *V, Value *With) {
|
|
|
|
for (Value::use_iterator UI = V->use_begin(), E = V->use_end();
|
|
|
|
UI != E; ++UI) {
|
|
|
|
if (ICmpInst *IC = dyn_cast<ICmpInst>(*UI))
|
|
|
|
if (IC->isEquality() && IC->getOperand(1) == With)
|
|
|
|
continue;
|
|
|
|
// Unknown instruction.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// String and Memory LibCall Optimizations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strcat' Optimizations
|
2009-09-03 05:19:59 +00:00
|
|
|
namespace {
|
2009-09-02 06:11:42 +00:00
|
|
|
struct StrCatOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// Verify the "strcat" function prototype.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 ||
|
2009-10-06 15:40:36 +00:00
|
|
|
FT->getReturnType() != Type::getInt8PtrTy(*Context) ||
|
2008-05-01 06:25:24 +00:00
|
|
|
FT->getParamType(0) != FT->getReturnType() ||
|
|
|
|
FT->getParamType(1) != FT->getReturnType())
|
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Extract some information from the instruction
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Dst = CI->getArgOperand(0);
|
|
|
|
Value *Src = CI->getArgOperand(1);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// See if we can get the length of the input string.
|
|
|
|
uint64_t Len = GetStringLength(Src);
|
2008-05-01 06:39:12 +00:00
|
|
|
if (Len == 0) return 0;
|
2008-05-01 06:25:24 +00:00
|
|
|
--Len; // Unbias length.
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Handle the simple, do-nothing case: strcat(x, "") -> x
|
|
|
|
if (Len == 0)
|
|
|
|
return Dst;
|
2009-08-18 00:48:13 +00:00
|
|
|
|
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2009-04-12 05:06:39 +00:00
|
|
|
EmitStrLenMemCpy(Src, Dst, Len, B);
|
|
|
|
return Dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
void EmitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// 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.
|
2010-03-05 22:25:30 +00:00
|
|
|
Value *DstLen = EmitStrLen(Dst, B, TD);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00: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).
|
2009-04-06 13:06:48 +00:00
|
|
|
Value *CpyDst = B.CreateGEP(Dst, DstLen, "endptr");
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00: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.
|
2009-07-03 19:42:02 +00:00
|
|
|
EmitMemCpy(CpyDst, Src,
|
Reapply address space patch after fixing an issue in MemCopyOptimizer.
Added support for address spaces and added a isVolatile field to memcpy, memmove, and memset,
e.g., llvm.memcpy.i32(i8*, i8*, i32, i32) -> llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100304 91177308-0d34-0410-b5e6-96231b3b80d8
2010-04-04 03:10:48 +00:00
|
|
|
ConstantInt::get(TD->getIntPtrType(*Context), Len+1),
|
|
|
|
1, false, B, TD);
|
2009-04-12 05:06:39 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strncat' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct StrNCatOpt : public StrCatOpt {
|
2009-04-12 05:06:39 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// Verify the "strncat" function prototype.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 3 ||
|
2009-10-06 15:40:36 +00:00
|
|
|
FT->getReturnType() != Type::getInt8PtrTy(*Context) ||
|
2009-04-12 05:06:39 +00:00
|
|
|
FT->getParamType(0) != FT->getReturnType() ||
|
|
|
|
FT->getParamType(1) != FT->getReturnType() ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getParamType(2)->isIntegerTy())
|
2009-04-12 05:06:39 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Extract some information from the instruction
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Dst = CI->getArgOperand(0);
|
|
|
|
Value *Src = CI->getArgOperand(1);
|
2009-04-12 05:06:39 +00:00
|
|
|
uint64_t Len;
|
|
|
|
|
|
|
|
// We don't do anything if length is not constant
|
2010-06-24 10:42:46 +00:00
|
|
|
if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(CI->getArgOperand(2)))
|
2009-04-12 05:06:39 +00:00
|
|
|
Len = LengthArg->getZExtValue();
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// See if we can get the length of the input string.
|
|
|
|
uint64_t SrcLen = GetStringLength(Src);
|
|
|
|
if (SrcLen == 0) return 0;
|
|
|
|
--SrcLen; // Unbias length.
|
|
|
|
|
|
|
|
// Handle the simple, do-nothing cases:
|
|
|
|
// strncat(x, "", c) -> x
|
|
|
|
// strncat(x, c, 0) -> x
|
|
|
|
if (SrcLen == 0 || Len == 0) return Dst;
|
|
|
|
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2009-04-12 05:06:39 +00:00
|
|
|
// We don't optimize this case
|
|
|
|
if (Len < SrcLen) return 0;
|
|
|
|
|
|
|
|
// strncat(x, s, c) -> strcat(x, s)
|
|
|
|
// s is constant so the strcat can be optimized further
|
2009-04-12 18:22:33 +00:00
|
|
|
EmitStrLenMemCpy(Src, Dst, SrcLen, B);
|
2008-05-01 06:25:24 +00:00
|
|
|
return Dst;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strchr' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct StrChrOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// Verify the "strchr" function prototype.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 ||
|
2009-10-06 15:40:36 +00:00
|
|
|
FT->getReturnType() != Type::getInt8PtrTy(*Context) ||
|
2010-09-30 11:21:59 +00:00
|
|
|
FT->getParamType(0) != FT->getReturnType() ||
|
|
|
|
!FT->getParamType(1)->isIntegerTy(32))
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *SrcStr = CI->getArgOperand(0);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// If the second operand is non-constant, see if we can compute the length
|
|
|
|
// of the input string and turn this into memchr.
|
2010-06-24 10:42:46 +00:00
|
|
|
ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
|
2008-05-01 06:25:24 +00:00
|
|
|
if (CharC == 0) {
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
uint64_t Len = GetStringLength(SrcStr);
|
2010-02-15 16:12:20 +00:00
|
|
|
if (Len == 0 || !FT->getParamType(1)->isIntegerTy(32))// memchr needs i32.
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
return EmitMemChr(SrcStr, CI->getArgOperand(1), // include nul.
|
2010-03-05 22:25:30 +00:00
|
|
|
ConstantInt::get(TD->getIntPtrType(*Context), Len),
|
|
|
|
B, TD);
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, the character is a constant, see if the first argument is
|
|
|
|
// a string literal. If so, we can constant fold.
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Str;
|
|
|
|
if (!GetConstantStringInfo(SrcStr, Str))
|
2008-05-01 06:39:12 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// strchr can find the nul character.
|
|
|
|
Str += '\0';
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Compute the offset.
|
2010-09-29 22:29:12 +00:00
|
|
|
size_t I = Str.find(CharC->getSExtValue());
|
|
|
|
if (I == std::string::npos) // Didn't find the char. strchr returns null.
|
|
|
|
return Constant::getNullValue(CI->getType());
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// strchr(s+n,c) -> gep(s+n+i,c)
|
2010-09-29 22:29:12 +00:00
|
|
|
Value *Idx = ConstantInt::get(Type::getInt64Ty(*Context), I);
|
2008-05-01 06:25:24 +00:00
|
|
|
return B.CreateGEP(SrcStr, Idx, "strchr");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-09-29 21:50:51 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strrchr' Optimizations
|
|
|
|
|
|
|
|
struct StrRChrOpt : public LibCallOptimization {
|
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// Verify the "strrchr" function prototype.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 ||
|
|
|
|
FT->getReturnType() != Type::getInt8PtrTy(*Context) ||
|
2010-09-30 11:21:59 +00:00
|
|
|
FT->getParamType(0) != FT->getReturnType() ||
|
|
|
|
!FT->getParamType(1)->isIntegerTy(32))
|
2010-09-29 21:50:51 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
Value *SrcStr = CI->getArgOperand(0);
|
|
|
|
ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
|
|
|
|
|
|
|
|
// Cannot fold anything if we're not looking for a constant.
|
|
|
|
if (!CharC)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
std::string Str;
|
|
|
|
if (!GetConstantStringInfo(SrcStr, Str)) {
|
|
|
|
// strrchr(s, 0) -> strchr(s, 0)
|
|
|
|
if (TD && CharC->isZero())
|
|
|
|
return EmitStrChr(SrcStr, '\0', B, TD);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// strrchr can find the nul character.
|
|
|
|
Str += '\0';
|
|
|
|
|
|
|
|
// Compute the offset.
|
|
|
|
size_t I = Str.rfind(CharC->getSExtValue());
|
|
|
|
if (I == std::string::npos) // Didn't find the char. Return null.
|
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
|
|
|
// strrchr(s+n,c) -> gep(s+n+i,c)
|
|
|
|
Value *Idx = ConstantInt::get(Type::getInt64Ty(*Context), I);
|
|
|
|
return B.CreateGEP(SrcStr, Idx, "strrchr");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strcmp' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct StrCmpOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// Verify the "strcmp" function prototype.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2009-10-07 21:14:25 +00:00
|
|
|
if (FT->getNumParams() != 2 ||
|
2010-07-06 03:53:43 +00:00
|
|
|
!FT->getReturnType()->isIntegerTy(32) ||
|
2008-05-01 06:25:24 +00:00
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
2009-10-06 15:40:36 +00:00
|
|
|
FT->getParamType(0) != Type::getInt8PtrTy(*Context))
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Str1P == Str2P) // strcmp(x,x) -> 0
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), 0);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Str1, Str2;
|
|
|
|
bool HasStr1 = GetConstantStringInfo(Str1P, Str1);
|
|
|
|
bool HasStr2 = GetConstantStringInfo(Str2P, Str2);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-03-13 04:39:26 +00:00
|
|
|
if (HasStr1 && Str1.empty()) // strcmp("", x) -> *x
|
2008-05-01 06:25:24 +00:00
|
|
|
return B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"), CI->getType());
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-03-13 04:39:26 +00:00
|
|
|
if (HasStr2 && Str2.empty()) // strcmp(x,"") -> *x
|
2008-05-01 06:25:24 +00:00
|
|
|
return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType());
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// strcmp(x, y) -> cnst (if both x and y are constant strings)
|
2009-03-13 04:39:26 +00:00
|
|
|
if (HasStr1 && HasStr2)
|
2009-10-07 21:14:25 +00:00
|
|
|
return ConstantInt::get(CI->getType(),
|
2009-07-03 19:42:02 +00:00
|
|
|
strcmp(Str1.c_str(),Str2.c_str()));
|
2008-12-21 00:19:21 +00:00
|
|
|
|
|
|
|
// strcmp(P, "x") -> memcmp(P, "x", 2)
|
|
|
|
uint64_t Len1 = GetStringLength(Str1P);
|
|
|
|
uint64_t Len2 = GetStringLength(Str2P);
|
2009-06-19 04:17:36 +00:00
|
|
|
if (Len1 && Len2) {
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2008-12-21 00:19:21 +00:00
|
|
|
return EmitMemCmp(Str1P, Str2P,
|
2009-08-13 21:58:54 +00:00
|
|
|
ConstantInt::get(TD->getIntPtrType(*Context),
|
2010-03-05 22:25:30 +00:00
|
|
|
std::min(Len1, Len2)), B, TD);
|
2008-12-21 00:19:21 +00:00
|
|
|
}
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strncmp' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct StrNCmpOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// Verify the "strncmp" function prototype.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2009-10-07 21:14:25 +00:00
|
|
|
if (FT->getNumParams() != 3 ||
|
2010-07-06 03:53:43 +00:00
|
|
|
!FT->getReturnType()->isIntegerTy(32) ||
|
2008-05-01 06:25:24 +00:00
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
2009-10-06 15:40:36 +00:00
|
|
|
FT->getParamType(0) != Type::getInt8PtrTy(*Context) ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getParamType(2)->isIntegerTy())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Str1P = CI->getArgOperand(0), *Str2P = CI->getArgOperand(1);
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Str1P == Str2P) // strncmp(x,x,n) -> 0
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), 0);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Get the length argument if it is constant.
|
|
|
|
uint64_t Length;
|
2010-06-24 10:42:46 +00:00
|
|
|
if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(CI->getArgOperand(2)))
|
2008-05-01 06:25:24 +00:00
|
|
|
Length = LengthArg->getZExtValue();
|
|
|
|
else
|
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Length == 0) // strncmp(x,y,0) -> 0
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), 0);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-16 10:30:29 +00:00
|
|
|
if (TD && Length == 1) // strncmp(x,y,1) -> memcmp(x,y,1)
|
2010-06-30 12:42:43 +00:00
|
|
|
return EmitMemCmp(Str1P, Str2P, CI->getArgOperand(2), B, TD);
|
2010-06-16 10:30:29 +00:00
|
|
|
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Str1, Str2;
|
|
|
|
bool HasStr1 = GetConstantStringInfo(Str1P, Str1);
|
|
|
|
bool HasStr2 = GetConstantStringInfo(Str2P, Str2);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-03-13 04:39:26 +00:00
|
|
|
if (HasStr1 && Str1.empty()) // strncmp("", x, n) -> *x
|
2008-05-01 06:25:24 +00:00
|
|
|
return B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"), CI->getType());
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-03-13 04:39:26 +00:00
|
|
|
if (HasStr2 && Str2.empty()) // strncmp(x, "", n) -> *x
|
2008-05-01 06:25:24 +00:00
|
|
|
return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType());
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// strncmp(x, y) -> cnst (if both x and y are constant strings)
|
2009-03-13 04:39:26 +00:00
|
|
|
if (HasStr1 && HasStr2)
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(),
|
2009-03-13 04:39:26 +00:00
|
|
|
strncmp(Str1.c_str(), Str2.c_str(), Length));
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strcpy' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct StrCpyOpt : public LibCallOptimization {
|
2010-03-24 20:19:04 +00:00
|
|
|
bool OptChkCall; // True if it's optimizing a __strcpy_chk libcall.
|
|
|
|
|
|
|
|
StrCpyOpt(bool c) : OptChkCall(c) {}
|
|
|
|
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// Verify the "strcpy" function prototype.
|
2010-03-23 15:48:04 +00:00
|
|
|
unsigned NumParams = OptChkCall ? 3 : 2;
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2010-03-23 15:48:04 +00:00
|
|
|
if (FT->getNumParams() != NumParams ||
|
|
|
|
FT->getReturnType() != FT->getParamType(0) ||
|
2008-05-01 06:25:24 +00:00
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
2009-10-06 15:40:36 +00:00
|
|
|
FT->getParamType(0) != Type::getInt8PtrTy(*Context))
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Dst == Src) // strcpy(x,x) -> x
|
|
|
|
return Src;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// See if we can get the length of the input string.
|
|
|
|
uint64_t Len = GetStringLength(Src);
|
2008-05-01 06:39:12 +00:00
|
|
|
if (Len == 0) return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00: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.
|
2010-03-23 15:48:04 +00:00
|
|
|
if (OptChkCall)
|
|
|
|
EmitMemCpyChk(Dst, Src,
|
|
|
|
ConstantInt::get(TD->getIntPtrType(*Context), Len),
|
2010-06-24 10:42:46 +00:00
|
|
|
CI->getArgOperand(2), B, TD);
|
2010-03-23 15:48:04 +00:00
|
|
|
else
|
|
|
|
EmitMemCpy(Dst, Src,
|
Reapply address space patch after fixing an issue in MemCopyOptimizer.
Added support for address spaces and added a isVolatile field to memcpy, memmove, and memset,
e.g., llvm.memcpy.i32(i8*, i8*, i32, i32) -> llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100304 91177308-0d34-0410-b5e6-96231b3b80d8
2010-04-04 03:10:48 +00:00
|
|
|
ConstantInt::get(TD->getIntPtrType(*Context), Len),
|
|
|
|
1, false, B, TD);
|
2008-05-01 06:25:24 +00:00
|
|
|
return Dst;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-04-12 05:06:39 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strncpy' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct StrNCpyOpt : public LibCallOptimization {
|
2009-04-12 05:06:39 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
|
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
2009-10-06 15:40:36 +00:00
|
|
|
FT->getParamType(0) != Type::getInt8PtrTy(*Context) ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getParamType(2)->isIntegerTy())
|
2009-04-12 05:06:39 +00:00
|
|
|
return 0;
|
2008-05-01 06:25:24 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Dst = CI->getArgOperand(0);
|
|
|
|
Value *Src = CI->getArgOperand(1);
|
|
|
|
Value *LenOp = CI->getArgOperand(2);
|
2009-04-12 05:06:39 +00:00
|
|
|
|
|
|
|
// See if we can get the length of the input string.
|
|
|
|
uint64_t SrcLen = GetStringLength(Src);
|
|
|
|
if (SrcLen == 0) return 0;
|
|
|
|
--SrcLen;
|
|
|
|
|
|
|
|
if (SrcLen == 0) {
|
|
|
|
// strncpy(x, "", y) -> memset(x, '\0', y, 1)
|
Reapply address space patch after fixing an issue in MemCopyOptimizer.
Added support for address spaces and added a isVolatile field to memcpy, memmove, and memset,
e.g., llvm.memcpy.i32(i8*, i8*, i32, i32) -> llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100304 91177308-0d34-0410-b5e6-96231b3b80d8
2010-04-04 03:10:48 +00:00
|
|
|
EmitMemSet(Dst, ConstantInt::get(Type::getInt8Ty(*Context), '\0'),
|
|
|
|
LenOp, false, B, TD);
|
2009-04-12 05:06:39 +00:00
|
|
|
return Dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t Len;
|
|
|
|
if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(LenOp))
|
|
|
|
Len = LengthArg->getZExtValue();
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (Len == 0) return Dst; // strncpy(x, y, 0) -> x
|
|
|
|
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2009-04-12 05:06:39 +00:00
|
|
|
// Let strncpy handle the zero padding
|
|
|
|
if (Len > SrcLen+1) return 0;
|
|
|
|
|
|
|
|
// strncpy(x, s, c) -> memcpy(x, s, c, 1) [s and c are constant]
|
2009-07-03 19:42:02 +00:00
|
|
|
EmitMemCpy(Dst, Src,
|
Reapply address space patch after fixing an issue in MemCopyOptimizer.
Added support for address spaces and added a isVolatile field to memcpy, memmove, and memset,
e.g., llvm.memcpy.i32(i8*, i8*, i32, i32) -> llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100304 91177308-0d34-0410-b5e6-96231b3b80d8
2010-04-04 03:10:48 +00:00
|
|
|
ConstantInt::get(TD->getIntPtrType(*Context), Len),
|
|
|
|
1, false, B, TD);
|
2009-04-12 05:06:39 +00:00
|
|
|
|
|
|
|
return Dst;
|
|
|
|
}
|
|
|
|
};
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strlen' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct StrLenOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 1 ||
|
2009-10-06 15:40:36 +00:00
|
|
|
FT->getParamType(0) != Type::getInt8PtrTy(*Context) ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getReturnType()->isIntegerTy())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Src = CI->getArgOperand(0);
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
// Constant folding: strlen("xyz") -> 3
|
|
|
|
if (uint64_t Len = GetStringLength(Src))
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), Len-1);
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
// strlen(x) != 0 --> *x != 0
|
|
|
|
// strlen(x) == 0 --> *x == 0
|
2009-12-23 23:24:51 +00:00
|
|
|
if (IsOnlyUsedInZeroEqualityComparison(CI))
|
|
|
|
return B.CreateZExt(B.CreateLoad(Src, "strlenfirst"), CI->getType());
|
|
|
|
return 0;
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-09-29 23:52:12 +00:00
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strpbrk' Optimizations
|
|
|
|
|
|
|
|
struct StrPBrkOpt : public LibCallOptimization {
|
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 ||
|
|
|
|
FT->getParamType(0) != Type::getInt8PtrTy(*Context) ||
|
|
|
|
FT->getParamType(1) != FT->getParamType(0) ||
|
|
|
|
FT->getReturnType() != FT->getParamType(0))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
std::string S1, S2;
|
|
|
|
bool HasS1 = GetConstantStringInfo(CI->getArgOperand(0), S1);
|
|
|
|
bool HasS2 = GetConstantStringInfo(CI->getArgOperand(1), S2);
|
|
|
|
|
|
|
|
// strpbrk(s, "") -> NULL
|
|
|
|
// strpbrk("", s) -> NULL
|
|
|
|
if ((HasS1 && S1.empty()) || (HasS2 && S2.empty()))
|
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
|
|
|
// Constant folding.
|
|
|
|
if (HasS1 && HasS2) {
|
|
|
|
size_t I = S1.find_first_of(S2);
|
|
|
|
if (I == std::string::npos) // No match.
|
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
|
|
|
Value *Idx = ConstantInt::get(Type::getInt64Ty(*Context), I);
|
|
|
|
return B.CreateGEP(CI->getArgOperand(0), Idx, "strpbrk");
|
|
|
|
}
|
|
|
|
|
|
|
|
// strpbrk(s, "a") -> strchr(s, 'a')
|
|
|
|
if (TD && HasS2 && S2.size() == 1)
|
|
|
|
return EmitStrChr(CI->getArgOperand(0), S2[0], B, TD);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-02-13 15:31:46 +00:00
|
|
|
//===---------------------------------------===//
|
2009-12-16 09:32:05 +00:00
|
|
|
// 'strto*' Optimizations. This handles strtol, strtod, strtof, strtoul, etc.
|
2009-02-13 15:31:46 +00:00
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct StrToOpt : public LibCallOptimization {
|
2009-02-13 15:31:46 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if ((FT->getNumParams() != 2 && FT->getNumParams() != 3) ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy())
|
2009-02-13 15:31:46 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *EndPtr = CI->getArgOperand(1);
|
2009-02-13 17:08:33 +00:00
|
|
|
if (isa<ConstantPointerNull>(EndPtr)) {
|
2010-12-17 01:09:43 +00:00
|
|
|
// 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.
|
2009-02-13 15:31:46 +00:00
|
|
|
CI->addAttribute(1, Attribute::NoCapture);
|
2009-02-13 17:08:33 +00:00
|
|
|
}
|
2009-02-13 15:31:46 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-09-30 00:58:35 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strspn' Optimizations
|
|
|
|
|
|
|
|
struct StrSpnOpt : public LibCallOptimization {
|
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 ||
|
|
|
|
FT->getParamType(0) != Type::getInt8PtrTy(*Context) ||
|
|
|
|
FT->getParamType(1) != FT->getParamType(0) ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
std::string S1, S2;
|
|
|
|
bool HasS1 = GetConstantStringInfo(CI->getArgOperand(0), S1);
|
|
|
|
bool HasS2 = GetConstantStringInfo(CI->getArgOperand(1), S2);
|
|
|
|
|
|
|
|
// strspn(s, "") -> 0
|
|
|
|
// strspn("", s) -> 0
|
|
|
|
if ((HasS1 && S1.empty()) || (HasS2 && S2.empty()))
|
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
|
|
|
// Constant folding.
|
|
|
|
if (HasS1 && HasS2)
|
|
|
|
return ConstantInt::get(CI->getType(), strspn(S1.c_str(), S2.c_str()));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strcspn' Optimizations
|
|
|
|
|
|
|
|
struct StrCSpnOpt : public LibCallOptimization {
|
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 ||
|
|
|
|
FT->getParamType(0) != Type::getInt8PtrTy(*Context) ||
|
|
|
|
FT->getParamType(1) != FT->getParamType(0) ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
std::string S1, S2;
|
|
|
|
bool HasS1 = GetConstantStringInfo(CI->getArgOperand(0), S1);
|
|
|
|
bool HasS2 = GetConstantStringInfo(CI->getArgOperand(1), S2);
|
|
|
|
|
|
|
|
// strcspn("", s) -> 0
|
|
|
|
if (HasS1 && S1.empty())
|
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
|
|
|
// Constant folding.
|
|
|
|
if (HasS1 && HasS2)
|
|
|
|
return ConstantInt::get(CI->getType(), strcspn(S1.c_str(), S2.c_str()));
|
|
|
|
|
|
|
|
// strcspn(s, "") -> strlen(s)
|
|
|
|
if (TD && HasS2 && S2.empty())
|
|
|
|
return EmitStrLen(CI->getArgOperand(0), B, TD);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-12-16 09:32:05 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'strstr' Optimizations
|
|
|
|
|
|
|
|
struct StrStrOpt : public LibCallOptimization {
|
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
|
|
|
!FT->getReturnType()->isPointerTy())
|
2009-12-16 09:32:05 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
// fold strstr(x, x) -> x.
|
2010-06-24 10:42:46 +00:00
|
|
|
if (CI->getArgOperand(0) == CI->getArgOperand(1))
|
|
|
|
return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
|
2010-01-04 07:55:25 +00:00
|
|
|
|
2010-06-15 21:34:25 +00:00
|
|
|
// fold strstr(a, b) == a -> strncmp(a, b, strlen(b)) == 0
|
2010-06-30 12:42:43 +00:00
|
|
|
if (TD && IsOnlyUsedInEqualityComparison(CI, CI->getArgOperand(0))) {
|
|
|
|
Value *StrLen = EmitStrLen(CI->getArgOperand(1), B, TD);
|
|
|
|
Value *StrNCmp = EmitStrNCmp(CI->getArgOperand(0), CI->getArgOperand(1),
|
2010-06-15 21:34:25 +00:00
|
|
|
StrLen, B, TD);
|
|
|
|
for (Value::use_iterator UI = CI->use_begin(), UE = CI->use_end();
|
|
|
|
UI != UE; ) {
|
2010-07-22 13:36:47 +00:00
|
|
|
ICmpInst *Old = cast<ICmpInst>(*UI++);
|
2010-06-15 21:34:25 +00:00
|
|
|
Value *Cmp = B.CreateICmp(Old->getPredicate(), StrNCmp,
|
|
|
|
ConstantInt::getNullValue(StrNCmp->getType()),
|
|
|
|
"cmp");
|
|
|
|
Old->replaceAllUsesWith(Cmp);
|
|
|
|
Old->eraseFromParent();
|
|
|
|
}
|
|
|
|
return CI;
|
|
|
|
}
|
|
|
|
|
2009-12-16 09:32:05 +00:00
|
|
|
// See if either input string is a constant string.
|
|
|
|
std::string SearchStr, ToFindStr;
|
2010-06-24 10:42:46 +00:00
|
|
|
bool HasStr1 = GetConstantStringInfo(CI->getArgOperand(0), SearchStr);
|
|
|
|
bool HasStr2 = GetConstantStringInfo(CI->getArgOperand(1), ToFindStr);
|
2010-01-04 07:55:25 +00:00
|
|
|
|
2009-12-16 09:32:05 +00:00
|
|
|
// fold strstr(x, "") -> x.
|
|
|
|
if (HasStr2 && ToFindStr.empty())
|
2010-06-24 10:42:46 +00:00
|
|
|
return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
|
2010-01-04 07:55:25 +00:00
|
|
|
|
2009-12-16 09:32:05 +00:00
|
|
|
// If both strings are known, constant fold it.
|
|
|
|
if (HasStr1 && HasStr2) {
|
|
|
|
std::string::size_type Offset = SearchStr.find(ToFindStr);
|
2010-01-04 07:55:25 +00:00
|
|
|
|
2009-12-16 09:32:05 +00:00
|
|
|
if (Offset == std::string::npos) // strstr("foo", "bar") -> null
|
|
|
|
return Constant::getNullValue(CI->getType());
|
|
|
|
|
|
|
|
// strstr("abcd", "bc") -> gep((char*)"abcd", 1)
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Result = CastToCStr(CI->getArgOperand(0), B);
|
2009-12-16 09:32:05 +00:00
|
|
|
Result = B.CreateConstInBoundsGEP1_64(Result, Offset, "strstr");
|
|
|
|
return B.CreateBitCast(Result, CI->getType());
|
|
|
|
}
|
2010-01-04 07:55:25 +00:00
|
|
|
|
2009-12-16 09:32:05 +00:00
|
|
|
// fold strstr(x, "y") -> strchr(x, 'y').
|
|
|
|
if (HasStr2 && ToFindStr.size() == 1)
|
2010-07-22 10:37:47 +00:00
|
|
|
return B.CreateBitCast(EmitStrChr(CI->getArgOperand(0),
|
|
|
|
ToFindStr[0], B, TD), CI->getType());
|
2009-12-16 09:32:05 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
2010-01-04 07:55:25 +00:00
|
|
|
|
2009-02-13 15:31:46 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'memcmp' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct MemCmpOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2010-02-16 11:11:14 +00:00
|
|
|
if (FT->getNumParams() != 3 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
2010-02-15 16:12:20 +00:00
|
|
|
!FT->getReturnType()->isIntegerTy(32))
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2008-05-19 09:27:24 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *LHS = CI->getArgOperand(0), *RHS = CI->getArgOperand(1);
|
2008-05-19 09:27:24 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
if (LHS == RHS) // memcmp(s,s,x) -> 0
|
2009-07-31 20:28:14 +00:00
|
|
|
return Constant::getNullValue(CI->getType());
|
2008-05-19 09:27:24 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Make sure we have a constant length.
|
2010-06-24 10:42:46 +00:00
|
|
|
ConstantInt *LenC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
|
2008-05-01 06:39:12 +00:00
|
|
|
if (!LenC) return 0;
|
2008-05-01 06:25:24 +00:00
|
|
|
uint64_t Len = LenC->getZExtValue();
|
2008-05-19 09:27:24 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Len == 0) // memcmp(s1,s2,0) -> 0
|
2009-07-31 20:28:14 +00:00
|
|
|
return Constant::getNullValue(CI->getType());
|
2008-05-01 06:25:24 +00:00
|
|
|
|
2010-05-25 22:53:43 +00:00
|
|
|
// memcmp(S1,S2,1) -> *(unsigned char*)LHS - *(unsigned char*)RHS
|
|
|
|
if (Len == 1) {
|
|
|
|
Value *LHSV = B.CreateZExt(B.CreateLoad(CastToCStr(LHS, B), "lhsc"),
|
|
|
|
CI->getType(), "lhsv");
|
|
|
|
Value *RHSV = B.CreateZExt(B.CreateLoad(CastToCStr(RHS, B), "rhsc"),
|
|
|
|
CI->getType(), "rhsv");
|
2010-05-26 09:45:04 +00:00
|
|
|
return B.CreateSub(LHSV, RHSV, "chardiff");
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2008-05-19 09:27:24 +00:00
|
|
|
|
2009-11-05 17:44:22 +00:00
|
|
|
// Constant folding: memcmp(x, y, l) -> cnst (all arguments are constant)
|
|
|
|
std::string LHSStr, RHSStr;
|
|
|
|
if (GetConstantStringInfo(LHS, LHSStr) &&
|
|
|
|
GetConstantStringInfo(RHS, RHSStr)) {
|
|
|
|
// Make sure we're not reading out-of-bounds memory.
|
|
|
|
if (Len > LHSStr.length() || Len > RHSStr.length())
|
|
|
|
return 0;
|
|
|
|
uint64_t Ret = memcmp(LHSStr.data(), RHSStr.data(), Len);
|
|
|
|
return ConstantInt::get(CI->getType(), Ret);
|
|
|
|
}
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'memcpy' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct MemCpyOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
2009-08-13 21:58:54 +00:00
|
|
|
FT->getParamType(2) != TD->getIntPtrType(*Context))
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
// memcpy(x, y, n) -> llvm.memcpy(x, y, n, 1)
|
2010-06-24 10:42:46 +00:00
|
|
|
EmitMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
CI->getArgOperand(2), 1, false, B, TD);
|
|
|
|
return CI->getArgOperand(0);
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-11-30 08:32:11 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'memmove' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct MemMoveOpt : public LibCallOptimization {
|
2008-11-30 08:32:11 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2008-11-30 08:32:11 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
2009-08-13 21:58:54 +00:00
|
|
|
FT->getParamType(2) != TD->getIntPtrType(*Context))
|
2008-11-30 08:32:11 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
// memmove(x, y, n) -> llvm.memmove(x, y, n, 1)
|
2010-06-24 10:42:46 +00:00
|
|
|
EmitMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
CI->getArgOperand(2), 1, false, B, TD);
|
|
|
|
return CI->getArgOperand(0);
|
2008-11-30 08:32:11 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'memset' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct MemSetOpt : public LibCallOptimization {
|
2008-11-30 08:32:11 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2008-11-30 08:32:11 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() != 3 || FT->getReturnType() != FT->getParamType(0) ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isIntegerTy() ||
|
2009-08-13 21:58:54 +00:00
|
|
|
FT->getParamType(2) != TD->getIntPtrType(*Context))
|
2008-11-30 08:32:11 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
// memset(p, v, n) -> llvm.memset(p, v, n, 1)
|
2010-07-22 10:37:47 +00:00
|
|
|
Value *Val = B.CreateIntCast(CI->getArgOperand(1),
|
|
|
|
Type::getInt8Ty(*Context), false);
|
2010-06-24 10:42:46 +00:00
|
|
|
EmitMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), false, B, TD);
|
|
|
|
return CI->getArgOperand(0);
|
2008-11-30 08:32:11 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Math Library Optimizations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'pow*' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct PowOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// Just make sure this has 2 arguments of the same FP type, which match the
|
|
|
|
// result type.
|
|
|
|
if (FT->getNumParams() != 2 || FT->getReturnType() != FT->getParamType(0) ||
|
|
|
|
FT->getParamType(0) != FT->getParamType(1) ||
|
2010-02-15 16:12:20 +00:00
|
|
|
!FT->getParamType(0)->isFloatingPointTy())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Op1 = CI->getArgOperand(0), *Op2 = CI->getArgOperand(1);
|
2008-05-01 06:25:24 +00:00
|
|
|
if (ConstantFP *Op1C = dyn_cast<ConstantFP>(Op1)) {
|
|
|
|
if (Op1C->isExactlyValue(1.0)) // pow(1.0, x) -> 1.0
|
|
|
|
return Op1C;
|
|
|
|
if (Op1C->isExactlyValue(2.0)) // pow(2.0, x) -> exp2(x)
|
2009-09-26 18:10:13 +00:00
|
|
|
return EmitUnaryFloatFnCall(Op2, "exp2", B, Callee->getAttributes());
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
ConstantFP *Op2C = dyn_cast<ConstantFP>(Op2);
|
|
|
|
if (Op2C == 0) return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Op2C->getValueAPF().isZero()) // pow(x, 0.0) -> 1.0
|
2009-07-27 20:59:43 +00:00
|
|
|
return ConstantFP::get(CI->getType(), 1.0);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Op2C->isExactlyValue(0.5)) {
|
2009-09-25 23:10:17 +00: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 infinite correctly.
|
|
|
|
// TODO: In fast-math mode, this could be just sqrt(x).
|
|
|
|
// TODO: In finite-only mode, this could be just fabs(sqrt(x)).
|
2009-09-25 23:40:21 +00:00
|
|
|
Value *Inf = ConstantFP::getInfinity(CI->getType());
|
|
|
|
Value *NegInf = ConstantFP::getInfinity(CI->getType(), true);
|
2009-09-26 18:10:13 +00:00
|
|
|
Value *Sqrt = EmitUnaryFloatFnCall(Op1, "sqrt", B,
|
|
|
|
Callee->getAttributes());
|
|
|
|
Value *FAbs = EmitUnaryFloatFnCall(Sqrt, "fabs", B,
|
|
|
|
Callee->getAttributes());
|
2009-09-25 23:10:17 +00:00
|
|
|
Value *FCmp = B.CreateFCmpOEQ(Op1, NegInf, "tmp");
|
|
|
|
Value *Sel = B.CreateSelect(FCmp, Inf, FAbs, "tmp");
|
|
|
|
return Sel;
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Op2C->isExactlyValue(1.0)) // pow(x, 1.0) -> x
|
|
|
|
return Op1;
|
|
|
|
if (Op2C->isExactlyValue(2.0)) // pow(x, 2.0) -> x*x
|
2009-06-04 22:49:04 +00:00
|
|
|
return B.CreateFMul(Op1, Op1, "pow2");
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Op2C->isExactlyValue(-1.0)) // pow(x, -1.0) -> 1.0/x
|
2009-07-27 20:59:43 +00:00
|
|
|
return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0),
|
2009-07-03 19:42:02 +00:00
|
|
|
Op1, "powrecip");
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-05-02 18:43:35 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'exp2' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct Exp2Opt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-02 18:43:35 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// Just make sure this has 1 argument of FP type, which matches the
|
|
|
|
// result type.
|
|
|
|
if (FT->getNumParams() != 1 || FT->getReturnType() != FT->getParamType(0) ||
|
2010-02-15 16:12:20 +00:00
|
|
|
!FT->getParamType(0)->isFloatingPointTy())
|
2008-05-02 18:43:35 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Op = CI->getArgOperand(0);
|
2008-05-02 18:43:35 +00:00
|
|
|
// 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
|
|
|
|
Value *LdExpArg = 0;
|
|
|
|
if (SIToFPInst *OpC = dyn_cast<SIToFPInst>(Op)) {
|
|
|
|
if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() <= 32)
|
2009-10-07 21:14:25 +00:00
|
|
|
LdExpArg = B.CreateSExt(OpC->getOperand(0),
|
2010-07-06 03:53:43 +00:00
|
|
|
Type::getInt32Ty(*Context), "tmp");
|
2008-05-02 18:43:35 +00:00
|
|
|
} else if (UIToFPInst *OpC = dyn_cast<UIToFPInst>(Op)) {
|
|
|
|
if (OpC->getOperand(0)->getType()->getPrimitiveSizeInBits() < 32)
|
2009-10-07 21:14:25 +00:00
|
|
|
LdExpArg = B.CreateZExt(OpC->getOperand(0),
|
2010-07-06 03:53:43 +00:00
|
|
|
Type::getInt32Ty(*Context), "tmp");
|
2008-05-02 18:43:35 +00:00
|
|
|
}
|
2009-06-18 20:05:31 +00:00
|
|
|
|
2008-05-02 18:43:35 +00:00
|
|
|
if (LdExpArg) {
|
|
|
|
const char *Name;
|
2009-10-05 05:54:46 +00:00
|
|
|
if (Op->getType()->isFloatTy())
|
2008-05-02 18:43:35 +00:00
|
|
|
Name = "ldexpf";
|
2009-10-05 05:54:46 +00:00
|
|
|
else if (Op->getType()->isDoubleTy())
|
2008-05-02 18:43:35 +00:00
|
|
|
Name = "ldexp";
|
|
|
|
else
|
|
|
|
Name = "ldexpl";
|
|
|
|
|
2009-07-27 20:59:43 +00:00
|
|
|
Constant *One = ConstantFP::get(*Context, APFloat(1.0f));
|
2009-10-05 05:54:46 +00:00
|
|
|
if (!Op->getType()->isFloatTy())
|
2009-07-29 18:55:55 +00:00
|
|
|
One = ConstantExpr::getFPExtend(One, Op->getType());
|
2008-05-02 18:43:35 +00:00
|
|
|
|
|
|
|
Module *M = Caller->getParent();
|
|
|
|
Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
|
2009-10-07 21:14:25 +00:00
|
|
|
Op->getType(),
|
2010-02-02 00:13:06 +00:00
|
|
|
Type::getInt32Ty(*Context),NULL);
|
2009-06-18 20:05:31 +00:00
|
|
|
CallInst *CI = B.CreateCall2(Callee, One, LdExpArg);
|
|
|
|
if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
|
|
|
|
CI->setCallingConv(F->getCallingConv());
|
|
|
|
|
|
|
|
return CI;
|
2008-05-02 18:43:35 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// Double -> Float Shrinking Optimizations for Unary Functions like 'floor'
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct UnaryDoubleFPOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2009-10-05 05:54:46 +00:00
|
|
|
if (FT->getNumParams() != 1 || !FT->getReturnType()->isDoubleTy() ||
|
|
|
|
!FT->getParamType(0)->isDoubleTy())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-06-18 20:05:31 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// If this is something like 'floor((double)floatval)', convert to floorf.
|
2010-06-24 10:42:46 +00:00
|
|
|
FPExtInst *Cast = dyn_cast<FPExtInst>(CI->getArgOperand(0));
|
2009-10-05 05:54:46 +00:00
|
|
|
if (Cast == 0 || !Cast->getOperand(0)->getType()->isFloatTy())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
// floor((double)floatval) -> (double)floorf(floatval)
|
|
|
|
Value *V = Cast->getOperand(0);
|
2009-09-26 18:10:13 +00:00
|
|
|
V = EmitUnaryFloatFnCall(V, Callee->getName().data(), B,
|
|
|
|
Callee->getAttributes());
|
2009-08-13 21:58:54 +00:00
|
|
|
return B.CreateFPExt(V, Type::getDoubleTy(*Context));
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Integer Optimizations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'ffs*' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct FFSOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// Just make sure this has 2 arguments of the same FP type, which match the
|
|
|
|
// result type.
|
2009-10-07 21:14:25 +00:00
|
|
|
if (FT->getNumParams() != 1 ||
|
2010-07-06 03:53:43 +00:00
|
|
|
!FT->getReturnType()->isIntegerTy(32) ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FT->getParamType(0)->isIntegerTy())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Op = CI->getArgOperand(0);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Constant fold.
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
|
|
|
|
if (CI->getValue() == 0) // ffs(0) -> 0.
|
2009-07-31 20:28:14 +00:00
|
|
|
return Constant::getNullValue(CI->getType());
|
2009-08-13 21:58:54 +00:00
|
|
|
return ConstantInt::get(Type::getInt32Ty(*Context), // ffs(c) -> cttz(c)+1
|
2008-05-01 06:25:24 +00:00
|
|
|
CI->getValue().countTrailingZeros()+1);
|
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// ffs(x) -> x != 0 ? (i32)llvm.cttz(x)+1 : 0
|
|
|
|
const Type *ArgType = Op->getType();
|
|
|
|
Value *F = Intrinsic::getDeclaration(Callee->getParent(),
|
|
|
|
Intrinsic::cttz, &ArgType, 1);
|
|
|
|
Value *V = B.CreateCall(F, Op, "cttz");
|
2009-07-24 23:12:02 +00:00
|
|
|
V = B.CreateAdd(V, ConstantInt::get(V->getType(), 1), "tmp");
|
2009-08-13 21:58:54 +00:00
|
|
|
V = B.CreateIntCast(V, Type::getInt32Ty(*Context), false, "tmp");
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-07-31 20:28:14 +00:00
|
|
|
Value *Cond = B.CreateICmpNE(Op, Constant::getNullValue(ArgType), "tmp");
|
2009-10-07 21:14:25 +00:00
|
|
|
return B.CreateSelect(Cond, V,
|
2010-07-06 03:53:43 +00:00
|
|
|
ConstantInt::get(Type::getInt32Ty(*Context), 0));
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'isdigit' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct IsDigitOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// We require integer(i32)
|
2010-02-16 11:11:14 +00:00
|
|
|
if (FT->getNumParams() != 1 || !FT->getReturnType()->isIntegerTy() ||
|
2010-02-15 16:12:20 +00:00
|
|
|
!FT->getParamType(0)->isIntegerTy(32))
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// isdigit(c) -> (c-'0') <u 10
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Op = CI->getArgOperand(0);
|
2009-10-07 21:14:25 +00:00
|
|
|
Op = B.CreateSub(Op, ConstantInt::get(Type::getInt32Ty(*Context), '0'),
|
2009-07-03 19:42:02 +00:00
|
|
|
"isdigittmp");
|
2009-10-07 21:14:25 +00:00
|
|
|
Op = B.CreateICmpULT(Op, ConstantInt::get(Type::getInt32Ty(*Context), 10),
|
2009-07-03 19:42:02 +00:00
|
|
|
"isdigit");
|
2008-05-01 06:25:24 +00:00
|
|
|
return B.CreateZExt(Op, CI->getType());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'isascii' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct IsAsciiOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// We require integer(i32)
|
2010-02-16 11:11:14 +00:00
|
|
|
if (FT->getNumParams() != 1 || !FT->getReturnType()->isIntegerTy() ||
|
2010-02-15 16:12:20 +00:00
|
|
|
!FT->getParamType(0)->isIntegerTy(32))
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// isascii(c) -> c <u 128
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Op = CI->getArgOperand(0);
|
2009-08-13 21:58:54 +00:00
|
|
|
Op = B.CreateICmpULT(Op, ConstantInt::get(Type::getInt32Ty(*Context), 128),
|
2009-07-03 19:42:02 +00:00
|
|
|
"isascii");
|
2008-05-01 06:25:24 +00:00
|
|
|
return B.CreateZExt(Op, CI->getType());
|
|
|
|
}
|
|
|
|
};
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-06-09 08:26:51 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'abs', 'labs', 'llabs' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct AbsOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-06-09 08:26:51 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// We require integer(integer) where the types agree.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (FT->getNumParams() != 1 || !FT->getReturnType()->isIntegerTy() ||
|
2008-06-09 08:26:51 +00:00
|
|
|
FT->getParamType(0) != FT->getReturnType())
|
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-06-09 08:26:51 +00:00
|
|
|
// abs(x) -> x >s -1 ? x : -x
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Op = CI->getArgOperand(0);
|
2009-10-07 21:14:25 +00:00
|
|
|
Value *Pos = B.CreateICmpSGT(Op,
|
2009-07-31 20:28:14 +00:00
|
|
|
Constant::getAllOnesValue(Op->getType()),
|
2008-06-09 08:26:51 +00:00
|
|
|
"ispos");
|
|
|
|
Value *Neg = B.CreateNeg(Op, "neg");
|
|
|
|
return B.CreateSelect(Pos, Op, Neg);
|
|
|
|
}
|
|
|
|
};
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'toascii' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct ToAsciiOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
// We require i32(i32)
|
|
|
|
if (FT->getNumParams() != 1 || FT->getReturnType() != FT->getParamType(0) ||
|
2010-02-15 16:12:20 +00:00
|
|
|
!FT->getParamType(0)->isIntegerTy(32))
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// isascii(c) -> c & 0x7f
|
2010-06-24 10:42:46 +00:00
|
|
|
return B.CreateAnd(CI->getArgOperand(0),
|
2009-07-24 23:12:02 +00:00
|
|
|
ConstantInt::get(CI->getType(),0x7F));
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Formatting and IO Optimizations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'printf' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct PrintFOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// Require one fixed pointer argument and an integer/void result.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2010-02-16 11:11:14 +00:00
|
|
|
if (FT->getNumParams() < 1 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!(FT->getReturnType()->isIntegerTy() ||
|
2009-10-05 05:54:46 +00:00
|
|
|
FT->getReturnType()->isVoidTy()))
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Check for a fixed format string.
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string FormatStr;
|
2010-06-24 10:42:46 +00:00
|
|
|
if (!GetConstantStringInfo(CI->getArgOperand(0), FormatStr))
|
2009-03-13 04:39:26 +00:00
|
|
|
return 0;
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
// Empty format string -> noop.
|
|
|
|
if (FormatStr.empty()) // Tolerate printf's declared void.
|
2009-10-07 21:14:25 +00:00
|
|
|
return CI->use_empty() ? (Value*)CI :
|
2009-07-24 23:12:02 +00:00
|
|
|
ConstantInt::get(CI->getType(), 0);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-11-09 04:57:04 +00:00
|
|
|
// printf("x") -> putchar('x'), even for '%'. Return the result of putchar
|
|
|
|
// in case there is an error writing to stdout.
|
2008-05-01 06:25:24 +00:00
|
|
|
if (FormatStr.size() == 1) {
|
2009-11-09 04:57:04 +00:00
|
|
|
Value *Res = EmitPutChar(ConstantInt::get(Type::getInt32Ty(*Context),
|
2010-03-05 22:25:30 +00:00
|
|
|
FormatStr[0]), B, TD);
|
2009-11-09 04:57:04 +00:00
|
|
|
if (CI->use_empty()) return CI;
|
|
|
|
return B.CreateIntCast(Res, CI->getType(), true);
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// printf("foo\n") --> puts("foo")
|
|
|
|
if (FormatStr[FormatStr.size()-1] == '\n' &&
|
|
|
|
FormatStr.find('%') == std::string::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.erase(FormatStr.end()-1);
|
2009-08-13 21:58:54 +00:00
|
|
|
Constant *C = ConstantArray::get(*Context, FormatStr, true);
|
2009-07-08 19:03:57 +00:00
|
|
|
C = new GlobalVariable(*Callee->getParent(), C->getType(), true,
|
|
|
|
GlobalVariable::InternalLinkage, C, "str");
|
2010-03-05 22:25:30 +00:00
|
|
|
EmitPutS(C, B, TD);
|
2009-10-07 21:14:25 +00:00
|
|
|
return CI->use_empty() ? (Value*)CI :
|
2009-07-24 23:12:02 +00:00
|
|
|
ConstantInt::get(CI->getType(), FormatStr.size()+1);
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Optimize specific format strings.
|
2010-06-24 10:42:46 +00:00
|
|
|
// printf("%c", chr) --> putchar(chr)
|
2010-06-30 12:42:43 +00:00
|
|
|
if (FormatStr == "%c" && CI->getNumArgOperands() > 1 &&
|
2010-06-24 10:42:46 +00:00
|
|
|
CI->getArgOperand(1)->getType()->isIntegerTy()) {
|
|
|
|
Value *Res = EmitPutChar(CI->getArgOperand(1), B, TD);
|
2009-11-21 01:01:30 +00:00
|
|
|
|
2009-11-09 04:57:04 +00:00
|
|
|
if (CI->use_empty()) return CI;
|
|
|
|
return B.CreateIntCast(Res, CI->getType(), true);
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// printf("%s\n", str) --> puts(str)
|
2010-06-30 12:42:43 +00:00
|
|
|
if (FormatStr == "%s\n" && CI->getNumArgOperands() > 1 &&
|
2010-06-24 10:42:46 +00:00
|
|
|
CI->getArgOperand(1)->getType()->isPointerTy() &&
|
2008-05-01 06:25:24 +00:00
|
|
|
CI->use_empty()) {
|
2010-06-24 10:42:46 +00:00
|
|
|
EmitPutS(CI->getArgOperand(1), B, TD);
|
2008-05-01 06:25:24 +00:00
|
|
|
return CI;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'sprintf' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct SPrintFOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// Require two fixed pointer arguments and an integer result.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2010-02-16 11:11:14 +00:00
|
|
|
if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Check for a fixed format string.
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string FormatStr;
|
2010-06-24 10:42:46 +00:00
|
|
|
if (!GetConstantStringInfo(CI->getArgOperand(1), FormatStr))
|
2009-03-13 04:39:26 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// If we just have a format string (nothing else crazy) transform it.
|
2010-06-30 12:42:43 +00:00
|
|
|
if (CI->getNumArgOperands() == 2) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// 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 0; // we found a format specifier, bail out.
|
2009-08-18 00:48:13 +00:00
|
|
|
|
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// sprintf(str, fmt) -> llvm.memcpy(str, fmt, strlen(fmt)+1, 1)
|
2010-07-22 10:37:47 +00:00
|
|
|
EmitMemCpy(CI->getArgOperand(0), CI->getArgOperand(1), // Copy the
|
|
|
|
ConstantInt::get(TD->getIntPtrType(*Context), // nul byte.
|
|
|
|
FormatStr.size() + 1), 1, false, B, TD);
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), FormatStr.size());
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// The remaining optimizations require the format string to be "%s" or "%c"
|
|
|
|
// and have an extra operand.
|
2010-06-30 12:42:43 +00:00
|
|
|
if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
|
|
|
|
CI->getNumArgOperands() < 3)
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Decode the second character of the format string.
|
|
|
|
if (FormatStr[1] == 'c') {
|
2008-05-01 06:39:12 +00:00
|
|
|
// sprintf(dst, "%c", chr) --> *(i8*)dst = chr; *((i8*)dst+1) = 0
|
2010-06-24 10:42:46 +00:00
|
|
|
if (!CI->getArgOperand(2)->getType()->isIntegerTy()) return 0;
|
|
|
|
Value *V = B.CreateTrunc(CI->getArgOperand(2),
|
Reapply address space patch after fixing an issue in MemCopyOptimizer.
Added support for address spaces and added a isVolatile field to memcpy, memmove, and memset,
e.g., llvm.memcpy.i32(i8*, i8*, i32, i32) -> llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100304 91177308-0d34-0410-b5e6-96231b3b80d8
2010-04-04 03:10:48 +00:00
|
|
|
Type::getInt8Ty(*Context), "char");
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Ptr = CastToCStr(CI->getArgOperand(0), B);
|
2008-05-01 06:39:12 +00:00
|
|
|
B.CreateStore(V, Ptr);
|
2009-10-07 21:14:25 +00:00
|
|
|
Ptr = B.CreateGEP(Ptr, ConstantInt::get(Type::getInt32Ty(*Context), 1),
|
Reapply address space patch after fixing an issue in MemCopyOptimizer.
Added support for address spaces and added a isVolatile field to memcpy, memmove, and memset,
e.g., llvm.memcpy.i32(i8*, i8*, i32, i32) -> llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100304 91177308-0d34-0410-b5e6-96231b3b80d8
2010-04-04 03:10:48 +00:00
|
|
|
"nul");
|
2009-08-13 21:58:54 +00:00
|
|
|
B.CreateStore(Constant::getNullValue(Type::getInt8Ty(*Context)), Ptr);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), 1);
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
if (FormatStr[1] == 's') {
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// sprintf(dest, "%s", str) -> llvm.memcpy(dest, str, strlen(str)+1, 1)
|
2010-06-24 10:42:46 +00:00
|
|
|
if (!CI->getArgOperand(2)->getType()->isPointerTy()) return 0;
|
2008-05-01 06:25:24 +00:00
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Len = EmitStrLen(CI->getArgOperand(2), B, TD);
|
2009-07-03 19:42:02 +00:00
|
|
|
Value *IncLen = B.CreateAdd(Len,
|
2009-07-24 23:12:02 +00:00
|
|
|
ConstantInt::get(Len->getType(), 1),
|
2008-05-01 06:25:24 +00:00
|
|
|
"leninc");
|
2010-07-22 10:37:47 +00:00
|
|
|
EmitMemCpy(CI->getArgOperand(0), CI->getArgOperand(2),
|
|
|
|
IncLen, 1, false, B, TD);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// The sprintf result is the unincremented number of bytes in the string.
|
|
|
|
return B.CreateIntCast(Len, CI->getType(), false);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'fwrite' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct FWriteOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// Require a pointer, an integer, an integer, a pointer, returning integer.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2010-02-16 11:11:14 +00:00
|
|
|
if (FT->getNumParams() != 4 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isIntegerTy() ||
|
|
|
|
!FT->getParamType(2)->isIntegerTy() ||
|
|
|
|
!FT->getParamType(3)->isPointerTy() ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Get the element size and count.
|
2010-06-24 10:42:46 +00:00
|
|
|
ConstantInt *SizeC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
|
|
|
|
ConstantInt *CountC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
|
2008-05-01 06:25:24 +00:00
|
|
|
if (!SizeC || !CountC) return 0;
|
|
|
|
uint64_t Bytes = SizeC->getZExtValue()*CountC->getZExtValue();
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// If this is writing zero records, remove the call (it's a noop).
|
|
|
|
if (Bytes == 0)
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), 0);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// If this is writing one byte, turn it into fputc.
|
|
|
|
if (Bytes == 1) { // fwrite(S,1,1,F) -> fputc(S[0],F)
|
2010-06-24 10:42:46 +00:00
|
|
|
Value *Char = B.CreateLoad(CastToCStr(CI->getArgOperand(0), B), "char");
|
|
|
|
EmitFPutC(Char, CI->getArgOperand(3), B, TD);
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), 1);
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'fputs' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct FPutsOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2009-08-18 00:48:13 +00:00
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Require two pointers. Also, we can't optimize if return value is used.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2010-02-16 11:11:14 +00:00
|
|
|
if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
2008-05-01 06:25:24 +00:00
|
|
|
!CI->use_empty())
|
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// fputs(s,F) --> fwrite(s,1,strlen(s),F)
|
2010-06-24 10:42:46 +00:00
|
|
|
uint64_t Len = GetStringLength(CI->getArgOperand(0));
|
2008-05-01 06:39:12 +00:00
|
|
|
if (!Len) return 0;
|
2010-06-24 10:42:46 +00:00
|
|
|
EmitFWrite(CI->getArgOperand(0),
|
2009-08-13 21:58:54 +00:00
|
|
|
ConstantInt::get(TD->getIntPtrType(*Context), Len-1),
|
2010-06-24 10:42:46 +00:00
|
|
|
CI->getArgOperand(1), B, TD);
|
2008-05-01 06:25:24 +00:00
|
|
|
return CI; // Known to have no uses (see above).
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'fprintf' Optimizations
|
|
|
|
|
2009-09-02 06:11:42 +00:00
|
|
|
struct FPrintFOpt : public LibCallOptimization {
|
2008-08-08 19:39:37 +00:00
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
2008-05-01 06:25:24 +00:00
|
|
|
// Require two fixed paramters as pointers and integer result.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
2010-02-16 11:11:14 +00:00
|
|
|
if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!FT->getParamType(1)->isPointerTy() ||
|
|
|
|
!FT->getReturnType()->isIntegerTy())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// All the optimizations depend on the format string.
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string FormatStr;
|
2010-06-24 10:42:46 +00:00
|
|
|
if (!GetConstantStringInfo(CI->getArgOperand(1), FormatStr))
|
2009-03-13 04:39:26 +00:00
|
|
|
return 0;
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
// fprintf(F, "foo") --> fwrite("foo", 3, 1, F)
|
2010-06-30 12:42:43 +00:00
|
|
|
if (CI->getNumArgOperands() == 2) {
|
2008-05-01 06:25:24 +00:00
|
|
|
for (unsigned i = 0, e = FormatStr.size(); i != e; ++i)
|
|
|
|
if (FormatStr[i] == '%') // Could handle %% -> % if we cared.
|
2008-05-01 06:39:12 +00:00
|
|
|
return 0; // We found a format specifier.
|
2009-08-18 00:48:13 +00:00
|
|
|
|
|
|
|
// These optimizations require TargetData.
|
|
|
|
if (!TD) return 0;
|
|
|
|
|
2010-06-24 10:42:46 +00:00
|
|
|
EmitFWrite(CI->getArgOperand(1),
|
2010-01-04 07:55:25 +00:00
|
|
|
ConstantInt::get(TD->getIntPtrType(*Context),
|
|
|
|
FormatStr.size()),
|
2010-06-24 10:42:46 +00:00
|
|
|
CI->getArgOperand(0), B, TD);
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), FormatStr.size());
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// The remaining optimizations require the format string to be "%s" or "%c"
|
|
|
|
// and have an extra operand.
|
2010-06-30 12:42:43 +00:00
|
|
|
if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
|
|
|
|
CI->getNumArgOperands() < 3)
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Decode the second character of the format string.
|
|
|
|
if (FormatStr[1] == 'c') {
|
2010-06-24 10:42:46 +00:00
|
|
|
// fprintf(F, "%c", chr) --> fputc(chr, F)
|
|
|
|
if (!CI->getArgOperand(2)->getType()->isIntegerTy()) return 0;
|
|
|
|
EmitFPutC(CI->getArgOperand(2), CI->getArgOperand(0), B, TD);
|
2009-07-24 23:12:02 +00:00
|
|
|
return ConstantInt::get(CI->getType(), 1);
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
if (FormatStr[1] == 's') {
|
2010-06-24 10:42:46 +00:00
|
|
|
// fprintf(F, "%s", str) --> fputs(str, F)
|
|
|
|
if (!CI->getArgOperand(2)->getType()->isPointerTy() || !CI->use_empty())
|
2008-05-01 06:25:24 +00:00
|
|
|
return 0;
|
2010-06-24 10:42:46 +00:00
|
|
|
EmitFPutS(CI->getArgOperand(2), CI->getArgOperand(0), B, TD);
|
2008-05-01 06:25:24 +00:00
|
|
|
return CI;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-11-30 06:19:18 +00:00
|
|
|
//===---------------------------------------===//
|
|
|
|
// 'puts' Optimizations
|
|
|
|
|
|
|
|
struct PutsOpt : public LibCallOptimization {
|
|
|
|
virtual Value *CallOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B) {
|
|
|
|
// Require one fixed pointer argument and an integer/void result.
|
|
|
|
const FunctionType *FT = Callee->getFunctionType();
|
|
|
|
if (FT->getNumParams() < 1 || !FT->getParamType(0)->isPointerTy() ||
|
|
|
|
!(FT->getReturnType()->isIntegerTy() ||
|
|
|
|
FT->getReturnType()->isVoidTy()))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Check for a constant string.
|
|
|
|
std::string Str;
|
|
|
|
if (!GetConstantStringInfo(CI->getArgOperand(0), Str))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (Str.empty()) {
|
|
|
|
// puts("") -> putchar('\n')
|
|
|
|
Value *Res = EmitPutChar(B.getInt32('\n'), B, TD);
|
|
|
|
if (CI->use_empty()) return CI;
|
|
|
|
return B.CreateIntCast(Res, CI->getType(), true);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-05-05 21:37:59 +00:00
|
|
|
} // end anonymous namespace.
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SimplifyLibCalls Pass Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
/// This pass optimizes well known library functions from libc and libm.
|
|
|
|
///
|
2009-09-02 06:11:42 +00:00
|
|
|
class SimplifyLibCalls : public FunctionPass {
|
2008-05-01 06:25:24 +00:00
|
|
|
StringMap<LibCallOptimization*> Optimizations;
|
|
|
|
// String and Memory LibCall Optimizations
|
2010-09-29 21:50:51 +00:00
|
|
|
StrCatOpt StrCat; StrNCatOpt StrNCat; StrChrOpt StrChr; StrRChrOpt StrRChr;
|
|
|
|
StrCmpOpt StrCmp; StrNCmpOpt StrNCmp; StrCpyOpt StrCpy; StrCpyOpt StrCpyChk;
|
2010-09-29 23:52:12 +00:00
|
|
|
StrNCpyOpt StrNCpy; StrLenOpt StrLen; StrPBrkOpt StrPBrk;
|
2010-09-30 00:58:35 +00:00
|
|
|
StrToOpt StrTo; StrSpnOpt StrSpn; StrCSpnOpt StrCSpn; StrStrOpt StrStr;
|
2009-12-16 09:32:05 +00:00
|
|
|
MemCmpOpt MemCmp; MemCpyOpt MemCpy; MemMoveOpt MemMove; MemSetOpt MemSet;
|
2008-05-01 06:25:24 +00:00
|
|
|
// Math Library Optimizations
|
2008-05-02 18:43:35 +00:00
|
|
|
PowOpt Pow; Exp2Opt Exp2; UnaryDoubleFPOpt UnaryDoubleFP;
|
2008-05-01 06:25:24 +00:00
|
|
|
// Integer Optimizations
|
2008-06-09 08:26:51 +00:00
|
|
|
FFSOpt FFS; AbsOpt Abs; IsDigitOpt IsDigit; IsAsciiOpt IsAscii;
|
|
|
|
ToAsciiOpt ToAscii;
|
2008-05-01 06:25:24 +00:00
|
|
|
// Formatting and IO Optimizations
|
|
|
|
SPrintFOpt SPrintF; PrintFOpt PrintF;
|
|
|
|
FWriteOpt FWrite; FPutsOpt FPuts; FPrintFOpt FPrintF;
|
2010-11-30 06:19:18 +00:00
|
|
|
PutsOpt Puts;
|
2009-11-21 01:01:30 +00:00
|
|
|
|
2009-01-05 00:07:50 +00:00
|
|
|
bool Modified; // This is only used by doInitialization.
|
2008-05-01 06:25:24 +00:00
|
|
|
public:
|
|
|
|
static char ID; // Pass identification
|
2010-10-19 17:21:58 +00:00
|
|
|
SimplifyLibCalls() : FunctionPass(ID), StrCpy(false), StrCpyChk(true) {
|
|
|
|
initializeSimplifyLibCallsPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2008-05-01 06:25:24 +00:00
|
|
|
void InitOptimizations();
|
|
|
|
bool runOnFunction(Function &F);
|
|
|
|
|
2009-01-04 20:27:34 +00:00
|
|
|
void setDoesNotAccessMemory(Function &F);
|
|
|
|
void setOnlyReadsMemory(Function &F);
|
|
|
|
void setDoesNotThrow(Function &F);
|
|
|
|
void setDoesNotCapture(Function &F, unsigned n);
|
|
|
|
void setDoesNotAlias(Function &F, unsigned n);
|
2009-01-05 00:07:50 +00:00
|
|
|
bool doInitialization(Module &M);
|
2009-01-04 20:27:34 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
}
|
|
|
|
};
|
|
|
|
char SimplifyLibCalls::ID = 0;
|
|
|
|
} // end anonymous namespace.
|
|
|
|
|
2010-07-21 22:09:45 +00:00
|
|
|
INITIALIZE_PASS(SimplifyLibCalls, "simplify-libcalls",
|
2010-10-07 22:25:06 +00:00
|
|
|
"Simplify well-known library calls", false, false)
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
// Public interface to the Simplify LibCalls pass.
|
|
|
|
FunctionPass *llvm::createSimplifyLibCallsPass() {
|
2009-10-07 21:14:25 +00:00
|
|
|
return new SimplifyLibCalls();
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Optimizations - Populate the Optimizations map with all the optimizations
|
|
|
|
/// we know.
|
|
|
|
void SimplifyLibCalls::InitOptimizations() {
|
|
|
|
// String and Memory LibCall Optimizations
|
|
|
|
Optimizations["strcat"] = &StrCat;
|
2009-04-12 05:06:39 +00:00
|
|
|
Optimizations["strncat"] = &StrNCat;
|
2008-05-01 06:25:24 +00:00
|
|
|
Optimizations["strchr"] = &StrChr;
|
2010-09-29 21:50:51 +00:00
|
|
|
Optimizations["strrchr"] = &StrRChr;
|
2008-05-01 06:25:24 +00:00
|
|
|
Optimizations["strcmp"] = &StrCmp;
|
|
|
|
Optimizations["strncmp"] = &StrNCmp;
|
|
|
|
Optimizations["strcpy"] = &StrCpy;
|
2009-04-12 05:06:39 +00:00
|
|
|
Optimizations["strncpy"] = &StrNCpy;
|
2008-05-01 06:25:24 +00:00
|
|
|
Optimizations["strlen"] = &StrLen;
|
2010-09-29 23:52:12 +00:00
|
|
|
Optimizations["strpbrk"] = &StrPBrk;
|
2009-02-13 15:31:46 +00:00
|
|
|
Optimizations["strtol"] = &StrTo;
|
|
|
|
Optimizations["strtod"] = &StrTo;
|
|
|
|
Optimizations["strtof"] = &StrTo;
|
|
|
|
Optimizations["strtoul"] = &StrTo;
|
|
|
|
Optimizations["strtoll"] = &StrTo;
|
|
|
|
Optimizations["strtold"] = &StrTo;
|
|
|
|
Optimizations["strtoull"] = &StrTo;
|
2010-09-30 00:58:35 +00:00
|
|
|
Optimizations["strspn"] = &StrSpn;
|
|
|
|
Optimizations["strcspn"] = &StrCSpn;
|
2009-12-16 09:32:05 +00:00
|
|
|
Optimizations["strstr"] = &StrStr;
|
2008-05-01 06:25:24 +00:00
|
|
|
Optimizations["memcmp"] = &MemCmp;
|
|
|
|
Optimizations["memcpy"] = &MemCpy;
|
2008-11-30 08:32:11 +00:00
|
|
|
Optimizations["memmove"] = &MemMove;
|
|
|
|
Optimizations["memset"] = &MemSet;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2010-03-23 15:48:04 +00:00
|
|
|
// _chk variants of String and Memory LibCall Optimizations.
|
|
|
|
Optimizations["__strcpy_chk"] = &StrCpyChk;
|
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Math Library Optimizations
|
|
|
|
Optimizations["powf"] = &Pow;
|
|
|
|
Optimizations["pow"] = &Pow;
|
|
|
|
Optimizations["powl"] = &Pow;
|
2008-09-04 18:30:46 +00:00
|
|
|
Optimizations["llvm.pow.f32"] = &Pow;
|
|
|
|
Optimizations["llvm.pow.f64"] = &Pow;
|
|
|
|
Optimizations["llvm.pow.f80"] = &Pow;
|
|
|
|
Optimizations["llvm.pow.f128"] = &Pow;
|
|
|
|
Optimizations["llvm.pow.ppcf128"] = &Pow;
|
2008-05-02 18:43:35 +00:00
|
|
|
Optimizations["exp2l"] = &Exp2;
|
|
|
|
Optimizations["exp2"] = &Exp2;
|
|
|
|
Optimizations["exp2f"] = &Exp2;
|
2008-09-04 18:30:46 +00:00
|
|
|
Optimizations["llvm.exp2.ppcf128"] = &Exp2;
|
|
|
|
Optimizations["llvm.exp2.f128"] = &Exp2;
|
|
|
|
Optimizations["llvm.exp2.f80"] = &Exp2;
|
|
|
|
Optimizations["llvm.exp2.f64"] = &Exp2;
|
|
|
|
Optimizations["llvm.exp2.f32"] = &Exp2;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
#ifdef HAVE_FLOORF
|
|
|
|
Optimizations["floor"] = &UnaryDoubleFP;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_CEILF
|
|
|
|
Optimizations["ceil"] = &UnaryDoubleFP;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_ROUNDF
|
|
|
|
Optimizations["round"] = &UnaryDoubleFP;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_RINTF
|
|
|
|
Optimizations["rint"] = &UnaryDoubleFP;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_NEARBYINTF
|
|
|
|
Optimizations["nearbyint"] = &UnaryDoubleFP;
|
|
|
|
#endif
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Integer Optimizations
|
|
|
|
Optimizations["ffs"] = &FFS;
|
|
|
|
Optimizations["ffsl"] = &FFS;
|
|
|
|
Optimizations["ffsll"] = &FFS;
|
2008-06-09 08:26:51 +00:00
|
|
|
Optimizations["abs"] = &Abs;
|
|
|
|
Optimizations["labs"] = &Abs;
|
|
|
|
Optimizations["llabs"] = &Abs;
|
2008-05-01 06:25:24 +00:00
|
|
|
Optimizations["isdigit"] = &IsDigit;
|
|
|
|
Optimizations["isascii"] = &IsAscii;
|
|
|
|
Optimizations["toascii"] = &ToAscii;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Formatting and IO Optimizations
|
|
|
|
Optimizations["sprintf"] = &SPrintF;
|
|
|
|
Optimizations["printf"] = &PrintF;
|
|
|
|
Optimizations["fwrite"] = &FWrite;
|
|
|
|
Optimizations["fputs"] = &FPuts;
|
|
|
|
Optimizations["fprintf"] = &FPrintF;
|
2010-11-30 06:19:18 +00:00
|
|
|
Optimizations["puts"] = &Puts;
|
2008-05-01 06:25:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// runOnFunction - Top level algorithm.
|
|
|
|
///
|
|
|
|
bool SimplifyLibCalls::runOnFunction(Function &F) {
|
|
|
|
if (Optimizations.empty())
|
|
|
|
InitOptimizations();
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-08-18 00:48:13 +00:00
|
|
|
const TargetData *TD = getAnalysisIfAvailable<TargetData>();
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2009-07-22 00:24:57 +00:00
|
|
|
IRBuilder<> Builder(F.getContext());
|
2008-05-01 06:25:24 +00:00
|
|
|
|
|
|
|
bool Changed = false;
|
|
|
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
|
|
|
|
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
|
|
|
|
// Ignore non-calls.
|
|
|
|
CallInst *CI = dyn_cast<CallInst>(I++);
|
|
|
|
if (!CI) continue;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Ignore indirect calls and calls to non-external functions.
|
|
|
|
Function *Callee = CI->getCalledFunction();
|
|
|
|
if (Callee == 0 || !Callee->isDeclaration() ||
|
|
|
|
!(Callee->hasExternalLinkage() || Callee->hasDLLImportLinkage()))
|
|
|
|
continue;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Ignore unknown calls.
|
2009-07-26 08:34:35 +00:00
|
|
|
LibCallOptimization *LCO = Optimizations.lookup(Callee->getName());
|
|
|
|
if (!LCO) continue;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Set the builder to the instruction after the call.
|
|
|
|
Builder.SetInsertPoint(BB, I);
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Try to optimize this call.
|
2009-07-26 08:34:35 +00:00
|
|
|
Value *Result = LCO->OptimizeCall(CI, TD, Builder);
|
2008-05-01 06:25:24 +00:00
|
|
|
if (Result == 0) continue;
|
|
|
|
|
2010-01-05 01:27:21 +00:00
|
|
|
DEBUG(dbgs() << "SimplifyLibCalls simplified: " << *CI;
|
|
|
|
dbgs() << " into: " << *Result << "\n");
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Something changed!
|
|
|
|
Changed = true;
|
|
|
|
++NumSimplified;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
// Inspect the instruction after the call (which was potentially just
|
|
|
|
// added) next.
|
|
|
|
I = CI; ++I;
|
2009-10-07 21:14:25 +00:00
|
|
|
|
2008-05-01 06:25:24 +00:00
|
|
|
if (CI != Result && !CI->use_empty()) {
|
|
|
|
CI->replaceAllUsesWith(Result);
|
|
|
|
if (!Result->hasName())
|
|
|
|
Result->takeName(CI);
|
|
|
|
}
|
|
|
|
CI->eraseFromParent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2009-01-05 00:07:50 +00:00
|
|
|
// Utility methods for doInitialization.
|
2009-01-04 20:27:34 +00:00
|
|
|
|
|
|
|
void SimplifyLibCalls::setDoesNotAccessMemory(Function &F) {
|
|
|
|
if (!F.doesNotAccessMemory()) {
|
|
|
|
F.setDoesNotAccessMemory();
|
|
|
|
++NumAnnotated;
|
|
|
|
Modified = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void SimplifyLibCalls::setOnlyReadsMemory(Function &F) {
|
|
|
|
if (!F.onlyReadsMemory()) {
|
|
|
|
F.setOnlyReadsMemory();
|
|
|
|
++NumAnnotated;
|
|
|
|
Modified = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void SimplifyLibCalls::setDoesNotThrow(Function &F) {
|
|
|
|
if (!F.doesNotThrow()) {
|
|
|
|
F.setDoesNotThrow();
|
|
|
|
++NumAnnotated;
|
|
|
|
Modified = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void SimplifyLibCalls::setDoesNotCapture(Function &F, unsigned n) {
|
|
|
|
if (!F.doesNotCapture(n)) {
|
|
|
|
F.setDoesNotCapture(n);
|
|
|
|
++NumAnnotated;
|
|
|
|
Modified = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void SimplifyLibCalls::setDoesNotAlias(Function &F, unsigned n) {
|
|
|
|
if (!F.doesNotAlias(n)) {
|
|
|
|
F.setDoesNotAlias(n);
|
|
|
|
++NumAnnotated;
|
|
|
|
Modified = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-05 00:07:50 +00:00
|
|
|
/// doInitialization - Add attributes to well-known functions.
|
2009-01-04 20:27:34 +00:00
|
|
|
///
|
2009-01-05 00:07:50 +00:00
|
|
|
bool SimplifyLibCalls::doInitialization(Module &M) {
|
2009-01-04 20:27:34 +00:00
|
|
|
Modified = false;
|
|
|
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
|
|
|
|
Function &F = *I;
|
|
|
|
if (!F.isDeclaration())
|
|
|
|
continue;
|
|
|
|
|
2009-07-26 07:49:05 +00:00
|
|
|
if (!F.hasName())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
const FunctionType *FTy = F.getFunctionType();
|
|
|
|
|
2009-07-26 07:49:05 +00:00
|
|
|
StringRef Name = F.getName();
|
|
|
|
switch (Name[0]) {
|
2009-01-04 20:27:34 +00:00
|
|
|
case 's':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "strlen") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setOnlyReadsMemory(F);
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2010-03-16 19:36:43 +00:00
|
|
|
} else if (Name == "strchr" ||
|
|
|
|
Name == "strrchr") {
|
|
|
|
if (FTy->getNumParams() != 2 ||
|
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isIntegerTy())
|
|
|
|
continue;
|
|
|
|
setOnlyReadsMemory(F);
|
|
|
|
setDoesNotThrow(F);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "strcpy" ||
|
|
|
|
Name == "stpcpy" ||
|
|
|
|
Name == "strcat" ||
|
|
|
|
Name == "strtol" ||
|
|
|
|
Name == "strtod" ||
|
|
|
|
Name == "strtof" ||
|
|
|
|
Name == "strtoul" ||
|
|
|
|
Name == "strtoll" ||
|
|
|
|
Name == "strtold" ||
|
|
|
|
Name == "strncat" ||
|
|
|
|
Name == "strncpy" ||
|
|
|
|
Name == "strtoull") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() < 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "strxfrm") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "strcmp" ||
|
|
|
|
Name == "strspn" ||
|
|
|
|
Name == "strncmp" ||
|
2010-03-16 19:36:43 +00:00
|
|
|
Name == "strcspn" ||
|
2009-07-26 07:49:05 +00:00
|
|
|
Name == "strcoll" ||
|
|
|
|
Name == "strcasecmp" ||
|
|
|
|
Name == "strncasecmp") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() < 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setOnlyReadsMemory(F);
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "strstr" ||
|
|
|
|
Name == "strpbrk") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setOnlyReadsMemory(F);
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "strtok" ||
|
|
|
|
Name == "strtok_r") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() < 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "scanf" ||
|
|
|
|
Name == "setbuf" ||
|
|
|
|
Name == "setvbuf") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() < 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "strdup" ||
|
|
|
|
Name == "strndup") {
|
2009-01-05 00:07:50 +00:00
|
|
|
if (FTy->getNumParams() < 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getReturnType()->isPointerTy() ||
|
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-05 00:07:50 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "stat" ||
|
|
|
|
Name == "sscanf" ||
|
|
|
|
Name == "sprintf" ||
|
|
|
|
Name == "statvfs") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() < 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "snprintf") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(2)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 3);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "setitimer") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(2)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
|
|
|
setDoesNotCapture(F, 3);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "system") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
// May throw; "system" is a valid pthread cancellation point.
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-01-04 20:27:34 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'm':
|
2009-09-18 22:35:49 +00:00
|
|
|
if (Name == "malloc") {
|
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getReturnType()->isPointerTy())
|
2009-09-18 22:35:49 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
|
|
|
} else if (Name == "memcmp") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setOnlyReadsMemory(F);
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "memchr" ||
|
|
|
|
Name == "memrchr") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 3)
|
|
|
|
continue;
|
|
|
|
setOnlyReadsMemory(F);
|
|
|
|
setDoesNotThrow(F);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "modf" ||
|
|
|
|
Name == "modff" ||
|
|
|
|
Name == "modfl" ||
|
|
|
|
Name == "memcpy" ||
|
|
|
|
Name == "memccpy" ||
|
|
|
|
Name == "memmove") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() < 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "memalign") {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!FTy->getReturnType()->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotAlias(F, 0);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "mkdir" ||
|
|
|
|
Name == "mktime") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() == 0 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-01-04 20:27:34 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'r':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "realloc") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getReturnType()->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "read") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
// May throw; "read" is a valid pthread cancellation point.
|
2009-01-04 20:27:34 +00:00
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "rmdir" ||
|
|
|
|
Name == "rewind" ||
|
|
|
|
Name == "remove" ||
|
|
|
|
Name == "realpath") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() < 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "rename" ||
|
|
|
|
Name == "readlink") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() < 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'w':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "write") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
// May throw; "write" is a valid pthread cancellation point.
|
2009-01-04 20:27:34 +00:00
|
|
|
setDoesNotCapture(F, 2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'b':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "bcopy") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "bcmp") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setOnlyReadsMemory(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "bzero") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'c':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "calloc") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getReturnType()->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "chmod" ||
|
|
|
|
Name == "chown" ||
|
|
|
|
Name == "ctermid" ||
|
|
|
|
Name == "clearerr" ||
|
|
|
|
Name == "closedir") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() == 0 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'a':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "atoi" ||
|
|
|
|
Name == "atol" ||
|
|
|
|
Name == "atof" ||
|
|
|
|
Name == "atoll") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setOnlyReadsMemory(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "access") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'f':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "fopen") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getReturnType()->isPointerTy() ||
|
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "fdopen") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getReturnType()->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "feof" ||
|
|
|
|
Name == "free" ||
|
|
|
|
Name == "fseek" ||
|
|
|
|
Name == "ftell" ||
|
|
|
|
Name == "fgetc" ||
|
|
|
|
Name == "fseeko" ||
|
|
|
|
Name == "ftello" ||
|
|
|
|
Name == "fileno" ||
|
|
|
|
Name == "fflush" ||
|
|
|
|
Name == "fclose" ||
|
|
|
|
Name == "fsetpos" ||
|
|
|
|
Name == "flockfile" ||
|
|
|
|
Name == "funlockfile" ||
|
|
|
|
Name == "ftrylockfile") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() == 0 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "ferror") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setOnlyReadsMemory(F);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "fputc" ||
|
|
|
|
Name == "fstat" ||
|
|
|
|
Name == "frexp" ||
|
|
|
|
Name == "frexpf" ||
|
|
|
|
Name == "frexpl" ||
|
|
|
|
Name == "fstatvfs") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "fgets") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(2)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 3);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "fread" ||
|
|
|
|
Name == "fwrite") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() != 4 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(3)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 4);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "fputs" ||
|
|
|
|
Name == "fscanf" ||
|
|
|
|
Name == "fprintf" ||
|
|
|
|
Name == "fgetpos") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() < 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'g':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "getc" ||
|
|
|
|
Name == "getlogin_r" ||
|
|
|
|
Name == "getc_unlocked") {
|
2009-01-04 20:27:34 +00:00
|
|
|
if (FTy->getNumParams() == 0 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "getenv") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setOnlyReadsMemory(F);
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "gets" ||
|
|
|
|
Name == "getchar") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
setDoesNotThrow(F);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "getitimer") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "getpwnam") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-01-04 20:27:34 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'u':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "ungetc") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "uname" ||
|
|
|
|
Name == "unlink" ||
|
|
|
|
Name == "unsetenv") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "utime" ||
|
|
|
|
Name == "utimes") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-01-04 20:27:34 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'p':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "putc") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "puts" ||
|
|
|
|
Name == "printf" ||
|
|
|
|
Name == "perror") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "pread" ||
|
|
|
|
Name == "pwrite") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 4 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
// May throw; these are valid pthread cancellation points.
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "putchar") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
setDoesNotThrow(F);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "popen") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getReturnType()->isPointerTy() ||
|
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "pclose") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-01-04 20:27:34 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'v':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "vscanf") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "vsscanf" ||
|
|
|
|
Name == "vfscanf") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(2)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "valloc") {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!FTy->getReturnType()->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "vprintf") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "vfprintf" ||
|
|
|
|
Name == "vsprintf") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "vsnprintf") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 4 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(2)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 3);
|
2009-01-04 20:27:34 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'o':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "open") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() < 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
// May throw; "open" is a valid pthread cancellation point.
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "opendir") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getReturnType()->isPointerTy() ||
|
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
2009-02-15 22:47:25 +00:00
|
|
|
setDoesNotCapture(F, 1);
|
2009-01-04 20:27:34 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 't':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "tmpfile") {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!FTy->getReturnType()->isPointerTy())
|
2009-01-04 20:27:34 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "times") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-01-04 20:27:34 +00:00
|
|
|
}
|
2009-02-15 22:47:25 +00:00
|
|
|
break;
|
2009-01-04 20:27:34 +00:00
|
|
|
case 'h':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "htonl" ||
|
|
|
|
Name == "htons") {
|
2009-01-04 20:27:34 +00:00
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAccessMemory(F);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'n':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "ntohl" ||
|
|
|
|
Name == "ntohs") {
|
2009-01-04 20:27:34 +00:00
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAccessMemory(F);
|
|
|
|
}
|
2009-02-15 22:47:25 +00:00
|
|
|
break;
|
|
|
|
case 'l':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "lstat") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "lchown") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'q':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "qsort") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 4 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(3)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
// May throw; places call through function pointer.
|
|
|
|
setDoesNotCapture(F, 4);
|
|
|
|
}
|
|
|
|
break;
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
case '_':
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "__strdup" ||
|
|
|
|
Name == "__strndup") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() < 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getReturnType()->isPointerTy() ||
|
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "__strtok_r") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 3 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "_IO_getc") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "_IO_putc") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 2);
|
|
|
|
}
|
2009-02-15 22:47:25 +00:00
|
|
|
break;
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
case 1:
|
2009-07-26 07:49:05 +00:00
|
|
|
if (Name == "\1__isoc99_scanf") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() < 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "\1stat64" ||
|
|
|
|
Name == "\1lstat64" ||
|
|
|
|
Name == "\1statvfs64" ||
|
|
|
|
Name == "\1__isoc99_sscanf") {
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
if (FTy->getNumParams() < 1 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "\1fopen64") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getReturnType()->isPointerTy() ||
|
|
|
|
!FTy->getParamType(0)->isPointerTy() ||
|
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
|
|
|
setDoesNotCapture(F, 1);
|
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "\1fseeko64" ||
|
|
|
|
Name == "\1ftello64") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() == 0 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotCapture(F, 1);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "\1tmpfile64") {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!FTy->getReturnType()->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
|
|
|
setDoesNotAlias(F, 0);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "\1fstat64" ||
|
|
|
|
Name == "\1fstatvfs64") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() != 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(1)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
setDoesNotThrow(F);
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
setDoesNotCapture(F, 2);
|
2009-07-26 07:49:05 +00:00
|
|
|
} else if (Name == "\1open64") {
|
2009-02-15 22:47:25 +00:00
|
|
|
if (FTy->getNumParams() < 2 ||
|
2010-02-16 11:11:14 +00:00
|
|
|
!FTy->getParamType(0)->isPointerTy())
|
2009-02-15 22:47:25 +00:00
|
|
|
continue;
|
|
|
|
// May throw; "open" is a valid pthread cancellation point.
|
|
|
|
setDoesNotCapture(F, 1);
|
Fix copy and pasted typos that prevented strtok_r, realloc, getenv, ungetc,
putc, puts, perror, vscanf and vsscanf from getting annotations.
Add annotations for eight printf functions, memalign, pread and pwrite.
On Linux, llvm-gcc sometimes renames strdup, getc, putc, strtok_r, scanf and
sscanf. Match the alternate function names.
Fix a crash annotating opendir.
Don't mark fsetpos's second parameter as nocapture. It's supposed to be
captured.
Do mark fopen's path and mode strings as nocapture. Mark ferror as readonly,
but not fileno which may set errno.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@62456 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-18 04:34:36 +00:00
|
|
|
}
|
2009-01-04 20:27:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Modified;
|
|
|
|
}
|
2008-05-01 06:25:24 +00: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)
|
|
|
|
// * cbrt(sqrt(x)) -> pow(x,1/9)
|
|
|
|
//
|
|
|
|
// cos, cosf, cosl:
|
|
|
|
// * cos(-x) -> cos(x)
|
|
|
|
//
|
|
|
|
// exp, expf, expl:
|
|
|
|
// * exp(log(x)) -> x
|
|
|
|
//
|
|
|
|
// log, logf, logl:
|
|
|
|
// * log(exp(x)) -> x
|
|
|
|
// * log(x**y) -> y*log(x)
|
|
|
|
// * log(exp(y)) -> y*log(e)
|
|
|
|
// * log(exp2(y)) -> y*log(2)
|
|
|
|
// * log(exp10(y)) -> y*log(10)
|
|
|
|
// * log(sqrt(x)) -> 0.5*log(x)
|
|
|
|
// * log(pow(x,y)) -> y*log(x)
|
|
|
|
//
|
|
|
|
// lround, lroundf, lroundl:
|
|
|
|
// * lround(cnst) -> cnst'
|
|
|
|
//
|
|
|
|
// pow, powf, powl:
|
|
|
|
// * pow(exp(x),y) -> exp(x*y)
|
|
|
|
// * pow(sqrt(x),y) -> pow(x,y*0.5)
|
|
|
|
// * pow(pow(x,y),z)-> pow(x,y*z)
|
|
|
|
//
|
|
|
|
// round, roundf, roundl:
|
|
|
|
// * round(cnst) -> cnst'
|
|
|
|
//
|
|
|
|
// signbit:
|
|
|
|
// * signbit(cnst) -> cnst'
|
|
|
|
// * signbit(nncst) -> 0 (if pstv is a non-negative constant)
|
|
|
|
//
|
|
|
|
// sqrt, sqrtf, sqrtl:
|
|
|
|
// * sqrt(expN(x)) -> expN(x*0.5)
|
|
|
|
// * sqrt(Nroot(x)) -> pow(x,1/(2*N))
|
|
|
|
// * sqrt(pow(x,y)) -> pow(|x|,y*0.5)
|
|
|
|
//
|
|
|
|
// stpcpy:
|
|
|
|
// * stpcpy(str, "literal") ->
|
|
|
|
// llvm.memcpy(str,"literal",strlen("literal")+1,1)
|
|
|
|
//
|
|
|
|
// tan, tanf, tanl:
|
|
|
|
// * tan(atan(x)) -> x
|
|
|
|
//
|
|
|
|
// trunc, truncf, truncl:
|
|
|
|
// * trunc(cnst) -> cnst'
|
|
|
|
//
|
|
|
|
//
|