From dfe964ce8c367248e587f2d9ecc7fac5ee2c6fdc Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 8 Mar 2009 03:59:00 +0000 Subject: [PATCH] change the MemIntrinsic get/setAlignment method to take an unsigned instead of a Constant*, which is what the clients of it really want. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66364 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IntrinsicInst.h | 15 +++++++++------ lib/Transforms/Scalar/InstructionCombining.cpp | 10 +++++----- lib/Transforms/Scalar/MemCpyOptimizer.cpp | 10 ++++------ lib/Transforms/Scalar/ScalarReplAggregates.cpp | 6 +++--- 4 files changed, 21 insertions(+), 20 deletions(-) diff --git a/include/llvm/IntrinsicInst.h b/include/llvm/IntrinsicInst.h index 924fec26d27..8f5e05f70cd 100644 --- a/include/llvm/IntrinsicInst.h +++ b/include/llvm/IntrinsicInst.h @@ -176,9 +176,13 @@ namespace llvm { Value *getRawDest() const { return const_cast(getOperand(1)); } Value *getLength() const { return const_cast(getOperand(3)); } - ConstantInt *getAlignment() const { + ConstantInt *getAlignmentCst() const { return cast(const_cast(getOperand(4))); } + + unsigned getAlignment() const { + return getAlignmentCst()->getZExtValue(); + } /// getDest - This is just like getRawDest, but it strips off any cast /// instructions that feed it, giving the original input. The returned @@ -198,12 +202,11 @@ namespace llvm { "setLength called with value of wrong type!"); setOperand(3, L); } - void setAlignment(ConstantInt *A) { - assert(getAlignment()->getType() == A->getType() && - "setAlignment called with value of wrong type!"); - setOperand(4, A); + void setAlignment(unsigned A) { + const Type *Int32Ty = getOperand(4)->getType(); + setOperand(4, ConstantInt::get(Int32Ty, A)); } - + // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const MemIntrinsic *) { return true; } static inline bool classof(const IntrinsicInst *I) { diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 09722d9c492..86048e6a15e 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -9302,10 +9302,10 @@ Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) { unsigned DstAlign = GetOrEnforceKnownAlignment(MI->getOperand(1)); unsigned SrcAlign = GetOrEnforceKnownAlignment(MI->getOperand(2)); unsigned MinAlign = std::min(DstAlign, SrcAlign); - unsigned CopyAlign = MI->getAlignment()->getZExtValue(); + unsigned CopyAlign = MI->getAlignment(); if (CopyAlign < MinAlign) { - MI->setAlignment(ConstantInt::get(Type::Int32Ty, MinAlign)); + MI->setAlignment(MinAlign); return MI; } @@ -9377,8 +9377,8 @@ Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) { Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) { unsigned Alignment = GetOrEnforceKnownAlignment(MI->getDest()); - if (MI->getAlignment()->getZExtValue() < Alignment) { - MI->setAlignment(ConstantInt::get(Type::Int32Ty, Alignment)); + if (MI->getAlignment() < Alignment) { + MI->setAlignment(Alignment); return MI; } @@ -9388,7 +9388,7 @@ Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) { if (!LenC || !FillC || FillC->getType() != Type::Int8Ty) return 0; uint64_t Len = LenC->getZExtValue(); - Alignment = MI->getAlignment()->getZExtValue(); + Alignment = MI->getAlignment(); // If the length is zero, this is a no-op if (Len == 0) return MI; // memset(d,c,0,a) -> noop diff --git a/lib/Transforms/Scalar/MemCpyOptimizer.cpp b/lib/Transforms/Scalar/MemCpyOptimizer.cpp index be9db9692f2..fc9f5f26c9f 100644 --- a/lib/Transforms/Scalar/MemCpyOptimizer.cpp +++ b/lib/Transforms/Scalar/MemCpyOptimizer.cpp @@ -678,13 +678,11 @@ bool MemCpyOpt::processMemCpy(MemCpyInst* M) { M->getParent()->getParent()->getParent(), M->getIntrinsicID(), Tys, 1); - std::vector args; - args.push_back(M->getRawDest()); - args.push_back(MDep->getRawSource()); - args.push_back(M->getLength()); - args.push_back(M->getAlignment()); + Value *Args[4] = { + M->getRawDest(), MDep->getRawSource(), M->getLength(), M->getAlignmentCst() + }; - CallInst* C = CallInst::Create(MemCpyFun, args.begin(), args.end(), "", M); + CallInst* C = CallInst::Create(MemCpyFun, Args, Args+4, "", M); // If C and M don't interfere, then this is a valid transformation. If they diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp index 351ecea1dd6..644625f56a0 100644 --- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp +++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp @@ -725,7 +725,7 @@ void SROA::RewriteMemIntrinUserOfAlloca(MemIntrinsic *MI, Instruction *BCInst, // that doesn't have anything to do with the alloca that we are promoting. For // memset, this Value* stays null. Value *OtherPtr = 0; - unsigned MemAlignment = MI->getAlignment()->getZExtValue(); + unsigned MemAlignment = MI->getAlignment(); if (MemTransferInst *MTI = dyn_cast(MI)) { // memmove/memcopy if (BCInst == MTI->getRawDest()) OtherPtr = MTI->getRawSource(); @@ -1356,7 +1356,7 @@ bool SROA::CanConvertToScalar(Value *V, bool &IsNotTrivial, const Type *&VecTy, continue; } } - + // Ignore dbg intrinsic. if (isa(User)) continue; @@ -1440,7 +1440,7 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, uint64_t Offset) { MSI->eraseFromParent(); continue; } - + // If user is a dbg info intrinsic then it is safe to remove it. if (isa(User)) { User->eraseFromParent(); -- 2.34.1