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

Add a convenience method to copy wrapping, exact, and fast-math flags (NFC).

Browse Source 
The loop vectorizer preserves wrapping, exact, and fast-math properties of scalar instructions.
This patch adds a convenience method to make that operation easier because we need to do this
in the loop vectorizer, SLP vectorizer, and possibly other places.

Although this is a 'no functional change' patch, I've added a testcase to verify that the exact
flag is preserved by the loop vectorizer. The wrapping and fast-math flags are already checked
in existing testcases.

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



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@216886 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Sanjay Patel 2014-09-01 18:44:57 +00:00
parent 88350bf61d
commit 73f8eff19e
4 changed files with 47 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/IR/InstrTypes.h
View File

@ -358,6 +358,10 @@ public:
/// isExact - Determine whether the exact flag is set.
bool isExact() const;
/// Convenience method to copy wrapping, exact, and fast-math flag values
/// from V to this instruction.
void copyFlags(const Value *V);
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Instruction *I) {
return I->isBinaryOp();

16
lib/IR/Instructions.cpp
View File

@ -2030,6 +2030,22 @@ bool BinaryOperator::isExact() const {
return cast<PossiblyExactOperator>(this)->isExact();
}
void BinaryOperator::copyFlags(const Value *V) {
// Copy the wrapping flags.
if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
setHasNoSignedWrap(OB->hasNoSignedWrap());
setHasNoUnsignedWrap(OB->hasNoUnsignedWrap());
}
// Copy the exact flag.
if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
setIsExact(PE->isExact());
// Copy the fast-math flags.
if (auto *FP = dyn_cast<FPMathOperator>(V))
setFastMathFlags(FP->getFastMathFlags());
}
//===----------------------------------------------------------------------===//
// FPMathOperator Class
//===----------------------------------------------------------------------===//

16
lib/Transforms/Vectorize/LoopVectorize.cpp
View File

@ -3248,19 +3248,9 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) {
for (unsigned Part = 0; Part < UF; ++Part) {
Value *V = Builder.CreateBinOp(BinOp->getOpcode(), A[Part], B[Part]);
// Update the NSW, NUW and Exact flags. Notice: V can be an Undef.
BinaryOperator *VecOp = dyn_cast<BinaryOperator>(V);
if (VecOp && isa<OverflowingBinaryOperator>(BinOp)) {
VecOp->setHasNoSignedWrap(BinOp->hasNoSignedWrap());
VecOp->setHasNoUnsignedWrap(BinOp->hasNoUnsignedWrap());
}
if (VecOp && isa<PossiblyExactOperator>(VecOp))
VecOp->setIsExact(BinOp->isExact());
// Copy the fast-math flags.
if (VecOp && isa<FPMathOperator>(V))
VecOp->setFastMathFlags(it->getFastMathFlags());
if (BinaryOperator *VecOp = dyn_cast<BinaryOperator>(V))
VecOp->copyFlags(BinOp);
Entry[Part] = V;
}

24
test/Transforms/LoopVectorize/exact.ll Normal file
View File

@ -0,0 +1,24 @@
; RUN: opt < %s -loop-vectorize -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0"
; CHECK-LABEL: @lshr_exact(
; CHECK: lshr exact <4 x i32>
define void @lshr_exact(i32* %x) {
entry:
br label %for.body
for.body:
%iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
%arrayidx = getelementptr inbounds i32* %x, i64 %iv
%0 = load i32* %arrayidx, align 4
%conv1 = lshr exact i32 %0, 1
store i32 %conv1, i32* %arrayidx, align 4
%iv.next = add nuw nsw i64 %iv, 1
%exitcond = icmp eq i64 %iv.next, 256
br i1 %exitcond, label %for.end, label %for.body
for.end:
ret void
}