#include "llvm/GlobalVariable.h"
#include "llvm/Instructions.h"
#include "llvm/IntrinsicInst.h"
+#include "llvm/LLVMContext.h"
+#include "llvm/Operator.h"
#include "llvm/Pass.h"
#include "llvm/Target/TargetData.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
-#include "llvm/Support/ManagedStatic.h"
#include <algorithm>
using namespace llvm;
// Useful predicates
//===----------------------------------------------------------------------===//
-static const User *isGEP(const Value *V) {
- if (isa<GetElementPtrInst>(V) ||
- (isa<ConstantExpr>(V) &&
- cast<ConstantExpr>(V)->getOpcode() == Instruction::GetElementPtr))
- return cast<User>(V);
- return 0;
+static const GEPOperator *isGEP(const Value *V) {
+ return dyn_cast<GEPOperator>(V);
}
static const Value *GetGEPOperands(const Value *V,
}
if (AccessTy->isSized())
- return TD.getTypePaddedSize(AccessTy) < Size;
+ return TD.getTypeAllocSize(AccessTy) < Size;
return false;
}
virtual void getArgumentAccesses(Function *F, CallSite CS,
std::vector<PointerAccessInfo> &Info) {
- assert(0 && "This method may not be called on this function!");
+ llvm_unreachable("This method may not be called on this function!");
}
virtual void getMustAliases(Value *P, std::vector<Value*> &RetVals) { }
AliasAnalysis::AliasResult
BasicAliasAnalysis::alias(const Value *V1, unsigned V1Size,
const Value *V2, unsigned V2Size) {
+ LLVMContext &Context = V1->getType()->getContext();
+
// Strip off any constant expression casts if they exist
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V1))
if (CE->isCast() && isa<PointerType>(CE->getOperand(0)->getType()))
// the base pointers.
while (isGEP(GEP1->getOperand(0)) &&
GEP1->getOperand(1) ==
- Constant::getNullValue(GEP1->getOperand(1)->getType()))
+ Context.getNullValue(GEP1->getOperand(1)->getType()))
GEP1 = cast<User>(GEP1->getOperand(0));
const Value *BasePtr1 = GEP1->getOperand(0);
while (isGEP(GEP2->getOperand(0)) &&
GEP2->getOperand(1) ==
- Constant::getNullValue(GEP2->getOperand(1)->getType()))
+ Context.getNullValue(GEP2->getOperand(1)->getType()))
GEP2 = cast<User>(GEP2->getOperand(0));
const Value *BasePtr2 = GEP2->getOperand(0);
for (unsigned i = 0; i != GEPOperands.size(); ++i)
if (!isa<ConstantInt>(GEPOperands[i]))
GEPOperands[i] =
- Constant::getNullValue(GEPOperands[i]->getType());
+ Context.getNullValue(GEPOperands[i]->getType());
int64_t Offset =
getTargetData().getIndexedOffset(BasePtr->getType(),
&GEPOperands[0],
// This function is used to determine if the indices of two GEP instructions are
// equal. V1 and V2 are the indices.
-static bool IndexOperandsEqual(Value *V1, Value *V2) {
+static bool IndexOperandsEqual(Value *V1, Value *V2, LLVMContext &Context) {
if (V1->getType() == V2->getType())
return V1 == V2;
if (Constant *C1 = dyn_cast<Constant>(V1))
if (Constant *C2 = dyn_cast<Constant>(V2)) {
// Sign extend the constants to long types, if necessary
if (C1->getType() != Type::Int64Ty)
- C1 = ConstantExpr::getSExt(C1, Type::Int64Ty);
+ C1 = Context.getConstantExprSExt(C1, Type::Int64Ty);
if (C2->getType() != Type::Int64Ty)
- C2 = ConstantExpr::getSExt(C2, Type::Int64Ty);
+ C2 = Context.getConstantExprSExt(C2, Type::Int64Ty);
return C1 == C2;
}
return false;
const PointerType *GEPPointerTy = cast<PointerType>(BasePtr1Ty);
+ LLVMContext &Context = GEPPointerTy->getContext();
+
// Find the (possibly empty) initial sequence of equal values... which are not
// necessarily constants.
unsigned NumGEP1Operands = NumGEP1Ops, NumGEP2Operands = NumGEP2Ops;
unsigned MaxOperands = std::max(NumGEP1Operands, NumGEP2Operands);
unsigned UnequalOper = 0;
while (UnequalOper != MinOperands &&
- IndexOperandsEqual(GEP1Ops[UnequalOper], GEP2Ops[UnequalOper])) {
+ IndexOperandsEqual(GEP1Ops[UnequalOper], GEP2Ops[UnequalOper],
+ Context)) {
// Advance through the type as we go...
++UnequalOper;
if (const CompositeType *CT = dyn_cast<CompositeType>(BasePtr1Ty))
if (G1OC->getType() != G2OC->getType()) {
// Sign extend both operands to long.
if (G1OC->getType() != Type::Int64Ty)
- G1OC = ConstantExpr::getSExt(G1OC, Type::Int64Ty);
+ G1OC = Context.getConstantExprSExt(G1OC, Type::Int64Ty);
if (G2OC->getType() != Type::Int64Ty)
- G2OC = ConstantExpr::getSExt(G2OC, Type::Int64Ty);
+ G2OC = Context.getConstantExprSExt(G2OC, Type::Int64Ty);
GEP1Ops[FirstConstantOper] = G1OC;
GEP2Ops[FirstConstantOper] = G2OC;
}
if (G1OC != G2OC) {
// Handle the "be careful" case above: if this is an array/vector
// subscript, scan for a subsequent variable array index.
- if (isa<SequentialType>(BasePtr1Ty)) {
- const Type *NextTy =
- cast<SequentialType>(BasePtr1Ty)->getElementType();
+ if (const SequentialType *STy =
+ dyn_cast<SequentialType>(BasePtr1Ty)) {
+ const Type *NextTy = STy;
bool isBadCase = false;
- for (unsigned Idx = FirstConstantOper+1;
+ for (unsigned Idx = FirstConstantOper;
Idx != MinOperands && isa<SequentialType>(NextTy); ++Idx) {
const Value *V1 = GEP1Ops[Idx], *V2 = GEP2Ops[Idx];
if (!isa<Constant>(V1) || !isa<Constant>(V2)) {
isBadCase = true;
break;
}
+ // If the array is indexed beyond the bounds of the static type
+ // at this level, it will also fall into the "be careful" case.
+ // It would theoretically be possible to analyze these cases,
+ // but for now just be conservatively correct.
+ if (const ArrayType *ATy = dyn_cast<ArrayType>(STy))
+ if (cast<ConstantInt>(G1OC)->getZExtValue() >=
+ ATy->getNumElements() ||
+ cast<ConstantInt>(G2OC)->getZExtValue() >=
+ ATy->getNumElements()) {
+ isBadCase = true;
+ break;
+ }
+ if (const VectorType *VTy = dyn_cast<VectorType>(STy))
+ if (cast<ConstantInt>(G1OC)->getZExtValue() >=
+ VTy->getNumElements() ||
+ cast<ConstantInt>(G2OC)->getZExtValue() >=
+ VTy->getNumElements()) {
+ isBadCase = true;
+ break;
+ }
+ STy = cast<SequentialType>(NextTy);
NextTy = cast<SequentialType>(NextTy)->getElementType();
}
// TargetData::getIndexedOffset.
for (i = 0; i != MaxOperands; ++i)
if (!isa<ConstantInt>(GEP1Ops[i]))
- GEP1Ops[i] = Constant::getNullValue(GEP1Ops[i]->getType());
+ GEP1Ops[i] = Context.getNullValue(GEP1Ops[i]->getType());
// Okay, now get the offset. This is the relative offset for the full
// instruction.
const TargetData &TD = getTargetData();
const Type *ZeroIdxTy = GEPPointerTy;
for (unsigned i = 0; i != FirstConstantOper; ++i) {
if (!isa<StructType>(ZeroIdxTy))
- GEP1Ops[i] = GEP2Ops[i] = Constant::getNullValue(Type::Int32Ty);
+ GEP1Ops[i] = GEP2Ops[i] = Context.getNullValue(Type::Int32Ty);
if (const CompositeType *CT = dyn_cast<CompositeType>(ZeroIdxTy))
ZeroIdxTy = CT->getTypeAtIndex(GEP1Ops[i]);
// If they are equal, use a zero index...
if (Op1 == Op2 && BasePtr1Ty == BasePtr2Ty) {
if (!isa<ConstantInt>(Op1))
- GEP1Ops[i] = GEP2Ops[i] = Constant::getNullValue(Op1->getType());
+ GEP1Ops[i] = GEP2Ops[i] = Context.getNullValue(Op1->getType());
// Otherwise, just keep the constants we have.
} else {
if (Op1) {
// value possible.
//
if (const ArrayType *AT = dyn_cast<ArrayType>(BasePtr1Ty))
- GEP1Ops[i] = ConstantInt::get(Type::Int64Ty,AT->getNumElements()-1);
+ GEP1Ops[i] =
+ Context.getConstantInt(Type::Int64Ty,AT->getNumElements()-1);
else if (const VectorType *VT = dyn_cast<VectorType>(BasePtr1Ty))
- GEP1Ops[i] = ConstantInt::get(Type::Int64Ty,VT->getNumElements()-1);
+ GEP1Ops[i] =
+ Context.getConstantInt(Type::Int64Ty,VT->getNumElements()-1);
}
}
return MayAlias; // Be conservative with out-of-range accesses
}
} else { // Conservatively assume the minimum value for this index
- GEP2Ops[i] = Constant::getNullValue(Op2->getType());
+ GEP2Ops[i] = Context.getNullValue(Op2->getType());
}
}
}
projects / oota-llvm.git / blobdiff