Add move vector to the integrated ARM assembler.

src/IceInstARM32.cpp

 //===- subzero/src/IceInstARM32.cpp - ARM32 instruction implementation ----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 1418 matching lines @@
   Type Ty = Dest->getType();
   const bool IsVector = isVectorType(Ty);
   const bool IsScalarFP = isScalarFloatingType(Ty);
   const bool CoreVFPMove = isMoveBetweenCoreAndVFPRegisters(Dest, Src0);
   const bool IsVMove = (IsVector || IsScalarFP || CoreVFPMove);
   const char *Opcode = IsVMove ? "vmov" : "mov";
   // when vmov{c}'ing, we need to emit a width string. Otherwise, the
   // assembler might be tempted to assume we want a vector vmov{c}, and that
   // is disallowed because ARM.
   const char *WidthString = !CoreVFPMove ? getVecWidthString(Ty) : "";
+  CondARM32::Cond Cond = getPredicate();

[Jim Stichnoth, 2016/02/12 01:38:55]

const

+  if (IsVector)

[John, 2016/02/11 23:59:54]

This is a serious error. Maybe llvm::report_fatal_error()?

+    assert(CondARM32::isUnconditional(Cond) &&
+           "Moves on vectors must be unconditional!");
   Str << "\t" << Opcode;
   if (IsVMove) {
-    Str << getPredicate() << WidthString;
+    Str << Cond << WidthString;
   } else {
-    Str << WidthString << getPredicate();
+    Str << WidthString << Cond;
   }
   Str << "\t";
   Dest->emit(Func);
   Str << ", ";
   Src0->emit(Func);
 }
 
 void InstARM32Mov::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   assert(!(isMultiDest() && isMultiSource()) && "Invalid vmov type.");
   if (isMultiDest()) {
     emitMultiDestSingleSource(Func);
     return;
   }
 
   if (isMultiSource()) {
     emitSingleDestMultiSource(Func);
     return;
   }
 
   emitSingleDestSingleSource(Func);
 }
 
 void InstARM32Mov::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
-  Variable *Dest = getDest();
+  const Variable *Dest = getDest();
   Operand *Src0 = getSrc(0);
+  const CondARM32::Cond Cond = getPredicate();
   if (!Dest->hasReg()) {
     llvm::report_fatal_error("mov can't store.");
   }
   if (isMemoryAccess(Src0)) {
     llvm::report_fatal_error("mov can't load.");
   }
 
   assert(!(isMultiDest() && isMultiSource()) && "Invalid vmov type.");
   if (isMultiDest()) {
-    Asm->vmovrrd(Dest, getDestHi(), Src0, getPredicate());
+    Asm->vmovrrd(Dest, getDestHi(), Src0, Cond);
     return;
   }
   if (isMultiSource()) {
-    Asm->vmovdrr(Dest, Src0, getSrc(1), getPredicate());
+    Asm->vmovdrr(Dest, Src0, getSrc(1), Cond);
     return;
   }
 
   const Type DestTy = Dest->getType();
   const Type SrcTy = Src0->getType();
   switch (DestTy) {
   default:
     break; // Error
   case IceType_i1:
   case IceType_i8:
   case IceType_i16:
   case IceType_i32:
     switch (SrcTy) {
     default:
       break; // Error
     case IceType_i1:
     case IceType_i8:
     case IceType_i16:
     case IceType_i32:
     case IceType_i64:
-      Asm->mov(Dest, Src0, getPredicate());
+      Asm->mov(Dest, Src0, Cond);
       return;
     case IceType_f32:
-      Asm->vmovrs(Dest, Src0, getPredicate());
+      Asm->vmovrs(Dest, Src0, Cond);
       return;
     }
     break; // Error
   case IceType_i64:
     if (isScalarIntegerType(SrcTy)) {
-      Asm->mov(Dest, Src0, getPredicate());
+      Asm->mov(Dest, Src0, Cond);
       return;
     }
     if (SrcTy == IceType_f64) {
       if (const auto *Var = llvm::dyn_cast<Variable>(Src0)) {
-        Asm->vmovdd(Dest, Var, getPredicate());
+        Asm->vmovdd(Dest, Var, Cond);
         return;
       }
       if (const auto *FpImm = llvm::dyn_cast<OperandARM32FlexFpImm>(Src0)) {
-        Asm->vmovd(Dest, FpImm, getPredicate());
+        Asm->vmovd(Dest, FpImm, Cond);
         return;
       }
     }
     break; // Error
   case IceType_f32:
     switch (SrcTy) {
     default:
       break; // Error
     case IceType_i1:
     case IceType_i8:
     case IceType_i16:
     case IceType_i32:
-      return Asm->vmovsr(Dest, Src0, getPredicate());
+      return Asm->vmovsr(Dest, Src0, Cond);
     case IceType_f32:
       if (const auto *Var = llvm::dyn_cast<Variable>(Src0)) {
-        Asm->vmovss(Dest, Var, getPredicate());
+        Asm->vmovss(Dest, Var, Cond);
         return;
       }
       if (const auto *FpImm = llvm::dyn_cast<OperandARM32FlexFpImm>(Src0)) {
-        Asm->vmovs(Dest, FpImm, getPredicate());
+        Asm->vmovs(Dest, FpImm, Cond);
         return;
       }
       break; // Error
     }
     break; // Error
   case IceType_f64:
     if (SrcTy == IceType_f64) {
       if (const auto *Var = llvm::dyn_cast<Variable>(Src0)) {
-        Asm->vmovdd(Dest, Var, getPredicate());
+        Asm->vmovdd(Dest, Var, Cond);
         return;
       }
       if (const auto *FpImm = llvm::dyn_cast<OperandARM32FlexFpImm>(Src0)) {
-        Asm->vmovd(Dest, FpImm, getPredicate());
+        Asm->vmovd(Dest, FpImm, Cond);
         return;
       }
     }
     break; // Error
   case IceType_v4i1:
   case IceType_v8i1:
   case IceType_v16i1:
   case IceType_v16i8:
   case IceType_v8i16:
   case IceType_v4i32:
   case IceType_v4f32:
-    // TODO(kschimpf): Add vector moves.
-    emitUsingTextFixup(Func);
+    assert(CondARM32::isUnconditional(Cond) &&
+           "Moves on <4 x f32> must be unconditional!");
+    assert(SrcTy == DestTy && "Mov on different vector types");
+    Asm->vorrq(Dest, Src0, Src0);
     return;
   }
   llvm::report_fatal_error("Mov: don't know how to move " +
                            typeIceString(SrcTy) + " to " +
                            typeIceString(DestTy));
 }
 
 void InstARM32Mov::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
@@ skipping 1188 matching lines @@
 
 template class InstARM32FourAddrGPR<InstARM32::Mla>;
 template class InstARM32FourAddrGPR<InstARM32::Mls>;
 
 template class InstARM32CmpLike<InstARM32::Cmn>;
 template class InstARM32CmpLike<InstARM32::Cmp>;
 template class InstARM32CmpLike<InstARM32::Tst>;
 
 } // end of namespace ARM32
 } // end of namespace Ice