From 1423921a24866af65dd7ffaf69bca20babe72786 Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Fri, 22 Jan 2016 01:17:26 +0000 Subject: [PATCH] [opaque pointer types] [NFC] Add an explicit type argument to ConstantFoldLoadFromConstPtr. Reviewers: mjacob, dblaikie Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D16418 llvm-svn: 258472 --- llvm/include/llvm/Analysis/ConstantFolding.h | 2 +- llvm/lib/Analysis/ConstantFolding.cpp | 42 +++++++++---------- llvm/lib/Analysis/InstructionSimplify.cpp | 2 +- llvm/lib/Analysis/ScalarEvolution.cpp | 4 +- .../SelectionDAG/SelectionDAGBuilder.cpp | 2 +- llvm/lib/Transforms/Scalar/GVN.cpp | 4 +- llvm/lib/Transforms/Scalar/SCCP.cpp | 2 +- 7 files changed, 29 insertions(+), 29 deletions(-) diff --git a/llvm/include/llvm/Analysis/ConstantFolding.h b/llvm/include/llvm/Analysis/ConstantFolding.h index af7b87c56c31..57a2537c0c7c 100644 --- a/llvm/include/llvm/Analysis/ConstantFolding.h +++ b/llvm/include/llvm/Analysis/ConstantFolding.h @@ -95,7 +95,7 @@ Constant *ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx); /// ConstantFoldLoadFromConstPtr - Return the value that a load from C would /// produce if it is constant and determinable. If this is not determinable, /// return null. -Constant *ConstantFoldLoadFromConstPtr(Constant *C, const DataLayout &DL); +Constant *ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, const DataLayout &DL); /// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a /// getelementptr constantexpr, return the constant value being addressed by the diff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp index ec2c38e5301f..54dd0d51d129 100644 --- a/llvm/lib/Analysis/ConstantFolding.cpp +++ b/llvm/lib/Analysis/ConstantFolding.cpp @@ -399,9 +399,9 @@ static bool ReadDataFromGlobal(Constant *C, uint64_t ByteOffset, } static Constant *FoldReinterpretLoadFromConstPtr(Constant *C, + Type *LoadTy, const DataLayout &DL) { PointerType *PTy = cast(C->getType()); - Type *LoadTy = PTy->getElementType(); IntegerType *IntType = dyn_cast(LoadTy); // If this isn't an integer load we can't fold it directly. @@ -414,19 +414,19 @@ static Constant *FoldReinterpretLoadFromConstPtr(Constant *C, // an actual new load. Type *MapTy; if (LoadTy->isHalfTy()) - MapTy = Type::getInt16PtrTy(C->getContext(), AS); + MapTy = Type::getInt16Ty(C->getContext()); else if (LoadTy->isFloatTy()) - MapTy = Type::getInt32PtrTy(C->getContext(), AS); + MapTy = Type::getInt32Ty(C->getContext()); else if (LoadTy->isDoubleTy()) - MapTy = Type::getInt64PtrTy(C->getContext(), AS); + MapTy = Type::getInt64Ty(C->getContext()); else if (LoadTy->isVectorTy()) { - MapTy = PointerType::getIntNPtrTy(C->getContext(), - DL.getTypeAllocSizeInBits(LoadTy), AS); + MapTy = PointerType::getIntNTy(C->getContext(), + DL.getTypeAllocSizeInBits(LoadTy)); } else return nullptr; - C = FoldBitCast(C, MapTy, DL); - if (Constant *Res = FoldReinterpretLoadFromConstPtr(C, DL)) + C = FoldBitCast(C, MapTy->getPointerTo(AS), DL); + if (Constant *Res = FoldReinterpretLoadFromConstPtr(C, MapTy, DL)) return FoldBitCast(Res, LoadTy, DL); return nullptr; } @@ -479,13 +479,15 @@ static Constant *FoldReinterpretLoadFromConstPtr(Constant *C, } static Constant *ConstantFoldLoadThroughBitcast(ConstantExpr *CE, + Type *DestTy, const DataLayout &DL) { - auto *DestPtrTy = dyn_cast(CE->getType()); - if (!DestPtrTy) + auto *SrcPtr = CE->getOperand(0); + auto *SrcPtrTy = dyn_cast(SrcPtr->getType()); + if (!SrcPtrTy) return nullptr; - Type *DestTy = DestPtrTy->getElementType(); + Type *SrcTy = SrcPtrTy->getPointerElementType(); - Constant *C = ConstantFoldLoadFromConstPtr(CE->getOperand(0), DL); + Constant *C = ConstantFoldLoadFromConstPtr(SrcPtr, SrcTy, DL); if (!C) return nullptr; @@ -524,7 +526,7 @@ static Constant *ConstantFoldLoadThroughBitcast(ConstantExpr *CE, /// Return the value that a load from C would produce if it is constant and /// determinable. If this is not determinable, return null. -Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C, +Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, const DataLayout &DL) { // First, try the easy cases: if (GlobalVariable *GV = dyn_cast(C)) @@ -533,7 +535,7 @@ Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C, if (auto *GA = dyn_cast(C)) if (GA->getAliasee() && !GA->mayBeOverridden()) - return ConstantFoldLoadFromConstPtr(GA->getAliasee(), DL); + return ConstantFoldLoadFromConstPtr(GA->getAliasee(), Ty, DL); // If the loaded value isn't a constant expr, we can't handle it. ConstantExpr *CE = dyn_cast(C); @@ -551,7 +553,7 @@ Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C, } if (CE->getOpcode() == Instruction::BitCast) - if (Constant *LoadedC = ConstantFoldLoadThroughBitcast(CE, DL)) + if (Constant *LoadedC = ConstantFoldLoadThroughBitcast(CE, Ty, DL)) return LoadedC; // Instead of loading constant c string, use corresponding integer value @@ -559,7 +561,6 @@ Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C, StringRef Str; if (getConstantStringInfo(CE, Str) && !Str.empty()) { unsigned StrLen = Str.size(); - Type *Ty = cast(CE->getType())->getElementType(); unsigned NumBits = Ty->getPrimitiveSizeInBits(); // Replace load with immediate integer if the result is an integer or fp // value. @@ -594,16 +595,15 @@ Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C, if (GlobalVariable *GV = dyn_cast(GetUnderlyingObject(CE, DL))) { if (GV->isConstant() && GV->hasDefinitiveInitializer()) { - Type *ResTy = cast(C->getType())->getElementType(); if (GV->getInitializer()->isNullValue()) - return Constant::getNullValue(ResTy); + return Constant::getNullValue(Ty); if (isa(GV->getInitializer())) - return UndefValue::get(ResTy); + return UndefValue::get(Ty); } } // Try hard to fold loads from bitcasted strange and non-type-safe things. - return FoldReinterpretLoadFromConstPtr(CE, DL); + return FoldReinterpretLoadFromConstPtr(CE, Ty, DL); } static Constant *ConstantFoldLoadInst(const LoadInst *LI, @@ -611,7 +611,7 @@ static Constant *ConstantFoldLoadInst(const LoadInst *LI, if (LI->isVolatile()) return nullptr; if (Constant *C = dyn_cast(LI->getOperand(0))) - return ConstantFoldLoadFromConstPtr(C, DL); + return ConstantFoldLoadFromConstPtr(C, LI->getType(), DL); return nullptr; } diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp index 1300ec9560c7..61e7296d05f6 100644 --- a/llvm/lib/Analysis/InstructionSimplify.cpp +++ b/llvm/lib/Analysis/InstructionSimplify.cpp @@ -3261,7 +3261,7 @@ static const Value *SimplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp, if (LoadInst *LI = dyn_cast(I)) if (!LI->isVolatile()) - return ConstantFoldLoadFromConstPtr(ConstOps[0], Q.DL); + return ConstantFoldLoadFromConstPtr(ConstOps[0], LI->getType(), Q.DL); return ConstantFoldInstOperands(I, ConstOps, Q.DL, Q.TLI); } diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index dc580dfdf263..88361d6c1af3 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -5915,7 +5915,7 @@ static Constant *EvaluateExpression(Value *V, const Loop *L, Operands[1], DL, TLI); if (LoadInst *LI = dyn_cast(I)) { if (!LI->isVolatile()) - return ConstantFoldLoadFromConstPtr(Operands[0], DL); + return ConstantFoldLoadFromConstPtr(Operands[0], LI->getType(), DL); } return ConstantFoldInstOperands(I, Operands, DL, TLI); } @@ -6303,7 +6303,7 @@ const SCEV *ScalarEvolution::computeSCEVAtScope(const SCEV *V, const Loop *L) { Operands[1], DL, &TLI); else if (const LoadInst *LI = dyn_cast(I)) { if (!LI->isVolatile()) - C = ConstantFoldLoadFromConstPtr(Operands[0], DL); + C = ConstantFoldLoadFromConstPtr(Operands[0], LI->getType(), DL); } else C = ConstantFoldInstOperands(I, Operands, DL, &TLI); if (!C) return V; diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index 3b8d3094b3a8..bc255b725da0 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -5450,7 +5450,7 @@ static SDValue getMemCmpLoad(const Value *PtrVal, MVT LoadVT, PointerType::getUnqual(LoadTy)); if (const Constant *LoadCst = ConstantFoldLoadFromConstPtr( - const_cast(LoadInput), *Builder.DL)) + const_cast(LoadInput), LoadTy, *Builder.DL)) return Builder.getValue(LoadCst); } diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp index 5f55db64e05f..8d3c86f4f1e4 100644 --- a/llvm/lib/Transforms/Scalar/GVN.cpp +++ b/llvm/lib/Transforms/Scalar/GVN.cpp @@ -1117,7 +1117,7 @@ static int AnalyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr, Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src, OffsetCst); Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS)); - if (ConstantFoldLoadFromConstPtr(Src, DL)) + if (ConstantFoldLoadFromConstPtr(Src, LoadTy, DL)) return Offset; return -1; } @@ -1279,7 +1279,7 @@ static Value *GetMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset, Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src, OffsetCst); Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS)); - return ConstantFoldLoadFromConstPtr(Src, DL); + return ConstantFoldLoadFromConstPtr(Src, LoadTy, DL); } diff --git a/llvm/lib/Transforms/Scalar/SCCP.cpp b/llvm/lib/Transforms/Scalar/SCCP.cpp index d966678e520f..4b18679a9c43 100644 --- a/llvm/lib/Transforms/Scalar/SCCP.cpp +++ b/llvm/lib/Transforms/Scalar/SCCP.cpp @@ -1094,7 +1094,7 @@ void SCCPSolver::visitLoadInst(LoadInst &I) { } // Transform load from a constant into a constant if possible. - if (Constant *C = ConstantFoldLoadFromConstPtr(Ptr, DL)) { + if (Constant *C = ConstantFoldLoadFromConstPtr(Ptr, I.getType(), DL)) { if (isa(C)) return; return markConstant(IV, &I, C);