ARM32 Vector lowering - scalarize select

src/IceTargetLoweringARM32.cpp

 //===- subzero/src/IceTargetLoweringARM32.cpp - ARM32 lowering ------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 565 matching lines @@
     llvm::report_fatal_error("Control flow should never have reached here.");
   }
   case Inst::Cast: {
     Variable *Dest = Instr->getDest();
     Operand *Src0 = Instr->getSrc(0);
     const Type DestTy = Dest->getType();
     auto *CastInstr = llvm::cast<InstCast>(Instr);
     const InstCast::OpKind CastKind = CastInstr->getCastKind();
 
     if (isVectorType(DestTy)) {
-      scalarizeUnaryInstruction(
-          Dest, Src0, [this, CastKind](Variable *Dest, Variable *Src) {
+      scalarizeInstruction(
+          Dest, [this, CastKind](Variable *Dest, Variable *Src) {
             return Context.insert<InstCast>(CastKind, Dest, Src);
-          });
+          }, Src0);
       CastInstr->setDeleted();
       return;
     }
 
     switch (CastKind) {
     default:
       return;
     case InstCast::Fptosi:
     case InstCast::Fptoui: {
       if (DestTy != IceType_i64) {
@@ skipping 135 matching lines @@
     }
     llvm::report_fatal_error("Control flow should never have reached here.");
   }
   case Inst::Icmp: {
     Variable *Dest = Instr->getDest();
     const Type DestTy = Dest->getType();
     if (isVectorType(DestTy)) {
       auto *CmpInstr = llvm::cast<InstIcmp>(Instr);
       const auto Condition = CmpInstr->getCondition();
       scalarizeInstruction(
-          Dest, CmpInstr->getSrc(0), CmpInstr->getSrc(1),
+          Dest,
           [this, Condition](Variable *Dest, Variable *Src0, Variable *Src1) {
             return Context.insert<InstIcmp>(Condition, Dest, Src0, Src1);
-          });
+          },
+          CmpInstr->getSrc(0), CmpInstr->getSrc(1));
       CmpInstr->setDeleted();
     }
     return;
   }
   case Inst::Fcmp: {
     Variable *Dest = Instr->getDest();
     const Type DestTy = Dest->getType();
     if (isVectorType(DestTy)) {
       auto *CmpInstr = llvm::cast<InstFcmp>(Instr);
       const auto Condition = CmpInstr->getCondition();
       scalarizeInstruction(
-          Dest, CmpInstr->getSrc(0), CmpInstr->getSrc(1),
+          Dest,
           [this, Condition](Variable *Dest, Variable *Src0, Variable *Src1) {
             return Context.insert<InstFcmp>(Condition, Dest, Src0, Src1);
-          });
+          },
+          CmpInstr->getSrc(0), CmpInstr->getSrc(1));
       CmpInstr->setDeleted();
     }
     return;
   }
+  case Inst::Select: {
+    Variable *Dest = Instr->getDest();
+    const auto DestTy = Dest->getType();
+    if (isVectorType(DestTy)) {
+      auto *SelectInstr = llvm::cast<InstSelect>(Instr);
+      scalarizeInstruction(Dest,
+                           [this](Variable *Dest, Variable *Src0,
+                                  Variable *Src1, Variable *Src2) {
+                             return Context.insert<InstSelect>(Dest, Src0, Src1,
+                                                               Src2);
+                           },
+                           SelectInstr->getSrc(0), SelectInstr->getSrc(1),
+                           SelectInstr->getSrc(2));
+      SelectInstr->setDeleted();
+    }
+    return;
+  }
   }
 }
 
 void TargetARM32::findMaxStackOutArgsSize() {
   // MinNeededOutArgsBytes should be updated if the Target ever creates a
   // high-level InstCall that requires more stack bytes.
   constexpr size_t MinNeededOutArgsBytes = 0;
   MaxOutArgsSizeBytes = MinNeededOutArgsBytes;
   for (CfgNode *Node : Func->getNodes()) {
     Context.init(Node);
@@ skipping 5845 matching lines @@
   Str << ".eabi_attribute 14, 3   @ Tag_ABI_PCS_R9_use: Not used\n";
 }
 
 llvm::SmallBitVector TargetARM32::TypeToRegisterSet[RegARM32::RCARM32_NUM];
 llvm::SmallBitVector
     TargetARM32::TypeToRegisterSetUnfiltered[RegARM32::RCARM32_NUM];
 llvm::SmallBitVector TargetARM32::RegisterAliases[RegARM32::Reg_NUM];
 
 } // end of namespace ARM32
 } // end of namespace Ice