[LoopVectorize] Merge UnaryOperator and BinaryOperator handling

[craig.topper]

Summary

This is a follow up to D62510 where UnaryOperator was added. It was suggested that we have common handling for UnaryOperator and BinaryOperator

[fhahn]

LGTM, IMO it makes sense to add this helper here.

llvm/include/llvm/IR/IRBuilder.h

1386

Maybe worth a comment that it either creates a binop or unaryop and Opc must be valid accordingly.

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

3988

nit: Could be just `

for (Value *Op : operands())  
   Ops.push_back(getOrCreateVectorValue(Op, Part));

[craig.topper]

Merged into D62510

llvm/include/llvm/IR/IRBuilder.h

Value *CreateUnOp(Instruction::UnaryOps Opc,
     if (auto *VC = dyn_cast<Constant>(V))
       return Insert(Folder.CreateUnOp(Opc, VC), Name);
     Instruction *UnOp = UnaryOperator::Create(Opc, V);
     if (isa<FPMathOperator>(UnOp))
       UnOp = setFPAttrs(UnOp, FPMathTag, FMF);
     return Insert(UnOp, Name);
   }
 
+  Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
+                      const Twine &Name = "",
+                      MDNode *FPMathTag = nullptr) {
+    if (Instruction::isBinaryOp(Opc)) {
+      assert(Ops.size() == 2 && "Invalid number of operands!");
+      return CreateBinOp(static_cast<Instruction::BinaryOps>(Opc),
+                         Ops[0], Ops[1], Name, FPMathTag);
+    }
+    if (Instruction::isUnaryOp(Opc)) {
+      assert(Ops.size() == 1 && "Invalid number of operands!");
+      return CreateUnOp(static_cast<Instruction::UnaryOps>(Opc),
+                        Ops[0], Name, FPMathTag);
+    }
+    llvm_unreachable("Unexpected opcode!");
+  }
+
   //===--------------------------------------------------------------------===//
   // Instruction creation methods: Memory Instructions
   //===--------------------------------------------------------------------===//
 
   AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
                            Value *ArraySize = nullptr, const Twine &Name = "") {
     return Insert(new AllocaInst(Ty, AddrSpace, ArraySize), Name);
   }

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

void InnerLoopVectorizer::widenInstruction(Instruction &I) {
   case Instruction::UDiv:
   case Instruction::SDiv:
   case Instruction::SRem:
   case Instruction::URem:
   case Instruction::Add:
   case Instruction::FAdd:
   case Instruction::Sub:
   case Instruction::FSub:
+  case Instruction::FNeg:
   case Instruction::Mul:
   case Instruction::FMul:
   case Instruction::FDiv:
   case Instruction::FRem:
   case Instruction::Shl:
   case Instruction::LShr:
   case Instruction::AShr:
   case Instruction::And:
   case Instruction::Or:
   case Instruction::Xor: {
-    // Just widen binops.
-    auto *BinOp = cast<BinaryOperator>(&I);
-    setDebugLocFromInst(Builder, BinOp);
+    // Just widen unops and binops.
+    setDebugLocFromInst(Builder, &I);
 
     for (unsigned Part = 0; Part < UF; ++Part) {
-      Value *A = getOrCreateVectorValue(BinOp->getOperand(0), Part);
-      Value *B = getOrCreateVectorValue(BinOp->getOperand(1), Part);
-      Value *V = Builder.CreateBinOp(BinOp->getOpcode(), A, B);
-
-      if (BinaryOperator *VecOp = dyn_cast<BinaryOperator>(V))
-        VecOp->copyIRFlags(BinOp);
-
-      // Use this vector value for all users of the original instruction.
-      VectorLoopValueMap.setVectorValue(&I, Part, V);
-      addMetadata(V, BinOp);
+      SmallVector<Value *, 2> Ops;
+      for (unsigned i = 0; i != I.getNumOperands(); ++i) {
+        Value *V = getOrCreateVectorValue(I.getOperand(i), Part);
+        Ops.push_back(V);
       }
+      Value *V = Builder.CreateNAryOp(I.getOpcode(), Ops);
 
-    break;
-  }
-  case Instruction::FNeg: {
-    // Just widen unary ops.
-    auto *UnOp = cast<UnaryOperator>(&I);
-    setDebugLocFromInst(Builder, UnOp);
-
-    for (unsigned Part = 0; Part < UF; ++Part) {
-      Value *A = getOrCreateVectorValue(UnOp->getOperand(0), Part);
-      Value *V = Builder.CreateUnOp(UnOp->getOpcode(), A);
-
-      if (UnaryOperator *VecOp = dyn_cast<UnaryOperator>(V))
-        VecOp->copyIRFlags(UnOp);
+      if (auto *VecOp = dyn_cast<Instruction>(V))
+        VecOp->copyIRFlags(&I);
 
       // Use this vector value for all users of the original instruction.
       VectorLoopValueMap.setVectorValue(&I, Part, V);
-      addMetadata(V, UnOp);
+      addMetadata(V, &I);
     }
 
     break;
   }
   case Instruction::Select: {
     // Widen selects.
     // If the selector is loop invariant we can create a select
     // instruction with a scalar condition. Otherwise, use vector-select.