Subzero. ARM32. Implements vector 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 843 matching lines @@
       scalarizeInstruction(
           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);
-                           },
-                           llvm::cast<Variable>(SelectInstr->getSrc(0)),
-                           llvm::cast<Variable>(SelectInstr->getSrc(1)),
-                           llvm::cast<Variable>(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 4828 matching lines @@
   Context.insert<InstFakeUse>(SP);
 }
 
 void TargetARM32::lowerSelect(const InstSelect *Instr) {
   Variable *Dest = Instr->getDest();
   Type DestTy = Dest->getType();
   Operand *SrcT = Instr->getTrueOperand();
   Operand *SrcF = Instr->getFalseOperand();
   Operand *Condition = Instr->getCondition();
 
-  if (isVectorType(DestTy)) {
-    UnimplementedLoweringError(this, Instr);
+  if (!isVectorType(DestTy)) {
+    lowerInt1ForSelect(Dest, Condition, legalizeUndef(SrcT),
+                       legalizeUndef(SrcF));
     return;
   }
 
-  lowerInt1ForSelect(Dest, Condition, legalizeUndef(SrcT), legalizeUndef(SrcF));
+  Type TType = DestTy;
+  switch (DestTy) {
+  default:
+    llvm::report_fatal_error("Unexpected type for vector select.");
+  case IceType_v4i1:
+    TType = IceType_v4i32;
+    break;
+  case IceType_v8i1:
+    TType = IceType_v8i16;
+    break;
+  case IceType_v16i1:
+    TType = IceType_v16i8;
+    break;
+  case IceType_v4f32:
+    TType = IceType_v4i32;
+    break;
+  case IceType_v4i32:
+  case IceType_v8i16:
+  case IceType_v16i8:
+    break;
+  }
+  auto *T = makeReg(TType);
+  lowerCast(InstCast::create(Func, InstCast::Sext, T, Condition));
+  auto *SrcTR = legalizeToReg(SrcT);
+  auto *SrcFR = legalizeToReg(SrcF);
+  _vbsl(T, SrcTR, SrcFR)->setDestRedefined();
+  _mov(Dest, T);
 }
 
 void TargetARM32::lowerStore(const InstStore *Instr) {
   Operand *Value = Instr->getData();
   Operand *Addr = Instr->getAddr();
   OperandARM32Mem *NewAddr = formMemoryOperand(Addr, Value->getType());
   Type Ty = NewAddr->getType();
 
   if (Ty == IceType_i64) {
     Value = legalizeUndef(Value);
@@ skipping 1239 matching lines @@
   // However, for compatibility with current NaCl LLVM, don't claim that.
   Str << ".eabi_attribute 14, 3   @ Tag_ABI_PCS_R9_use: Not used\n";
 }
 
 SmallBitVector TargetARM32::TypeToRegisterSet[RegARM32::RCARM32_NUM];
 SmallBitVector TargetARM32::TypeToRegisterSetUnfiltered[RegARM32::RCARM32_NUM];
 SmallBitVector TargetARM32::RegisterAliases[RegARM32::Reg_NUM];
 
 } // end of namespace ARM32
 } // end of namespace Ice