6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-14 14:24:05 +00:00
Code Issues Projects Releases Wiki Activity

Thread LLVMContext through the constant folding APIs, which touches a lot of files.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@74844 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson
2009-07-06 18:42:36 +00:00
parent e034393b15
commit 508955156a
21 changed files with 256 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -22,6 +22,7 @@
#include "llvm/GlobalVariable.h"
#include "llvm/Instructions.h"
#include "llvm/IntrinsicInst.h"
#include "llvm/LLVMContext.h"
#include "llvm/Pass.h"
#include "llvm/Target/TargetData.h"
#include "llvm/ADT/SmallVector.h"
@ -394,13 +395,13 @@ BasicAliasAnalysis::alias(const Value *V1, unsigned V1Size,
// 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);
@ -480,7 +481,7 @@ BasicAliasAnalysis::alias(const Value *V1, unsigned V1Size,
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],
@ -498,16 +499,16 @@ BasicAliasAnalysis::alias(const Value *V1, unsigned V1Size,
// 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;
@ -535,7 +536,8 @@ BasicAliasAnalysis::CheckGEPInstructions(
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))
@ -600,9 +602,9 @@ BasicAliasAnalysis::CheckGEPInstructions(
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;
}
@ -689,7 +691,7 @@ BasicAliasAnalysis::CheckGEPInstructions(
// 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();
@ -734,7 +736,7 @@ BasicAliasAnalysis::CheckGEPInstructions(
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]);
@ -749,7 +751,7 @@ BasicAliasAnalysis::CheckGEPInstructions(
// 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) {
@ -775,9 +777,11 @@ BasicAliasAnalysis::CheckGEPInstructions(
// 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);
}
}
@ -792,7 +796,7 @@ BasicAliasAnalysis::CheckGEPInstructions(
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());
}
}
}