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

[spatel]

Summary

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.

This is a preliminary patch to enable a fix for:
http://llvm.org/bugs/show_bug.cgi?id=20802
[SLP vectorizer] fast-math and wrap/exact flags are not preserved.

[majnemer]

lib/IR/Instructions.cpp

2033–2049 ↗

(On Diff #13131)

You could shorten this a bit by doing two things:

1. Folding the dyn_cast into the if
2. Using auto for the type of the variables, the dyn_cast makes unambiguous.

test/Transforms/LoopVectorize/exact.ll

3–4 ↗

(On Diff #13131)

Space between ; and CHECK.

[spatel]

Thanks, David! Patch updated.

[aschwaighofer]

LGTM.

Thanks!

lib/IR/Instructions.cpp

2038 ↗

(On Diff #13133)

Nitpick: Can you put a newline below this line for symmetry?

[spatel]

Closed by commit rL216886 (authored by @spatel).

[spatel]

Thanks, Arnold! Checked in with r216886.

llvm/trunk/include/llvm/IR/InstrTypes.h

#undef DEFINE_HELPERS
   bool hasNoUnsignedWrap() const;
 
   /// hasNoSignedWrap - Determine whether the no signed wrap flag is set.
   bool hasNoSignedWrap() const;
 
   /// 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();
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };

llvm/trunk/lib/IR/Instructions.cpp

 bool BinaryOperator::hasNoSignedWrap() const {
   return cast<OverflowingBinaryOperator>(this)->hasNoSignedWrap();
 }
 
 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
 //===----------------------------------------------------------------------===//
 
 /// getFPAccuracy - Get the maximum error permitted by this operation in ULPs.
 /// An accuracy of 0.0 means that the operation should be performed with the
 /// default precision.
 float FPMathOperator::getFPAccuracy() const {

llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp

case Instruction::Xor: {
       setDebugLocFromInst(Builder, BinOp);
       VectorParts &A = getVectorValue(it->getOperand(0));
       VectorParts &B = getVectorValue(it->getOperand(1));
 
       // Use this vector value for all users of the original instruction.
       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;
       }
 
       propagateMetadata(Entry, it);
       break;
     }
     case Instruction::Select: {
       // Widen selects.

llvm/trunk/test/Transforms/LoopVectorize/exact.ll

+; 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
+}