[llvm-commits] [llvm] r158919 - in /llvm/trunk: include/llvm/Analysis/MemoryBuiltins.h lib/Analysis/BasicAliasAnalysis.cpp lib/Analysis/IPA/GlobalsModRef.cpp lib/Analysis/MemoryBuiltins.cpp lib/Analysis/MemoryDependenceAnalysis.cpp lib/Transforms/InstCombine/InstCombineCalls.cpp lib/Transforms/InstCombine/InstructionCombining.cpp lib/Transforms/Scalar/DeadStoreElimination.cpp lib/Transforms/Scalar/GVN.cpp lib/Transforms/Utils/Local.cpp test/Transforms/InstCombine/objsize.ll
Hal Finkel
hfinkel at anl.gov
Wed Jun 27 12:30:54 PDT 2012
Nuno,
I think that something here is broken w.r.t. pointer vectors.
When testing the vectorizer I see errors in the debug output
like this:
ObjectSizeOffsetVisitor unknown instruction: %arrayidx7.v.r1 =
extractelement <2 x double*> %arrayidx7, i32 0
-Hal
On Thu, 21 Jun 2012 15:45:29 -0000
Nuno Lopes <nunoplopes at sapo.pt> wrote:
> Author: nlopes
> Date: Thu Jun 21 10:45:28 2012
> New Revision: 158919
>
> URL: http://llvm.org/viewvc/llvm-project?rev=158919&view=rev
> Log:
> refactor the MemoryBuiltin analysis:
> - provide more extensive set of functions to detect library
> allocation functions (e.g., malloc, calloc, strdup, etc)
> - provide an API to compute the size and offset of an object pointed
> by
>
> Move a few clients (GVN, AA, instcombine, ...) to the new API.
> This implementation is a lot more aggressive than each of the custom
> implementations being replaced.
>
> Patch reviewed by Nick Lewycky and Chandler Carruth, thanks.
>
> Modified:
> llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h
> llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
> llvm/trunk/lib/Analysis/IPA/GlobalsModRef.cpp
> llvm/trunk/lib/Analysis/MemoryBuiltins.cpp
> llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp
> llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp
> llvm/trunk/lib/Transforms/Scalar/GVN.cpp
> llvm/trunk/lib/Transforms/Utils/Local.cpp
> llvm/trunk/test/Transforms/InstCombine/objsize.ll
>
> Modified: llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h (original) +++
> llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h Thu Jun 21 10:45:28
> 2012 @@ -15,6 +15,14 @@ #ifndef LLVM_ANALYSIS_MEMORYBUILTINS_H
> #define LLVM_ANALYSIS_MEMORYBUILTINS_H
>
> +#include "llvm/ADT/DenseMap.h"
> +#include "llvm/ADT/SmallPtrSet.h"
> +#include "llvm/Operator.h"
> +#include "llvm/Support/DataTypes.h"
> +#include "llvm/Support/InstVisitor.h"
> +#include "llvm/Support/IRBuilder.h"
> +#include "llvm/Support/TargetFolder.h"
> +
> namespace llvm {
> class CallInst;
> class PointerType;
> @@ -22,24 +30,50 @@
> class Type;
> class Value;
>
> +
> +/// \brief Tests if a value is a call to a library function that
> allocates or +/// reallocates memory (either malloc, calloc, realloc,
> or strdup like). +bool isAllocationFn(const Value *V, bool
> LookThroughBitCast = false); +
> +/// \brief Tests if a value is a call to a function that returns a
> NoAlias +/// pointer (including malloc/calloc/strdup-like functions).
> +bool isNoAliasFn(const Value *V, bool LookThroughBitCast = false);
> +
> +/// \brief Tests if a value is a call to a library function that
> allocates +/// uninitialized memory (such as malloc).
> +bool isMallocLikeFn(const Value *V, bool LookThroughBitCast = false);
> +
> +/// \brief Tests if a value is a call to a library function that
> allocates +/// zero-filled memory (such as calloc).
> +bool isCallocLikeFn(const Value *V, bool LookThroughBitCast = false);
> +
> +/// \brief Tests if a value is a call to a library function that
> allocates +/// memory (either malloc, calloc, or strdup like).
> +bool isAllocLikeFn(const Value *V, bool LookThroughBitCast = false);
> +
> +/// \brief Tests if a value is a call to a library function that
> reallocates +/// memory (such as realloc).
> +bool isReallocLikeFn(const Value *V, bool LookThroughBitCast =
> false); +
> +
> //===----------------------------------------------------------------------===//
> // malloc Call Utility Functions.
> //
>
> -/// isMalloc - Returns true if the value is either a malloc call or
> a bitcast of -/// the result of a malloc call
> -bool isMalloc(const Value *I);
> -
> /// extractMallocCall - Returns the corresponding CallInst if the
> instruction /// is a malloc call. Since CallInst::CreateMalloc()
> only creates calls, we /// ignore InvokeInst here.
> const CallInst *extractMallocCall(const Value *I);
> -CallInst *extractMallocCall(Value *I);
> +static inline CallInst *extractMallocCall(Value *I) {
> + return const_cast<CallInst*>(extractMallocCall((const Value*)I));
> +}
>
> /// extractMallocCallFromBitCast - Returns the corresponding
> CallInst if the /// instruction is a bitcast of the result of a
> malloc call. const CallInst *extractMallocCallFromBitCast(const Value
> *I); -CallInst *extractMallocCallFromBitCast(Value *I);
> +static inline CallInst *extractMallocCallFromBitCast(Value *I) {
> + return const_cast<CallInst*>(extractMallocCallFromBitCast((const
> Value*)I)); +}
>
> /// isArrayMalloc - Returns the corresponding CallInst if the
> instruction /// is a call to malloc whose array size can be
> determined and the array size @@ -67,7 +101,7 @@
> /// determined.
> Value *getMallocArraySize(CallInst *CI, const TargetData *TD,
> bool LookThroughSExt = false);
> -
> +
>
> //===----------------------------------------------------------------------===//
> // calloc Call Utility Functions.
> @@ -76,7 +110,9 @@
> /// extractCallocCall - Returns the corresponding CallInst if the
> instruction /// is a calloc call.
> const CallInst *extractCallocCall(const Value *I);
> -CallInst *extractCallocCall(Value *I);
> +static inline CallInst *extractCallocCall(Value *I) {
> + return const_cast<CallInst*>(extractCallocCall((const Value*)I));
> +}
>
>
> //===----------------------------------------------------------------------===//
> @@ -90,6 +126,126 @@
> return const_cast<CallInst*>(isFreeCall((const Value*)I));
> }
>
> +
> +//===----------------------------------------------------------------------===//
> +// Utility functions to compute size of objects.
> +//
> +
> +/// \brief Compute the size of the object pointed by Ptr. Returns
> true and the +/// object size in Size if successful, and false
> otherwise. +/// If RoundToAlign is true, then Size is rounded up to
> the aligment of allocas, +/// byval arguments, and global variables.
> +bool getObjectSize(const Value *Ptr, uint64_t &Size, const
> TargetData *TD,
> + bool RoundToAlign = false);
> +
> +
> +
> +typedef std::pair<APInt, APInt> SizeOffsetType;
> +
> +/// \brief Evaluate the size and offset of an object ponted by a
> Value* +/// statically. Fails if size or offset are not known at
> compile time. +class ObjectSizeOffsetVisitor
> + : public InstVisitor<ObjectSizeOffsetVisitor, SizeOffsetType> {
> +
> + const TargetData *TD;
> + bool RoundToAlign;
> + unsigned IntTyBits;
> + APInt Zero;
> +
> + APInt align(APInt Size, uint64_t Align);
> +
> + SizeOffsetType unknown() {
> + return std::make_pair(APInt(), APInt());
> + }
> +
> +public:
> + ObjectSizeOffsetVisitor(const TargetData *TD, LLVMContext &Context,
> + bool RoundToAlign = false);
> +
> + SizeOffsetType compute(Value *V);
> +
> + bool knownSize(SizeOffsetType &SizeOffset) {
> + return SizeOffset.first.getBitWidth() > 1;
> + }
> +
> + bool knownOffset(SizeOffsetType &SizeOffset) {
> + return SizeOffset.second.getBitWidth() > 1;
> + }
> +
> + bool bothKnown(SizeOffsetType &SizeOffset) {
> + return knownSize(SizeOffset) && knownOffset(SizeOffset);
> + }
> +
> + SizeOffsetType visitAllocaInst(AllocaInst &I);
> + SizeOffsetType visitArgument(Argument &A);
> + SizeOffsetType visitCallSite(CallSite CS);
> + SizeOffsetType visitConstantPointerNull(ConstantPointerNull&);
> + SizeOffsetType visitExtractValueInst(ExtractValueInst &I);
> + SizeOffsetType visitGEPOperator(GEPOperator &GEP);
> + SizeOffsetType visitGlobalVariable(GlobalVariable &GV);
> + SizeOffsetType visitIntToPtrInst(IntToPtrInst&);
> + SizeOffsetType visitLoadInst(LoadInst &I);
> + SizeOffsetType visitPHINode(PHINode&);
> + SizeOffsetType visitSelectInst(SelectInst &I);
> + SizeOffsetType visitUndefValue(UndefValue&);
> + SizeOffsetType visitInstruction(Instruction &I);
> +};
> +
> +typedef std::pair<Value*, Value*> SizeOffsetEvalType;
> +typedef IRBuilder<true, TargetFolder> BuilderTy;
> +typedef DenseMap<const Value*, SizeOffsetEvalType> CacheMapTy;
> +typedef SmallPtrSet<const Value*, 8> PtrSetTy;
> +
> +
> +/// \brief Evaluate the size and offset of an object ponted by a
> Value*. +/// May create code to compute the result at run-time.
> +class ObjectSizeOffsetEvaluator
> + : public InstVisitor<ObjectSizeOffsetEvaluator,
> SizeOffsetEvalType> { +
> + const TargetData *TD;
> + LLVMContext &Context;
> + BuilderTy Builder;
> + ObjectSizeOffsetVisitor Visitor;
> + IntegerType *IntTy;
> + Value *Zero;
> + CacheMapTy CacheMap;
> + PtrSetTy SeenVals;
> +
> + SizeOffsetEvalType unknown() {
> + return std::make_pair((Value*)0, (Value*)0);
> + }
> + SizeOffsetEvalType compute_(Value *V);
> +
> +public:
> + ObjectSizeOffsetEvaluator(const TargetData *TD, LLVMContext
> &Context);
> + SizeOffsetEvalType compute(Value *V);
> +
> + bool knownSize(SizeOffsetEvalType &SizeOffset) {
> + return SizeOffset.first;
> + }
> +
> + bool knownOffset(SizeOffsetEvalType &SizeOffset) {
> + return SizeOffset.second;
> + }
> +
> + bool anyKnown(SizeOffsetEvalType &SizeOffset) {
> + return knownSize(SizeOffset) || knownOffset(SizeOffset);
> + }
> +
> + bool bothKnown(SizeOffsetEvalType &SizeOffset) {
> + return knownSize(SizeOffset) && knownOffset(SizeOffset);
> + }
> +
> + SizeOffsetEvalType visitAllocaInst(AllocaInst &I);
> + SizeOffsetEvalType visitCallSite(CallSite CS);
> + SizeOffsetEvalType visitGEPOperator(GEPOperator &GEP);
> + SizeOffsetEvalType visitIntToPtrInst(IntToPtrInst&);
> + SizeOffsetEvalType visitLoadInst(LoadInst &I);
> + SizeOffsetEvalType visitPHINode(PHINode &PHI);
> + SizeOffsetEvalType visitSelectInst(SelectInst &I);
> + SizeOffsetEvalType visitInstruction(Instruction &I);
> +};
> +
> } // End llvm namespace
>
> #endif
>
> Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original) +++
> llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Thu Jun 21 10:45:28
> 2012 @@ -86,47 +86,10 @@ /// UnknownSize if unknown.
> static uint64_t getObjectSize(const Value *V, const TargetData &TD,
> bool RoundToAlign = false) {
> - Type *AccessTy;
> - unsigned Align;
> - if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
> - if (!GV->hasDefinitiveInitializer())
> - return AliasAnalysis::UnknownSize;
> - AccessTy = GV->getType()->getElementType();
> - Align = GV->getAlignment();
> - } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
> - if (!AI->isArrayAllocation())
> - AccessTy = AI->getType()->getElementType();
> - else
> - return AliasAnalysis::UnknownSize;
> - Align = AI->getAlignment();
> - } else if (const CallInst* CI = extractMallocCall(V)) {
> - if (!RoundToAlign && !isArrayMalloc(V, &TD))
> - // The size is the argument to the malloc call.
> - if (const ConstantInt* C =
> dyn_cast<ConstantInt>(CI->getArgOperand(0)))
> - return C->getZExtValue();
> - return AliasAnalysis::UnknownSize;
> - } else if (const Argument *A = dyn_cast<Argument>(V)) {
> - if (A->hasByValAttr()) {
> - AccessTy = cast<PointerType>(A->getType())->getElementType();
> - Align = A->getParamAlignment();
> - } else {
> - return AliasAnalysis::UnknownSize;
> - }
> - } else {
> - return AliasAnalysis::UnknownSize;
> - }
> -
> - if (!AccessTy->isSized())
> - return AliasAnalysis::UnknownSize;
> -
> - uint64_t Size = TD.getTypeAllocSize(AccessTy);
> - // If there is an explicitly specified alignment, and we need to
> - // take alignment into account, round up the size. (If the
> alignment
> - // is implicit, getTypeAllocSize is sufficient.)
> - if (RoundToAlign && Align)
> - Size = RoundUpToAlignment(Size, Align);
> -
> - return Size;
> + uint64_t Size;
> + if (getObjectSize(V, Size, &TD, RoundToAlign))
> + return Size;
> + return AliasAnalysis::UnknownSize;
> }
>
> /// isObjectSmallerThan - Return true if we can prove that the
> object specified
>
> Modified: llvm/trunk/lib/Analysis/IPA/GlobalsModRef.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/IPA/GlobalsModRef.cpp?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/IPA/GlobalsModRef.cpp (original) +++
> llvm/trunk/lib/Analysis/IPA/GlobalsModRef.cpp Thu Jun 21 10:45:28
> 2012 @@ -329,15 +329,8 @@ // Check the value being stored.
> Value *Ptr = GetUnderlyingObject(SI->getOperand(0));
>
> - if (isMalloc(Ptr)) {
> - // Okay, easy case.
> - } else if (CallInst *CI = dyn_cast<CallInst>(Ptr)) {
> - Function *F = CI->getCalledFunction();
> - if (!F || !F->isDeclaration()) return false; // Too hard
> to analyze.
> - if (F->getName() != "calloc") return false; // Not calloc.
> - } else {
> + if (!isAllocLikeFn(Ptr))
> return false; // Too hard to analyze.
> - }
>
> // Analyze all uses of the allocation. If any of them are
> used in a // non-simple way (e.g. stored to another global) bail out.
> @@ -454,19 +447,18 @@
> for (inst_iterator II = inst_begin(SCC[i]->getFunction()),
> E = inst_end(SCC[i]->getFunction());
> II != E && FunctionEffect != ModRef; ++II)
> - if (isa<LoadInst>(*II)) {
> + if (LoadInst *LI = dyn_cast<LoadInst>(&*II)) {
> FunctionEffect |= Ref;
> - if (cast<LoadInst>(*II).isVolatile())
> + if (LI->isVolatile())
> // Volatile loads may have side-effects, so mark them as
> writing // memory (for example, a flag inside the processor).
> FunctionEffect |= Mod;
> - } else if (isa<StoreInst>(*II)) {
> + } else if (StoreInst *SI = dyn_cast<StoreInst>(&*II)) {
> FunctionEffect |= Mod;
> - if (cast<StoreInst>(*II).isVolatile())
> + if (SI->isVolatile())
> // Treat volatile stores as reading memory somewhere.
> FunctionEffect |= Ref;
> - } else if (isMalloc(&cast<Instruction>(*II)) ||
> - isFreeCall(&cast<Instruction>(*II))) {
> + } else if (isAllocationFn(&*II) || isFreeCall(&*II)) {
> FunctionEffect |= ModRef;
> } else if (IntrinsicInst *Intrinsic =
> dyn_cast<IntrinsicInst>(&*II)) { // The callgraph doesn't include
> intrinsic calls.
>
> Modified: llvm/trunk/lib/Analysis/MemoryBuiltins.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryBuiltins.cpp?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/MemoryBuiltins.cpp (original) +++
> llvm/trunk/lib/Analysis/MemoryBuiltins.cpp Thu Jun 21 10:45:28 2012
> @@ -12,80 +12,165 @@ //
> //===----------------------------------------------------------------------===//
>
> +#define DEBUG_TYPE "memory-builtins"
> +#include "llvm/ADT/Statistic.h"
> +#include "llvm/ADT/STLExtras.h"
> #include "llvm/Analysis/MemoryBuiltins.h"
> -#include "llvm/Constants.h"
> +#include "llvm/GlobalVariable.h"
> #include "llvm/Instructions.h"
> +#include "llvm/Intrinsics.h"
> +#include "llvm/Metadata.h"
> #include "llvm/Module.h"
> #include "llvm/Analysis/ValueTracking.h"
> +#include "llvm/Support/Debug.h"
> +#include "llvm/Support/MathExtras.h"
> +#include "llvm/Support/raw_ostream.h"
> #include "llvm/Target/TargetData.h"
> +#include "llvm/Transforms/Utils/Local.h"
> using namespace llvm;
>
> -//===----------------------------------------------------------------------===//
> -// malloc Call Utility Functions.
> -//
> +enum AllocType {
> + MallocLike = 1<<0, // allocates
> + CallocLike = 1<<1, // allocates + bzero
> + ReallocLike = 1<<2, // reallocates
> + StrDupLike = 1<<3,
> + AllocLike = MallocLike | CallocLike | StrDupLike,
> + AnyAlloc = MallocLike | CallocLike | ReallocLike |
> StrDupLike +};
> +
> +struct AllocFnsTy {
> + const char *Name;
> + AllocType AllocTy;
> + unsigned char NumParams;
> + // First and Second size parameters (or -1 if unused)
> + unsigned char FstParam, SndParam;
> +};
> +
> +static const AllocFnsTy AllocationFnData[] = {
> + {"malloc", MallocLike, 1, 0, -1},
> + {"valloc", MallocLike, 1, 0, -1},
> + {"_Znwj", MallocLike, 1, 0, -1}, // operator
> new(unsigned int)
> + {"_Znwm", MallocLike, 1, 0, -1}, // operator
> new(unsigned long)
> + {"_Znaj", MallocLike, 1, 0, -1}, // operator
> new[](unsigned int)
> + {"_Znam", MallocLike, 1, 0, -1}, // operator
> new[](unsigned long)
> + {"posix_memalign", MallocLike, 3, 2, -1},
> + {"calloc", CallocLike, 2, 0, 1},
> + {"realloc", ReallocLike, 2, 1, -1},
> + {"reallocf", ReallocLike, 2, 1, -1},
> + {"strdup", StrDupLike, 1, -1, -1},
> + {"strndup", StrDupLike, 2, -1, -1}
> +};
> +
> +
> +static Function *getCalledFunction(const Value *V, bool
> LookThroughBitCast) {
> + if (LookThroughBitCast)
> + V = V->stripPointerCasts();
> + const CallInst *CI = dyn_cast<CallInst>(V);
> + if (!CI)
> + return 0;
>
> -/// isMalloc - Returns true if the value is either a malloc call or a
> -/// bitcast of the result of a malloc call.
> -bool llvm::isMalloc(const Value *I) {
> - return extractMallocCall(I) || extractMallocCallFromBitCast(I);
> + Function *Callee = CI->getCalledFunction();
> + if (!Callee || !Callee->isDeclaration())
> + return 0;
> + return Callee;
> }
>
> -static bool isMallocCall(const CallInst *CI) {
> - if (!CI)
> - return false;
> +/// \brief Returns the allocation data for the given value if it is
> a call to a +/// known allocation function, and NULL otherwise.
> +static const AllocFnsTy *getAllocationData(const Value *V, AllocType
> AllocTy,
> + bool LookThroughBitCast =
> false) {
> + Function *Callee = getCalledFunction(V, LookThroughBitCast);
> + if (!Callee)
> + return 0;
>
> - Function *Callee = CI->getCalledFunction();
> - if (Callee == 0 || !Callee->isDeclaration())
> - return false;
> - if (Callee->getName() != "malloc" &&
> - Callee->getName() != "_Znwj" && // operator new(unsigned int)
> - Callee->getName() != "_Znwm" && // operator new(unsigned long)
> - Callee->getName() != "_Znaj" && // operator new[](unsigned int)
> - Callee->getName() != "_Znam") // operator new[](unsigned
> long)
> - return false;
> + unsigned i = 0;
> + bool found = false;
> + for ( ; i < array_lengthof(AllocationFnData); ++i) {
> + if (Callee->getName() == AllocationFnData[i].Name) {
> + found = true;
> + break;
> + }
> + }
> + if (!found)
> + return 0;
>
> - // Check malloc prototype.
> - // FIXME: workaround for PR5130, this will be obsolete when a
> nobuiltin
> - // attribute will exist.
> + const AllocFnsTy *FnData = &AllocationFnData[i];
> + if ((FnData->AllocTy & AllocTy) == 0)
> + return 0;
> +
> + // Check function prototype.
> + // FIXME: Check the nobuiltin metadata?? (PR5130)
> + unsigned FstParam = FnData->FstParam;
> + unsigned SndParam = FnData->SndParam;
> FunctionType *FTy = Callee->getFunctionType();
> - return FTy->getReturnType() ==
> Type::getInt8PtrTy(FTy->getContext()) &&
> - FTy->getNumParams() == 1 &&
> - (FTy->getParamType(0)->isIntegerTy(32) ||
> - FTy->getParamType(0)->isIntegerTy(64));
> +
> + if (FTy->getReturnType() == Type::getInt8PtrTy(FTy->getContext())
> &&
> + FTy->getNumParams() == FnData->NumParams &&
> + (FstParam == (unsigned char)-1 ||
> + (FTy->getParamType(FstParam)->isIntegerTy(32) ||
> + FTy->getParamType(FstParam)->isIntegerTy(64))) &&
> + (SndParam == (unsigned char)-1 ||
> + FTy->getParamType(SndParam)->isIntegerTy(32) ||
> + FTy->getParamType(SndParam)->isIntegerTy(64)))
> + return FnData;
> + return 0;
> }
>
> -/// extractMallocCall - Returns the corresponding CallInst if the
> instruction -/// is a malloc call. Since CallInst::CreateMalloc()
> only creates calls, we -/// ignore InvokeInst here.
> -const CallInst *llvm::extractMallocCall(const Value *I) {
> - const CallInst *CI = dyn_cast<CallInst>(I);
> - return (isMallocCall(CI)) ? CI : NULL;
> +static bool hasNoAliasAttr(const Value *V, bool LookThroughBitCast) {
> + Function *Callee = getCalledFunction(V, LookThroughBitCast);
> + return Callee && Callee->hasFnAttr(Attribute::NoAlias);
> }
>
> -CallInst *llvm::extractMallocCall(Value *I) {
> - CallInst *CI = dyn_cast<CallInst>(I);
> - return (isMallocCall(CI)) ? CI : NULL;
> +
> +/// \brief Tests if a value is a call to a library function that
> allocates or +/// reallocates memory (either malloc, calloc, realloc,
> or strdup like). +bool llvm::isAllocationFn(const Value *V, bool
> LookThroughBitCast) {
> + return getAllocationData(V, AnyAlloc, LookThroughBitCast);
> }
>
> -static bool isBitCastOfMallocCall(const BitCastInst *BCI) {
> - if (!BCI)
> - return false;
> -
> - return isMallocCall(dyn_cast<CallInst>(BCI->getOperand(0)));
> +/// \brief Tests if a value is a call to a function that returns a
> NoAlias +/// pointer (including malloc/calloc/strdup-like functions).
> +bool llvm::isNoAliasFn(const Value *V, bool LookThroughBitCast) {
> + return isAllocLikeFn(V, LookThroughBitCast) ||
> + hasNoAliasAttr(V, LookThroughBitCast);
> }
>
> -/// extractMallocCallFromBitCast - Returns the corresponding
> CallInst if the -/// instruction is a bitcast of the result of a
> malloc call. -CallInst *llvm::extractMallocCallFromBitCast(Value *I) {
> - BitCastInst *BCI = dyn_cast<BitCastInst>(I);
> - return (isBitCastOfMallocCall(BCI)) ?
> cast<CallInst>(BCI->getOperand(0))
> - : NULL;
> +/// \brief Tests if a value is a call to a library function that
> allocates +/// uninitialized memory (such as malloc).
> +bool llvm::isMallocLikeFn(const Value *V, bool LookThroughBitCast) {
> + return getAllocationData(V, MallocLike, LookThroughBitCast);
> +}
> +
> +/// \brief Tests if a value is a call to a library function that
> allocates +/// zero-filled memory (such as calloc).
> +bool llvm::isCallocLikeFn(const Value *V, bool LookThroughBitCast) {
> + return getAllocationData(V, CallocLike, LookThroughBitCast);
> +}
> +
> +/// \brief Tests if a value is a call to a library function that
> allocates +/// memory (either malloc, calloc, or strdup like).
> +bool llvm::isAllocLikeFn(const Value *V, bool LookThroughBitCast) {
> + return getAllocationData(V, AllocLike, LookThroughBitCast);
> }
>
> +/// \brief Tests if a value is a call to a library function that
> reallocates +/// memory (such as realloc).
> +bool llvm::isReallocLikeFn(const Value *V, bool LookThroughBitCast) {
> + return getAllocationData(V, ReallocLike, LookThroughBitCast);
> +}
> +
> +/// extractMallocCall - Returns the corresponding CallInst if the
> instruction +/// is a malloc call. Since CallInst::CreateMalloc()
> only creates calls, we +/// ignore InvokeInst here.
> +const CallInst *llvm::extractMallocCall(const Value *I) {
> + return isMallocLikeFn(I) ? cast<CallInst>(I) : 0;
> +}
> +
> +/// extractMallocCallFromBitCast - Returns the corresponding
> CallInst if the +/// instruction is a bitcast of the result of a
> malloc call. const CallInst *llvm::extractMallocCallFromBitCast(const
> Value *I) { const BitCastInst *BCI = dyn_cast<BitCastInst>(I);
> - return (isBitCastOfMallocCall(BCI)) ?
> cast<CallInst>(BCI->getOperand(0))
> - : NULL;
> + return BCI ? extractMallocCall(BCI->getOperand(0)) : 0;
> }
>
> static Value *computeArraySize(const CallInst *CI, const TargetData
> *TD, @@ -134,7 +219,7 @@
> /// 1: PointerType is the bitcast's result type.
> /// >1: Unique PointerType cannot be determined, return NULL.
> PointerType *llvm::getMallocType(const CallInst *CI) {
> - assert(isMalloc(CI) && "getMallocType and not malloc call");
> + assert(isMallocLikeFn(CI) && "getMallocType and not malloc call");
>
> PointerType *MallocType = NULL;
> unsigned NumOfBitCastUses = 0;
> @@ -176,53 +261,17 @@
> /// determined.
> Value *llvm::getMallocArraySize(CallInst *CI, const TargetData *TD,
> bool LookThroughSExt) {
> - assert(isMalloc(CI) && "getMallocArraySize and not malloc call");
> + assert(isMallocLikeFn(CI) && "getMallocArraySize and not malloc
> call"); return computeArraySize(CI, TD, LookThroughSExt);
> }
>
>
> -//===----------------------------------------------------------------------===//
> -// calloc Call Utility Functions.
> -//
> -
> -static bool isCallocCall(const CallInst *CI) {
> - if (!CI)
> - return false;
> -
> - Function *Callee = CI->getCalledFunction();
> - if (Callee == 0 || !Callee->isDeclaration())
> - return false;
> - if (Callee->getName() != "calloc")
> - return false;
> -
> - // Check malloc prototype.
> - // FIXME: workaround for PR5130, this will be obsolete when a
> nobuiltin
> - // attribute exists.
> - FunctionType *FTy = Callee->getFunctionType();
> - return FTy->getReturnType() ==
> Type::getInt8PtrTy(FTy->getContext()) &&
> - FTy->getNumParams() == 2 &&
> - ((FTy->getParamType(0)->isIntegerTy(32) &&
> - FTy->getParamType(1)->isIntegerTy(32)) ||
> - (FTy->getParamType(0)->isIntegerTy(64) &&
> - FTy->getParamType(1)->isIntegerTy(64)));
> -}
> -
> /// extractCallocCall - Returns the corresponding CallInst if the
> instruction /// is a calloc call.
> const CallInst *llvm::extractCallocCall(const Value *I) {
> - const CallInst *CI = dyn_cast<CallInst>(I);
> - return isCallocCall(CI) ? CI : 0;
> + return isCallocLikeFn(I) ? cast<CallInst>(I) : 0;
> }
>
> -CallInst *llvm::extractCallocCall(Value *I) {
> - CallInst *CI = dyn_cast<CallInst>(I);
> - return isCallocCall(CI) ? CI : 0;
> -}
> -
> -
> -//===----------------------------------------------------------------------===//
> -// free Call Utility Functions.
> -//
>
> /// isFreeCall - Returns non-null if the value is a call to the
> builtin free() const CallInst *llvm::isFreeCall(const Value *I) {
> @@ -251,3 +300,388 @@
>
> return CI;
> }
> +
> +
> +
> +//===----------------------------------------------------------------------===//
> +// Utility functions to compute size of objects.
> +//
> +
> +
> +/// \brief Compute the size of the object pointed by Ptr. Returns
> true and the +/// object size in Size if successful, and false
> otherwise. +/// If RoundToAlign is true, then Size is rounded up to
> the aligment of allocas, +/// byval arguments, and global variables.
> +bool llvm::getObjectSize(const Value *Ptr, uint64_t &Size, const
> TargetData *TD,
> + bool RoundToAlign) {
> + if (!TD)
> + return false;
> +
> + ObjectSizeOffsetVisitor Visitor(TD, Ptr->getContext(),
> RoundToAlign);
> + SizeOffsetType Data = Visitor.compute(const_cast<Value*>(Ptr));
> + if (!Visitor.bothKnown(Data))
> + return false;
> +
> + APInt ObjSize = Data.first, Offset = Data.second;
> + // check for overflow
> + if (Offset.slt(0) || ObjSize.ult(Offset))
> + Size = 0;
> + else
> + Size = (ObjSize - Offset).getZExtValue();
> + return true;
> +}
> +
> +
> +STATISTIC(ObjectVisitorArgument,
> + "Number of arguments with unsolved size and offset");
> +STATISTIC(ObjectVisitorLoad,
> + "Number of load instructions with unsolved size and
> offset"); +
> +
> +APInt ObjectSizeOffsetVisitor::align(APInt Size, uint64_t Align) {
> + if (RoundToAlign && Align)
> + return APInt(IntTyBits, RoundUpToAlignment(Size.getZExtValue(),
> Align));
> + return Size;
> +}
> +
> +ObjectSizeOffsetVisitor::ObjectSizeOffsetVisitor(const TargetData
> *TD,
> + LLVMContext
> &Context,
> + bool RoundToAlign)
> +: TD(TD), RoundToAlign(RoundToAlign) {
> + IntegerType *IntTy = TD->getIntPtrType(Context);
> + IntTyBits = IntTy->getBitWidth();
> + Zero = APInt::getNullValue(IntTyBits);
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::compute(Value *V) {
> + V = V->stripPointerCasts();
> +
> + if (GEPOperator *GEP = dyn_cast<GEPOperator>(V))
> + return visitGEPOperator(*GEP);
> + if (Instruction *I = dyn_cast<Instruction>(V))
> + return visit(*I);
> + if (Argument *A = dyn_cast<Argument>(V))
> + return visitArgument(*A);
> + if (ConstantPointerNull *P = dyn_cast<ConstantPointerNull>(V))
> + return visitConstantPointerNull(*P);
> + if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
> + return visitGlobalVariable(*GV);
> + if (UndefValue *UV = dyn_cast<UndefValue>(V))
> + return visitUndefValue(*UV);
> + if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
> + if (CE->getOpcode() == Instruction::IntToPtr)
> + return unknown(); // clueless
> +
> + DEBUG(dbgs() << "ObjectSizeOffsetVisitor::compute() unhandled
> value: " << *V
> + << '\n');
> + return unknown();
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::visitAllocaInst(AllocaInst
> &I) {
> + if (!I.getAllocatedType()->isSized())
> + return unknown();
> +
> + APInt Size(IntTyBits, TD->getTypeAllocSize(I.getAllocatedType()));
> + if (!I.isArrayAllocation())
> + return std::make_pair(align(Size, I.getAlignment()), Zero);
> +
> + Value *ArraySize = I.getArraySize();
> + if (const ConstantInt *C = dyn_cast<ConstantInt>(ArraySize)) {
> + Size *= C->getValue().zextOrSelf(IntTyBits);
> + return std::make_pair(align(Size, I.getAlignment()), Zero);
> + }
> + return unknown();
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::visitArgument(Argument &A) {
> + // no interprocedural analysis is done at the moment
> + if (!A.hasByValAttr()) {
> + ++ObjectVisitorArgument;
> + return unknown();
> + }
> + PointerType *PT = cast<PointerType>(A.getType());
> + APInt Size(IntTyBits, TD->getTypeAllocSize(PT->getElementType()));
> + return std::make_pair(align(Size, A.getParamAlignment()), Zero);
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::visitCallSite(CallSite CS) {
> + const AllocFnsTy *FnData = getAllocationData(CS.getInstruction(),
> AnyAlloc);
> + if (!FnData)
> + return unknown();
> +
> + // handle strdup-like functions separately
> + if (FnData->AllocTy == StrDupLike) {
> + // TODO
> + return unknown();
> + }
> +
> + ConstantInt *Arg =
> dyn_cast<ConstantInt>(CS.getArgument(FnData->FstParam));
> + if (!Arg)
> + return unknown();
> +
> + APInt Size = Arg->getValue();
> + // size determined by just 1 parameter
> + if (FnData->SndParam == (unsigned char)-1)
> + return std::make_pair(Size, Zero);
> +
> + Arg = dyn_cast<ConstantInt>(CS.getArgument(FnData->SndParam));
> + if (!Arg)
> + return unknown();
> +
> + Size *= Arg->getValue();
> + return std::make_pair(Size, Zero);
> +
> + // TODO: handle more standard functions (+ wchar cousins):
> + // - strdup / strndup
> + // - strcpy / strncpy
> + // - strcat / strncat
> + // - memcpy / memmove
> + // - strcat / strncat
> + // - memset
> +}
> +
> +SizeOffsetType
> +ObjectSizeOffsetVisitor::visitConstantPointerNull(ConstantPointerNull&)
> {
> + return std::make_pair(Zero, Zero);
> +}
> +
> +SizeOffsetType
> +ObjectSizeOffsetVisitor::visitExtractValueInst(ExtractValueInst&) {
> + // Easy cases were already folded by previous passes.
> + return unknown();
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::visitGEPOperator(GEPOperator
> &GEP) {
> + SizeOffsetType PtrData = compute(GEP.getPointerOperand());
> + if (!bothKnown(PtrData) || !GEP.hasAllConstantIndices())
> + return unknown();
> +
> + SmallVector<Value*, 8> Ops(GEP.idx_begin(), GEP.idx_end());
> + APInt
> Offset(IntTyBits,TD->getIndexedOffset(GEP.getPointerOperandType(),Ops));
> + return std::make_pair(PtrData.first, PtrData.second + Offset);
> +}
> +
> +SizeOffsetType
> ObjectSizeOffsetVisitor::visitGlobalVariable(GlobalVariable &GV){
> + if (!GV.hasDefinitiveInitializer())
> + return unknown();
> +
> + APInt Size(IntTyBits,
> TD->getTypeAllocSize(GV.getType()->getElementType()));
> + return std::make_pair(align(Size, GV.getAlignment()), Zero);
> +}
> +
> +SizeOffsetType
> ObjectSizeOffsetVisitor::visitIntToPtrInst(IntToPtrInst&) {
> + // clueless
> + return unknown();
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::visitLoadInst(LoadInst&) {
> + ++ObjectVisitorLoad;
> + return unknown();
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::visitPHINode(PHINode&) {
> + // too complex to analyze statically.
> + return unknown();
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::visitSelectInst(SelectInst
> &I) {
> + SizeOffsetType TrueSide = compute(I.getTrueValue());
> + SizeOffsetType FalseSide = compute(I.getFalseValue());
> + if (bothKnown(TrueSide) && bothKnown(FalseSide) && TrueSide ==
> FalseSide)
> + return TrueSide;
> + return unknown();
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::visitUndefValue(UndefValue&)
> {
> + return std::make_pair(Zero, Zero);
> +}
> +
> +SizeOffsetType ObjectSizeOffsetVisitor::visitInstruction(Instruction
> &I) {
> + DEBUG(dbgs() << "ObjectSizeOffsetVisitor unknown instruction:" <<
> I << '\n');
> + return unknown();
> +}
> +
> +
> +ObjectSizeOffsetEvaluator::ObjectSizeOffsetEvaluator(const
> TargetData *TD,
> + LLVMContext
> &Context) +: TD(TD), Context(Context), Builder(Context,
> TargetFolder(TD)), +Visitor(TD, Context) {
> + IntTy = TD->getIntPtrType(Context);
> + Zero = ConstantInt::get(IntTy, 0);
> +}
> +
> +SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute(Value *V) {
> + SizeOffsetEvalType Result = compute_(V);
> +
> + if (!bothKnown(Result)) {
> + // erase everything that was computed in this iteration from the
> cache, so
> + // that no dangling references are left behind. We could be a
> bit smarter if
> + // we kept a dependency graph. It's probably not worth the
> complexity.
> + for (PtrSetTy::iterator I=SeenVals.begin(), E=SeenVals.end();
> I != E; ++I) {
> + CacheMapTy::iterator CacheIt = CacheMap.find(*I);
> + // non-computable results can be safely cached
> + if (CacheIt != CacheMap.end() && anyKnown(CacheIt->second))
> + CacheMap.erase(CacheIt);
> + }
> + }
> +
> + SeenVals.clear();
> + return Result;
> +}
> +
> +SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute_(Value *V) {
> + SizeOffsetType Const = Visitor.compute(V);
> + if (Visitor.bothKnown(Const))
> + return std::make_pair(ConstantInt::get(Context, Const.first),
> + ConstantInt::get(Context, Const.second));
> +
> + V = V->stripPointerCasts();
> +
> + // check cache
> + CacheMapTy::iterator CacheIt = CacheMap.find(V);
> + if (CacheIt != CacheMap.end())
> + return CacheIt->second;
> +
> + // always generate code immediately before the instruction being
> + // processed, so that the generated code dominates the same BBs
> + Instruction *PrevInsertPoint = Builder.GetInsertPoint();
> + if (Instruction *I = dyn_cast<Instruction>(V))
> + Builder.SetInsertPoint(I);
> +
> + // record the pointers that were handled in this run, so that they
> can be
> + // cleaned later if something fails
> + SeenVals.insert(V);
> +
> + // now compute the size and offset
> + SizeOffsetEvalType Result;
> + if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
> + Result = visitGEPOperator(*GEP);
> + } else if (Instruction *I = dyn_cast<Instruction>(V)) {
> + Result = visit(*I);
> + } else if (isa<Argument>(V) ||
> + (isa<ConstantExpr>(V) &&
> + cast<ConstantExpr>(V)->getOpcode() ==
> Instruction::IntToPtr) ||
> + isa<GlobalVariable>(V)) {
> + // ignore values where we cannot do more than what
> ObjectSizeVisitor can
> + Result = unknown();
> + } else {
> + DEBUG(dbgs() << "ObjectSizeOffsetEvaluator::compute() unhandled
> value: "
> + << *V << '\n');
> + Result = unknown();
> + }
> +
> + if (PrevInsertPoint)
> + Builder.SetInsertPoint(PrevInsertPoint);
> +
> + // Don't reuse CacheIt since it may be invalid at this point.
> + CacheMap[V] = Result;
> + return Result;
> +}
> +
> +SizeOffsetEvalType
> ObjectSizeOffsetEvaluator::visitAllocaInst(AllocaInst &I) {
> + if (!I.getAllocatedType()->isSized())
> + return unknown();
> +
> + // must be a VLA
> + assert(I.isArrayAllocation());
> + Value *ArraySize = I.getArraySize();
> + Value *Size = ConstantInt::get(ArraySize->getType(),
> +
> TD->getTypeAllocSize(I.getAllocatedType()));
> + Size = Builder.CreateMul(Size, ArraySize);
> + return std::make_pair(Size, Zero);
> +}
> +
> +SizeOffsetEvalType ObjectSizeOffsetEvaluator::visitCallSite(CallSite
> CS) {
> + const AllocFnsTy *FnData = getAllocationData(CS.getInstruction(),
> AnyAlloc);
> + if (!FnData)
> + return unknown();
> +
> + // handle strdup-like functions separately
> + if (FnData->AllocTy == StrDupLike) {
> + // TODO
> + return unknown();
> + }
> +
> + Value *FirstArg = CS.getArgument(FnData->FstParam);
> + if (FnData->SndParam == (unsigned char)-1)
> + return std::make_pair(FirstArg, Zero);
> +
> + Value *SecondArg = CS.getArgument(FnData->SndParam);
> + Value *Size = Builder.CreateMul(FirstArg, SecondArg);
> + return std::make_pair(Size, Zero);
> +
> + // TODO: handle more standard functions (+ wchar cousins):
> + // - strdup / strndup
> + // - strcpy / strncpy
> + // - strcat / strncat
> + // - memcpy / memmove
> + // - strcat / strncat
> + // - memset
> +}
> +
> +SizeOffsetEvalType
> +ObjectSizeOffsetEvaluator::visitGEPOperator(GEPOperator &GEP) {
> + SizeOffsetEvalType PtrData = compute_(GEP.getPointerOperand());
> + if (!bothKnown(PtrData))
> + return unknown();
> +
> + Value *Offset = EmitGEPOffset(&Builder, *TD, &GEP);
> + Offset = Builder.CreateAdd(PtrData.second, Offset);
> + return std::make_pair(PtrData.first, Offset);
> +}
> +
> +SizeOffsetEvalType
> ObjectSizeOffsetEvaluator::visitIntToPtrInst(IntToPtrInst&) {
> + // clueless
> + return unknown();
> +}
> +
> +SizeOffsetEvalType
> ObjectSizeOffsetEvaluator::visitLoadInst(LoadInst&) {
> + return unknown();
> +}
> +
> +SizeOffsetEvalType ObjectSizeOffsetEvaluator::visitPHINode(PHINode
> &PHI) {
> + // create 2 PHIs: one for size and another for offset
> + PHINode *SizePHI = Builder.CreatePHI(IntTy,
> PHI.getNumIncomingValues());
> + PHINode *OffsetPHI = Builder.CreatePHI(IntTy,
> PHI.getNumIncomingValues()); +
> + // insert right away in the cache to handle recursive PHIs
> + CacheMap[&PHI] = std::make_pair(SizePHI, OffsetPHI);
> +
> + // compute offset/size for each PHI incoming pointer
> + for (unsigned i = 0, e = PHI.getNumIncomingValues(); i != e; ++i) {
> +
> Builder.SetInsertPoint(PHI.getIncomingBlock(i)->getFirstInsertionPt());
> + SizeOffsetEvalType EdgeData = compute_(PHI.getIncomingValue(i));
> +
> + if (!bothKnown(EdgeData)) {
> + OffsetPHI->replaceAllUsesWith(UndefValue::get(IntTy));
> + OffsetPHI->eraseFromParent();
> + SizePHI->replaceAllUsesWith(UndefValue::get(IntTy));
> + SizePHI->eraseFromParent();
> + return unknown();
> + }
> + SizePHI->addIncoming(EdgeData.first, PHI.getIncomingBlock(i));
> + OffsetPHI->addIncoming(EdgeData.second, PHI.getIncomingBlock(i));
> + }
> + return std::make_pair(SizePHI, OffsetPHI);
> +}
> +
> +SizeOffsetEvalType
> ObjectSizeOffsetEvaluator::visitSelectInst(SelectInst &I) {
> + SizeOffsetEvalType TrueSide = compute_(I.getTrueValue());
> + SizeOffsetEvalType FalseSide = compute_(I.getFalseValue());
> +
> + if (!bothKnown(TrueSide) || !bothKnown(FalseSide))
> + return unknown();
> + if (TrueSide == FalseSide)
> + return TrueSide;
> +
> + Value *Size = Builder.CreateSelect(I.getCondition(),
> TrueSide.first,
> + FalseSide.first);
> + Value *Offset = Builder.CreateSelect(I.getCondition(),
> TrueSide.second,
> + FalseSide.second);
> + return std::make_pair(Size, Offset);
> +}
> +
> +SizeOffsetEvalType
> ObjectSizeOffsetEvaluator::visitInstruction(Instruction &I) {
> + DEBUG(dbgs() << "ObjectSizeOffsetEvaluator unknown instruction:"
> << I <<'\n');
> + return unknown();
> +}
>
> Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
> +++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Thu Jun 21
> 10:45:28 2012 @@ -474,8 +474,7 @@ // a subsequent bitcast of the
> malloc call result. There can be stores to // the malloced memory
> between the malloc call and its bitcast uses, and we // need to
> continue scanning until the malloc call.
> - if (isa<AllocaInst>(Inst) ||
> - (isa<CallInst>(Inst) && extractMallocCall(Inst))) {
> + if (isa<AllocaInst>(Inst) || isNoAliasFn(Inst)) {
> const Value *AccessPtr = GetUnderlyingObject(MemLoc.Ptr, TD);
>
> if (AccessPtr == Inst || AA->isMustAlias(Inst, AccessPtr))
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> (original) +++
> llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp Thu Jun 21
> 10:45:28 2012 @@ -172,7 +172,7 @@ Instruction
> *InstCombiner::visitCallInst(CallInst &CI) { if (isFreeCall(&CI))
> return visitFree(CI);
> - if (extractMallocCall(&CI) || extractCallocCall(&CI))
> + if (isAllocLikeFn(&CI))
> return visitMalloc(CI);
>
> // If the caller function is nounwind, mark the call as nounwind,
> even if the @@ -246,84 +246,10 @@
> switch (II->getIntrinsicID()) {
> default: break;
> case Intrinsic::objectsize: {
> - // We need target data for just about everything so depend on it.
> - if (!TD) return 0;
> -
> - Type *ReturnTy = CI.getType();
> - uint64_t DontKnow = II->getArgOperand(1) == Builder->getTrue() ?
> 0 : -1ULL; -
> - // Get to the real allocated thing and offset as fast as
> possible.
> - Value *Op1 = II->getArgOperand(0)->stripPointerCasts();
> -
> - uint64_t Offset = 0;
> - uint64_t Size = -1ULL;
> -
> - // Try to look through constant GEPs.
> - if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op1)) {
> - if (!GEP->hasAllConstantIndices()) return 0;
> -
> - // Get the current byte offset into the thing. Use the original
> - // operand in case we're looking through a bitcast.
> - SmallVector<Value*, 8> Ops(GEP->idx_begin(), GEP->idx_end());
> - if (!GEP->getPointerOperandType()->isPointerTy())
> - return 0;
> - Offset = TD->getIndexedOffset(GEP->getPointerOperandType(),
> Ops); -
> - Op1 = GEP->getPointerOperand()->stripPointerCasts();
> -
> - // Make sure we're not a constant offset from an external
> - // global.
> - if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Op1))
> - if (!GV->hasDefinitiveInitializer()) return 0;
> - }
> -
> - // If we've stripped down to a single global variable that we
> - // can know the size of then just return that.
> - if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Op1)) {
> - if (GV->hasDefinitiveInitializer()) {
> - Constant *C = GV->getInitializer();
> - Size = TD->getTypeAllocSize(C->getType());
> - } else {
> - // Can't determine size of the GV.
> - Constant *RetVal = ConstantInt::get(ReturnTy, DontKnow);
> - return ReplaceInstUsesWith(CI, RetVal);
> - }
> - } else if (AllocaInst *AI = dyn_cast<AllocaInst>(Op1)) {
> - // Get alloca size.
> - if (AI->getAllocatedType()->isSized()) {
> - Size = TD->getTypeAllocSize(AI->getAllocatedType());
> - if (AI->isArrayAllocation()) {
> - const ConstantInt *C =
> dyn_cast<ConstantInt>(AI->getArraySize());
> - if (!C) return 0;
> - Size *= C->getZExtValue();
> - }
> - }
> - } else if (CallInst *MI = extractMallocCall(Op1)) {
> - // Get allocation size.
> - Value *Arg = MI->getArgOperand(0);
> - if (ConstantInt *CI = dyn_cast<ConstantInt>(Arg))
> - Size = CI->getZExtValue();
> -
> - } else if (CallInst *MI = extractCallocCall(Op1)) {
> - // Get allocation size.
> - Value *Arg1 = MI->getArgOperand(0);
> - Value *Arg2 = MI->getArgOperand(1);
> - if (ConstantInt *CI1 = dyn_cast<ConstantInt>(Arg1))
> - if (ConstantInt *CI2 = dyn_cast<ConstantInt>(Arg2))
> - Size = (CI1->getValue() * CI2->getValue()).getZExtValue();
> - }
> -
> - // Do not return "I don't know" here. Later optimization passes
> could
> - // make it possible to evaluate objectsize to a constant.
> - if (Size == -1ULL)
> - return 0;
> -
> - if (Size < Offset) {
> - // Out of bound reference? Negative index normalized to large
> - // index? Just return "I don't know".
> - return ReplaceInstUsesWith(CI, ConstantInt::get(ReturnTy,
> DontKnow));
> - }
> - return ReplaceInstUsesWith(CI, ConstantInt::get(ReturnTy,
> Size-Offset));
> + uint64_t Size;
> + if (getObjectSize(II->getArgOperand(0), Size, TD))
> + return ReplaceInstUsesWith(CI, ConstantInt::get(CI.getType(),
> Size));
> + return 0;
> }
> case Intrinsic::bswap:
> // bswap(bswap(x)) -> x
> @@ -768,7 +694,7 @@
> TerminatorInst *TI = II->getParent()->getTerminator();
> bool CannotRemove = false;
> for (++BI; &*BI != TI; ++BI) {
> - if (isa<AllocaInst>(BI) || isMalloc(BI)) {
> + if (isa<AllocaInst>(BI)) {
> CannotRemove = true;
> break;
> }
>
> Modified:
> llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp
> (original) +++
> llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp Thu
> Jun 21 10:45:28 2012 @@ -1068,7 +1068,7 @@ // If the bitcast is of an
> allocation, and the allocation will be // converted to match the type
> of the cast, don't touch this. if
> (isa<AllocaInst>(BCI->getOperand(0)) ||
> - isMalloc(BCI->getOperand(0))) {
> + isAllocationFn(BCI->getOperand(0))) {
> // See if the bitcast simplifies, if so, don't nuke this
> GEP yet. if (Instruction *I = visitBitCast(*BCI)) {
> if (I != BCI) {
>
> Modified: llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp
> (original) +++
> llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp Thu Jun 21
> 10:45:28 2012 @@ -275,39 +275,9 @@ }
> static uint64_t getPointerSize(const Value *V, AliasAnalysis &AA) {
> - const TargetData *TD = AA.getTargetData();
> -
> - if (const CallInst *CI = extractMallocCall(V)) {
> - if (const ConstantInt *C =
> dyn_cast<ConstantInt>(CI->getArgOperand(0)))
> - return C->getZExtValue();
> - }
> -
> - if (const CallInst *CI = extractCallocCall(V)) {
> - if (const ConstantInt *C1 =
> dyn_cast<ConstantInt>(CI->getArgOperand(0)))
> - if (const ConstantInt *C2 =
> dyn_cast<ConstantInt>(CI->getArgOperand(1)))
> - return (C1->getValue() * C2->getValue()).getZExtValue();
> - }
> -
> - if (TD == 0)
> - return AliasAnalysis::UnknownSize;
> -
> - if (const AllocaInst *A = dyn_cast<AllocaInst>(V)) {
> - // Get size information for the alloca
> - if (const ConstantInt *C =
> dyn_cast<ConstantInt>(A->getArraySize()))
> - return C->getZExtValue() *
> TD->getTypeAllocSize(A->getAllocatedType());
> - }
> -
> - if (const Argument *A = dyn_cast<Argument>(V)) {
> - if (A->hasByValAttr())
> - if (PointerType *PT = dyn_cast<PointerType>(A->getType()))
> - return TD->getTypeAllocSize(PT->getElementType());
> - }
> -
> - if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
> - if (!GV->mayBeOverridden())
> - return TD->getTypeAllocSize(GV->getType()->getElementType());
> - }
> -
> + uint64_t Size;
> + if (getObjectSize(V, Size, AA.getTargetData()))
> + return Size;
> return AliasAnalysis::UnknownSize;
> }
>
> @@ -705,16 +675,13 @@
> // Find all of the alloca'd pointers in the entry block.
> BasicBlock *Entry = BB.getParent()->begin();
> for (BasicBlock::iterator I = Entry->begin(), E = Entry->end();
> I != E; ++I) {
> - if (AllocaInst *AI = dyn_cast<AllocaInst>(I))
> - DeadStackObjects.insert(AI);
> + if (isa<AllocaInst>(I))
> + DeadStackObjects.insert(I);
>
> // Okay, so these are dead heap objects, but if the pointer
> never escapes // then it's leaked by this function anyways.
> - CallInst *CI = extractMallocCall(I);
> - if (!CI)
> - CI = extractCallocCall(I);
> - if (CI && !PointerMayBeCaptured(CI, true, true))
> - DeadStackObjects.insert(CI);
> + else if (isAllocLikeFn(I) && !PointerMayBeCaptured(I, true,
> true))
> + DeadStackObjects.insert(I);
> }
>
> // Treat byval arguments the same, stores to them are dead at the
> end of the @@ -773,18 +740,8 @@
> continue;
> }
>
> - if (AllocaInst *A = dyn_cast<AllocaInst>(BBI)) {
> - DeadStackObjects.remove(A);
> - continue;
> - }
> -
> - if (CallInst *CI = extractMallocCall(BBI)) {
> - DeadStackObjects.remove(CI);
> - continue;
> - }
> -
> - if (CallInst *CI = extractCallocCall(BBI)) {
> - DeadStackObjects.remove(CI);
> + if (isa<AllocaInst>(BBI) || isAllocLikeFn(BBI)) {
> + DeadStackObjects.remove(BBI);
> continue;
> }
>
>
> Modified: llvm/trunk/lib/Transforms/Scalar/GVN.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/GVN.cpp?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/GVN.cpp (original) +++
> llvm/trunk/lib/Transforms/Scalar/GVN.cpp Thu Jun 21 10:45:28 2012 @@
> -1436,7 +1436,7 @@ Instruction *DepInst = DepInfo.getInst();
>
> // Loading the allocation -> undef.
> - if (isa<AllocaInst>(DepInst) || isMalloc(DepInst) ||
> + if (isa<AllocaInst>(DepInst) || isMallocLikeFn(DepInst) ||
> // Loading immediately after lifetime begin -> undef.
> isLifetimeStart(DepInst)) {
> ValuesPerBlock.push_back(AvailableValueInBlock::get(DepBB,
> @@ -1951,7 +1951,7 @@
> // If this load really doesn't depend on anything, then we must be
> loading an // undef value. This can happen when loading for a fresh
> allocation with no // intervening stores, for example.
> - if (isa<AllocaInst>(DepInst) || isMalloc(DepInst)) {
> + if (isa<AllocaInst>(DepInst) || isMallocLikeFn(DepInst)) {
> L->replaceAllUsesWith(UndefValue::get(L->getType()));
> markInstructionForDeletion(L);
> ++NumGVNLoad;
>
> Modified: llvm/trunk/lib/Transforms/Utils/Local.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/Local.cpp?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/Local.cpp (original) +++
> llvm/trunk/lib/Transforms/Utils/Local.cpp Thu Jun 21 10:45:28 2012 @@
> -266,7 +266,7 @@ return isa<UndefValue>(II->getArgOperand(1));
> }
>
> - if (extractMallocCall(I) || extractCallocCall(I)) return true;
> + if (isAllocLikeFn(I)) return true;
>
> if (CallInst *CI = isFreeCall(I))
> if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
>
> Modified: llvm/trunk/test/Transforms/InstCombine/objsize.ll
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/objsize.ll?rev=158919&r1=158918&r2=158919&view=diff
> ==============================================================================
> --- llvm/trunk/test/Transforms/InstCombine/objsize.ll (original) +++
> llvm/trunk/test/Transforms/InstCombine/objsize.ll Thu Jun 21 10:45:28
> 2012 @@ -42,7 +42,7 @@
> define i1 @baz() nounwind {
> ; CHECK: @baz
> -; CHECK-NEXT: ret i1 true
> +; CHECK-NEXT: objectsize
> %1 = tail call i32 @llvm.objectsize.i32(i8* getelementptr inbounds
> ([0 x i8]* @window, i32 0, i32 0), i1 false) %2 = icmp eq i32 %1, -1
> ret i1 %2
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
--
Hal Finkel
Postdoctoral Appointee
Leadership Computing Facility
Argonne National Laboratory
More information about the llvm-commits
mailing list