RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-12-12 06:06:32 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[opaque pointer types] [NFC] GEP: replace get(Pointer)ElementType uses with get{Source,Result}ElementType.

Browse Source 
Summary:
GEPOperator: provide getResultElementType alongside getSourceElementType.
This is made possible by adding a result element type field to GetElementPtrConstantExpr, which GetElementPtrInst already has.

GEP: replace get(Pointer)ElementType uses with get{Source,Result}ElementType.

Reviewers: mjacob, dblaikie

Subscribers: llvm-commits

Differential Revision: http://reviews.llvm.org/D16275

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@258145 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eduard Burtescu 2016-01-19 17:28:00 +00:00
parent b0025fa67f
commit f70dc429e7
21 changed files with 73 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/llvm/IR/Operator.h
View File

@ -401,6 +401,7 @@ public:
}
Type *getSourceElementType() const;
Type *getResultElementType() const;
/// Method to return the address space of the pointer operand.
unsigned getPointerAddressSpace() const {

2
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -381,7 +381,7 @@ static bool isObjectSize(const Value *V, uint64_t Size, const DataLayout &DL,
}
// Don't attempt to analyze GEPs over unsized objects.
if (!GEPOp->getOperand(0)->getType()->getPointerElementType()->isSized())
if (!GEPOp->getSourceElementType()->isSized())
return V;
unsigned AS = GEPOp->getPointerAddressSpace();

8
lib/Analysis/ScalarEvolution.cpp
View File

@ -4087,16 +4087,16 @@ const SCEV *ScalarEvolution::createNodeForSelectOrPHI(Instruction *I,
/// operations. This allows them to be analyzed by regular SCEV code.
///
const SCEV *ScalarEvolution::createNodeForGEP(GEPOperator *GEP) {
Value *Base = GEP->getOperand(0);
// Don't attempt to analyze GEPs over unsized objects.
if (!Base->getType()->getPointerElementType()->isSized())
if (!GEP->getSourceElementType()->isSized())
return getUnknown(GEP);
SmallVector<const SCEV *, 4> IndexExprs;
for (auto Index = GEP->idx_begin(); Index != GEP->idx_end(); ++Index)
IndexExprs.push_back(getSCEV(*Index));
return getGEPExpr(GEP->getSourceElementType(), getSCEV(Base), IndexExprs,
GEP->isInBounds());
return getGEPExpr(GEP->getSourceElementType(),
getSCEV(GEP->getPointerOperand()),
IndexExprs, GEP->isInBounds());
}
/// GetMinTrailingZeros - Determine the minimum number of zero bits that S is

10
lib/Analysis/ValueTracking.cpp
View File

@ -2886,8 +2886,7 @@ bool llvm::getConstantStringInfo(const Value *V, StringRef &Str,
return false;
// Make sure the index-ee is a pointer to array of i8.
PointerType *PT = cast<PointerType>(GEP->getOperand(0)->getType());
ArrayType *AT = dyn_cast<ArrayType>(PT->getElementType());
ArrayType *AT = dyn_cast<ArrayType>(GEP->getSourceElementType());
if (!AT || !AT->getElementType()->isIntegerTy(8))
return false;
@ -3253,8 +3252,7 @@ static bool isDereferenceableAndAlignedPointer(
// For GEPs, determine if the indexing lands within the allocated object.
if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
Type *VTy = GEP->getType();
Type *Ty = VTy->getPointerElementType();
Type *Ty = GEP->getResultElementType();
const Value *Base = GEP->getPointerOperand();
// Conservatively require that the base pointer be fully dereferenceable
@ -3265,14 +3263,14 @@ static bool isDereferenceableAndAlignedPointer(
Visited))
return false;
APInt Offset(DL.getPointerTypeSizeInBits(VTy), 0);
APInt Offset(DL.getPointerTypeSizeInBits(GEP->getType()), 0);
if (!GEP->accumulateConstantOffset(DL, Offset))
return false;
// Check if the load is within the bounds of the underlying object
// and offset is aligned.
uint64_t LoadSize = DL.getTypeStoreSize(Ty);
Type *BaseType = Base->getType()->getPointerElementType();
Type *BaseType = GEP->getSourceElementType();
assert(isPowerOf2_32(Align) && "must be a power of 2!");
return (Offset + LoadSize).ule(DL.getTypeAllocSize(BaseType)) &&
!(Offset & APInt(Offset.getBitWidth(), Align-1));

3
lib/Analysis/VectorUtils.cpp
View File

@ -231,8 +231,7 @@ Intrinsic::ID llvm::getIntrinsicIDForCall(CallInst *CI,
unsigned llvm::getGEPInductionOperand(const GetElementPtrInst *Gep) {
const DataLayout &DL = Gep->getModule()->getDataLayout();
unsigned LastOperand = Gep->getNumOperands() - 1;
unsigned GEPAllocSize = DL.getTypeAllocSize(
cast<PointerType>(Gep->getType()->getScalarType())->getElementType());
unsigned GEPAllocSize = DL.getTypeAllocSize(Gep->getResultElementType());
// Walk backwards and try to peel off zeros.
while (LastOperand > 1 && match(Gep->getOperand(LastOperand), m_Zero())) {

8
lib/CodeGen/SelectionDAG/FastISel.cpp
View File

@ -513,7 +513,13 @@ bool FastISel::selectGetElementPtr(const User *I) {
}
Ty = StTy->getElementType(Field);
} else {
Ty = cast<SequentialType>(Ty)->getElementType();
if (Ty->isPointerTy()) {
// The only pointer type is for the very first index,
// therefore the next type is the source element type.
Ty = cast<GEPOperator>(I)->getSourceElementType();
} else {
Ty = cast<SequentialType>(Ty)->getElementType();
}
// If this is a constant subscript, handle it quickly.
if (const auto *CI = dyn_cast<ConstantInt>(Idx)) {

9
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
View File

@ -3018,7 +3018,14 @@ void SelectionDAGBuilder::visitGetElementPtr(const User &I) {
Ty = StTy->getElementType(Field);
} else {
Ty = cast<SequentialType>(Ty)->getElementType();
if (Ty->isPointerTy()) {
// The only pointer type is for the very first index,
// therefore the next type is the source element type.
Ty = cast<GEPOperator>(&I)->getSourceElementType();
} else {
Ty = cast<SequentialType>(Ty)->getElementType();
}
MVT PtrTy =
DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout(), AS);
unsigned PtrSize = PtrTy.getSizeInBits();

22
lib/IR/ConstantFold.cpp
View File

@ -2041,7 +2041,7 @@ static Constant *ConstantFoldGetElementPtrImpl(Type *PointeeTy, Constant *C,
if (isa<UndefValue>(C)) {
PointerType *PtrTy = cast<PointerType>(C->getType()->getScalarType());
Type *Ty = GetElementPtrInst::getIndexedType(PtrTy->getElementType(), Idxs);
Type *Ty = GetElementPtrInst::getIndexedType(PointeeTy, Idxs);
assert(Ty && "Invalid indices for GEP!");
Type *GEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
if (VectorType *VT = dyn_cast<VectorType>(C->getType()))
@ -2058,8 +2058,8 @@ static Constant *ConstantFoldGetElementPtrImpl(Type *PointeeTy, Constant *C,
}
if (isNull) {
PointerType *PtrTy = cast<PointerType>(C->getType()->getScalarType());
Type *Ty =
GetElementPtrInst::getIndexedType(PtrTy->getElementType(), Idxs);
Type *Ty = GetElementPtrInst::getIndexedType(PointeeTy, Idxs);
assert(Ty && "Invalid indices for GEP!");
Type *GEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
if (VectorType *VT = dyn_cast<VectorType>(C->getType()))
@ -2241,22 +2241,6 @@ static Constant *ConstantFoldGetElementPtrImpl(Type *PointeeTy, Constant *C,
return nullptr;
}
Constant *llvm::ConstantFoldGetElementPtr(Constant *C,
bool inBounds,
ArrayRef<Constant *> Idxs) {
return ConstantFoldGetElementPtrImpl(
cast<PointerType>(C->getType()->getScalarType())->getElementType(), C,
inBounds, Idxs);
}
Constant *llvm::ConstantFoldGetElementPtr(Constant *C,
bool inBounds,
ArrayRef<Value *> Idxs) {
return ConstantFoldGetElementPtrImpl(
cast<PointerType>(C->getType()->getScalarType())->getElementType(), C,
inBounds, Idxs);
}
Constant *llvm::ConstantFoldGetElementPtr(Type *Ty, Constant *C,
bool inBounds,
ArrayRef<Constant *> Idxs) {

4
lib/IR/ConstantFold.h
View File

@ -47,10 +47,6 @@ namespace llvm {
Constant *V2);
Constant *ConstantFoldCompareInstruction(unsigned short predicate,
Constant *C1, Constant *C2);
Constant *ConstantFoldGetElementPtr(Constant *C, bool inBounds,
ArrayRef<Constant *> Idxs);
Constant *ConstantFoldGetElementPtr(Constant *C, bool inBounds,
ArrayRef<Value *> Idxs);
Constant *ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool inBounds,
ArrayRef<Constant *> Idxs);
Constant *ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool inBounds,

7
lib/IR/Constants.cpp
View File

@ -2335,7 +2335,8 @@ GetElementPtrConstantExpr::GetElementPtrConstantExpr(
OperandTraits<GetElementPtrConstantExpr>::op_end(this) -
(IdxList.size() + 1),
IdxList.size() + 1),
SrcElementTy(SrcElementTy) {
SrcElementTy(SrcElementTy),
ResElementTy(GetElementPtrInst::getIndexedType(SrcElementTy, IdxList)) {
Op<0>() = C;
Use *OperandList = getOperandList();
for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
@ -2346,6 +2347,10 @@ Type *GetElementPtrConstantExpr::getSourceElementType() const {
return SrcElementTy;
}
Type *GetElementPtrConstantExpr::getResultElementType() const {
return ResElementTy;
}
//===----------------------------------------------------------------------===//
// ConstantData* implementations

10
lib/IR/ConstantsContext.h
View File

@ -225,19 +225,12 @@ public:
/// used behind the scenes to implement getelementpr constant exprs.
class GetElementPtrConstantExpr : public ConstantExpr {
Type *SrcElementTy;
Type *ResElementTy;
void anchor() override;
GetElementPtrConstantExpr(Type *SrcElementTy, Constant *C,
ArrayRef<Constant *> IdxList, Type *DestTy);
public:
static GetElementPtrConstantExpr *Create(Constant *C,
ArrayRef<Constant*> IdxList,
Type *DestTy,
unsigned Flags) {
return Create(
cast<PointerType>(C->getType()->getScalarType())->getElementType(), C,
IdxList, DestTy, Flags);
}
static GetElementPtrConstantExpr *Create(Type *SrcElementTy, Constant *C,
ArrayRef<Constant *> IdxList,
Type *DestTy, unsigned Flags) {
@ -247,6 +240,7 @@ public:
return Result;
}
Type *getSourceElementType() const;
Type *getResultElementType() const;
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);

6
lib/IR/Operator.cpp
View File

@ -12,6 +12,12 @@ Type *GEPOperator::getSourceElementType() const {
return cast<GetElementPtrConstantExpr>(this)->getSourceElementType();
}
Type *GEPOperator::getResultElementType() const {
if (auto *I = dyn_cast<GetElementPtrInst>(this))
return I->getResultElementType();
return cast<GetElementPtrConstantExpr>(this)->getResultElementType();
}
bool GEPOperator::accumulateConstantOffset(const DataLayout &DL,
APInt &Offset) const {
assert(Offset.getBitWidth() ==

8
lib/Target/AArch64/AArch64FastISel.cpp
View File

@ -4825,7 +4825,13 @@ bool AArch64FastISel::selectGetElementPtr(const Instruction *I) {
TotalOffs += DL.getStructLayout(StTy)->getElementOffset(Field);
Ty = StTy->getElementType(Field);
} else {
Ty = cast<SequentialType>(Ty)->getElementType();
if (Ty->isPointerTy()) {
// The only pointer type is for the very first index,
// therefore the next type is the source element type.
Ty = cast<GEPOperator>(I)->getSourceElementType();
} else {
Ty = cast<SequentialType>(Ty)->getElementType();
}
// If this is a constant subscript, handle it quickly.
if (const auto *CI = dyn_cast<ConstantInt>(Idx)) {
if (CI->isZero())

2
lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -329,7 +329,7 @@ static bool CleanupConstantGlobalUsers(Value *V, Constant *Init,
// we already know what the result of any load from that GEP is.
// TODO: Handle splats.
if (Init && isa<ConstantAggregateZero>(Init) && GEP->isInBounds())
SubInit = Constant::getNullValue(GEP->getType()->getElementType());
SubInit = Constant::getNullValue(GEP->getResultElementType());
}
Changed |= CleanupConstantGlobalUsers(GEP, SubInit, DL, TLI);

6
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
View File

@ -694,10 +694,8 @@ static bool canReplaceGEPIdxWithZero(InstCombiner &IC, GetElementPtrInst *GEPI,
return false;
SmallVector<Value *, 4> Ops(GEPI->idx_begin(), GEPI->idx_begin() + Idx);
Type *AllocTy = GetElementPtrInst::getIndexedType(
cast<PointerType>(GEPI->getOperand(0)->getType()->getScalarType())
->getElementType(),
Ops);
Type *AllocTy =
GetElementPtrInst::getIndexedType(GEPI->getSourceElementType(), Ops);
if (!AllocTy || !AllocTy->isSized())
return false;
const DataLayout &DL = IC.getDataLayout();

23
lib/Transforms/InstCombine/InstructionCombining.cpp
View File

@ -1349,19 +1349,18 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
for (User::op_iterator I = GEP.op_begin() + 1, E = GEP.op_end(); I != E;
++I, ++GTI) {
// Skip indices into struct types.
SequentialType *SeqTy = dyn_cast<SequentialType>(*GTI);
if (!SeqTy)
if (isa<StructType>(*GTI))
continue;
// Index type should have the same width as IntPtr
Type *IndexTy = (*I)->getType();
Type *NewIndexType = IndexTy->isVectorTy() ?
VectorType::get(IntPtrTy, IndexTy->getVectorNumElements()) : IntPtrTy;
// If the element type has zero size then any index over it is equivalent
// to an index of zero, so replace it with zero if it is not zero already.
if (SeqTy->getElementType()->isSized() &&
DL.getTypeAllocSize(SeqTy->getElementType()) == 0)
Type *EltTy = GTI.getIndexedType();
if (EltTy->isSized() && DL.getTypeAllocSize(EltTy) == 0)
if (!isa<Constant>(*I) || !cast<Constant>(*I)->isNullValue()) {
*I = Constant::getNullValue(NewIndexType);
MadeChange = true;
@ -1405,7 +1404,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
return nullptr;
// Keep track of the type as we walk the GEP.
Type *CurTy = Op1->getOperand(0)->getType()->getScalarType();
Type *CurTy = nullptr;
for (unsigned J = 0, F = Op1->getNumOperands(); J != F; ++J) {
if (Op1->getOperand(J)->getType() != Op2->getOperand(J)->getType())
@ -1436,7 +1435,9 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
// Sink down a layer of the type for the next iteration.
if (J > 0) {
if (CompositeType *CT = dyn_cast<CompositeType>(CurTy)) {
if (J == 1) {
CurTy = Op1->getSourceElementType();
} else if (CompositeType *CT = dyn_cast<CompositeType>(CurTy)) {
CurTy = CT->getTypeAtIndex(Op1->getOperand(J));
} else {
CurTy = nullptr;
@ -1565,8 +1566,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
unsigned AS = GEP.getPointerAddressSpace();
if (GEP.getOperand(1)->getType()->getScalarSizeInBits() ==
DL.getPointerSizeInBits(AS)) {
Type *PtrTy = GEP.getPointerOperandType();
Type *Ty = PtrTy->getPointerElementType();
Type *Ty = GEP.getSourceElementType();
uint64_t TyAllocSize = DL.getTypeAllocSize(Ty);
bool Matched = false;
@ -1629,9 +1629,8 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
//
// This occurs when the program declares an array extern like "int X[];"
if (HasZeroPointerIndex) {
PointerType *CPTy = cast<PointerType>(PtrOp->getType());
if (ArrayType *CATy =
dyn_cast<ArrayType>(CPTy->getElementType())) {
dyn_cast<ArrayType>(GEP.getSourceElementType())) {
// GEP (bitcast i8* X to [0 x i8]*), i32 0, ... ?
if (CATy->getElementType() == StrippedPtrTy->getElementType()) {
// -> GEP i8* X, ...
@ -1688,7 +1687,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
// %t = getelementptr i32* bitcast ([2 x i32]* %str to i32*), i32 %V
// into: %t1 = getelementptr [2 x i32]* %str, i32 0, i32 %V; bitcast
Type *SrcElTy = StrippedPtrTy->getElementType();
Type *ResElTy = PtrOp->getType()->getPointerElementType();
Type *ResElTy = GEP.getSourceElementType();
if (SrcElTy->isArrayTy() &&
DL.getTypeAllocSize(SrcElTy->getArrayElementType()) ==
DL.getTypeAllocSize(ResElTy)) {

4
lib/Transforms/Scalar/NaryReassociate.cpp
View File

@ -335,7 +335,7 @@ static bool isGEPFoldable(GetElementPtrInst *GEP,
}
unsigned AddrSpace = GEP->getPointerAddressSpace();
return TTI->isLegalAddressingMode(GEP->getType()->getElementType(), BaseGV,
return TTI->isLegalAddressingMode(GEP->getResultElementType(), BaseGV,
BaseOffset, HasBaseReg, Scale, AddrSpace);
}
@ -434,7 +434,7 @@ GetElementPtrInst *NaryReassociate::tryReassociateGEPAtIndex(
// NewGEP = (char *)Candidate + RHS * sizeof(IndexedType)
uint64_t IndexedSize = DL->getTypeAllocSize(IndexedType);
Type *ElementType = GEP->getType()->getElementType();
Type *ElementType = GEP->getResultElementType();
uint64_t ElementSize = DL->getTypeAllocSize(ElementType);
// Another less rare case: because I is not necessarily the last index of the
// GEP, the size of the type at the I-th index (IndexedSize) is not

2
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
View File

@ -2108,7 +2108,7 @@ chainToBasePointerCost(SmallVectorImpl<Instruction*> &Chain,
} else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Instr)) {
// Cost of the address calculation
Type *ValTy = GEP->getPointerOperandType()->getPointerElementType();
Type *ValTy = GEP->getSourceElementType();
Cost += TTI.getAddressComputationCost(ValTy);
// And cost of the GEP itself

8
lib/Transforms/Scalar/ScalarReplAggregates.cpp
View File

@ -510,15 +510,11 @@ bool ConvertToScalarInfo::CanConvertToScalar(Value *V, uint64_t Offset,
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(UI)) {
// If this is a GEP with a variable indices, we can't handle it.
PointerType* PtrTy = dyn_cast<PointerType>(GEP->getPointerOperandType());
if (!PtrTy)
return false;
// Compute the offset that this GEP adds to the pointer.
SmallVector<Value*, 8> Indices(GEP->op_begin()+1, GEP->op_end());
Value *GEPNonConstantIdx = nullptr;
if (!GEP->hasAllConstantIndices()) {
if (!isa<VectorType>(PtrTy->getElementType()))
if (!isa<VectorType>(GEP->getSourceElementType()))
return false;
if (NonConstantIdx)
return false;
@ -528,7 +524,7 @@ bool ConvertToScalarInfo::CanConvertToScalar(Value *V, uint64_t Offset,
HadDynamicAccess = true;
} else
GEPNonConstantIdx = NonConstantIdx;
uint64_t GEPOffset = DL.getIndexedOffset(PtrTy,
uint64_t GEPOffset = DL.getIndexedOffset(GEP->getPointerOperandType(),
Indices);
// See if all uses can be converted.
if (!CanConvertToScalar(GEP, Offset+GEPOffset, GEPNonConstantIdx))

4
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp
View File

@ -911,7 +911,7 @@ bool SeparateConstOffsetFromGEP::splitGEP(GetElementPtrInst *GEP) {
getAnalysis<TargetTransformInfoWrapperPass>().getTTI(
*GEP->getParent()->getParent());
unsigned AddrSpace = GEP->getPointerAddressSpace();
if (!TTI.isLegalAddressingMode(GEP->getType()->getElementType(),
if (!TTI.isLegalAddressingMode(GEP->getResultElementType(),
/*BaseGV=*/nullptr, AccumulativeByteOffset,
/*HasBaseReg=*/true, /*Scale=*/0,
AddrSpace)) {
@ -1018,7 +1018,7 @@ bool SeparateConstOffsetFromGEP::splitGEP(GetElementPtrInst *GEP) {
// unsigned.. Therefore, we cast ElementTypeSizeOfGEP to signed because it is
// used with unsigned integers later.
int64_t ElementTypeSizeOfGEP = static_cast<int64_t>(
DL->getTypeAllocSize(GEP->getType()->getElementType()));
DL->getTypeAllocSize(GEP->getResultElementType()));
Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
if (AccumulativeByteOffset % ElementTypeSizeOfGEP == 0) {
// Very likely. As long as %gep is natually aligned, the byte offset we

5
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp
View File

@ -270,7 +270,7 @@ static bool isGEPFoldable(GetElementPtrInst *GEP,
}
unsigned AddrSpace = GEP->getPointerAddressSpace();
return TTI->isLegalAddressingMode(GEP->getType()->getElementType(), BaseGV,
return TTI->isLegalAddressingMode(GEP->getResultElementType(), BaseGV,
BaseOffset, HasBaseReg, Scale, AddrSpace);
}
@ -566,8 +566,7 @@ Value *StraightLineStrengthReduce::emitBump(const Candidate &Basis,
if (Basis.CandidateKind == Candidate::GEP) {
APInt ElementSize(
IndexOffset.getBitWidth(),
DL->getTypeAllocSize(
cast<GetElementPtrInst>(Basis.Ins)->getType()->getElementType()));
DL->getTypeAllocSize(cast<GetElementPtrInst>(Basis.Ins)->getResultElementType()));
APInt Q, R;
APInt::sdivrem(IndexOffset, ElementSize, Q, R);
if (R.getSExtValue() == 0)