Add hybrid assembler concept to 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 66 matching lines @@
 
 void InstARM32Pred::dumpOpcodePred(Ostream &Str, const char *Opcode,
                                    Type Ty) const {
   Str << Opcode << getPredicate() << "." << Ty;
 }
 
 CondARM32::Cond InstARM32::getOppositeCondition(CondARM32::Cond Cond) {
   return InstARM32CondAttributes[Cond].Opposite;
 }
 
+void InstARM32::emitUsingTextFixup(const Cfg *Func) const {
+  GlobalContext *Ctx = Func->getContext();
+  if (!BuildDefs::dump() || !Ctx->getFlags().getAllowHybridAssembly())
+    UnimplementedError(Ctx->getFlags());
+  std::string Buffer;
+  llvm::raw_string_ostream StrBuf(Buffer);
+  OstreamLocker L(Ctx);
+  Ostream &OldStr = Ctx->getStrEmit();
+  Ctx->setStrEmit(StrBuf);
+  emit(Func);
+  Ctx->setStrEmit(OldStr);
+  ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
+  Asm->emitTextInst(StrBuf.str());
+}
+
+void InstARM32::emitIAS(const Cfg *Func) const { emitUsingTextFixup(Func); }
+
 void InstARM32Pred::emitUnaryopGPR(const char *Opcode,
                                    const InstARM32Pred *Inst, const Cfg *Func,
                                    bool NeedsWidthSuffix) {
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(Inst->getSrcSize() == 1);
   Type SrcTy = Inst->getSrc(0)->getType();
   Str << "\t" << Opcode;
   if (NeedsWidthSuffix)
     Str << getWidthString(SrcTy);
   Str << Inst->getPredicate() << "\t";
@@ skipping 216 matching lines @@
   }
   if (TargetTrue == OldNode) {
     TargetTrue = NewNode;
     Found = true;
   }
   return Found;
 }
 
 template <InstARM32::InstKindARM32 K>
 void InstARM32ThreeAddrGPR<K>::emitIAS(const Cfg *Func) const {
-  (void)Func;
-  UnimplementedError(Func->getContext()->getFlags());
+  emitUsingTextFixup(Func);
 }
 
 template <>
 void InstARM32ThreeAddrGPR<InstARM32::Add>::emitIAS(const Cfg *Func) const {
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
-  Asm->add(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
+  if (!Asm->add(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate()))
+    emitUsingTextFixup(Func);
 }
 
 template <>
 void InstARM32ThreeAddrGPR<InstARM32::Sub>::emitIAS(const Cfg *Func) const {
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
-  Asm->sub(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
+  if (!Asm->sub(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate()))
+    emitUsingTextFixup(Func);
 }
 
 InstARM32Call::InstARM32Call(Cfg *Func, Variable *Dest, Operand *CallTarget)
     : InstARM32(Func, InstARM32::Call, 1, Dest) {
   HasSideEffects = true;
   addSource(CallTarget);
 }
 
 InstARM32Label::InstARM32Label(Cfg *Func, TargetARM32 *Target)
     : InstARM32(Func, InstARM32::Label, 0, nullptr),
@@ skipping 256 matching lines @@
     const char *NoWidthString = "";
     const char *WidthString =
         isVectorType(Src0->getType()) ? ".64" : NoWidthString;
     Str << "\t" << ActualOpcode << getPredicate() << WidthString << "\t";
     Src0->emit(Func);
     Str << ", ";
     Dest->emit(Func);
   }
 }
 
-void InstARM32Mov::emitIASSingleDestSingleSource(const Cfg *Func) const {
+bool InstARM32Mov::emitIASSingleDestSingleSource(const Cfg *Func) const {
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Variable *Dest = getDest();
   Operand *Src0 = getSrc(0);
-  // Note: Loop is used so that we can short circuit using break.
-  do {
-    if (Dest->hasReg()) {
-      const Type DestTy = Dest->getType();
-      const bool DestIsVector = isVectorType(DestTy);
-      const bool DestIsScalarFP = isScalarFloatingType(DestTy);
-      const bool CoreVFPMove = isMoveBetweenCoreAndVFPRegisters(Dest, Src0);
-      if (DestIsVector || DestIsScalarFP || CoreVFPMove)
-        break;
-      if (isMemoryAccess(Src0)) {
-        // TODO(kschimpf) Figure out how to do ldr on CoreVPFMove? (see
-        // emitSingleDestSingleSource, local variable LoadOpcode).
-        Asm->ldr(Dest, Src0, getPredicate());
-      } else {
-        Asm->mov(Dest, Src0, getPredicate());
-      }
-      return;
-    } else {
-      const Type Src0Type = Src0->getType();
-      const bool Src0IsVector = isVectorType(Src0Type);
-      const bool Src0IsScalarFP = isScalarFloatingType(Src0Type);
-      const bool CoreVFPMove = isMoveBetweenCoreAndVFPRegisters(Dest, Src0);
-      if (Src0IsVector || Src0IsScalarFP || CoreVFPMove)
-        break;
-      Asm->str(Src0, Dest, getPredicate());
-      return;
+  if (Dest->hasReg()) {
+    const Type DestTy = Dest->getType();
+    const bool DestIsVector = isVectorType(DestTy);
+    const bool DestIsScalarFP = isScalarFloatingType(DestTy);
+    const bool CoreVFPMove = isMoveBetweenCoreAndVFPRegisters(Dest, Src0);
+    if (DestIsVector || DestIsScalarFP || CoreVFPMove)
+      return false;
+    if (isMemoryAccess(Src0)) {
+      // TODO(kschimpf) Figure out how to do ldr on CoreVPFMove? (see
+      // emitSingleDestSingleSource, local variable LoadOpcode).
+      return Asm->ldr(Dest, Src0, getPredicate());
     }
-  } while (0);
-  llvm_unreachable("not yet implemented");
+    return Asm->mov(Dest, Src0, getPredicate());
+  } else {
+    const Type Src0Type = Src0->getType();
+    const bool Src0IsVector = isVectorType(Src0Type);
+    const bool Src0IsScalarFP = isScalarFloatingType(Src0Type);
+    const bool CoreVFPMove = isMoveBetweenCoreAndVFPRegisters(Dest, Src0);
+    if (Src0IsVector || Src0IsScalarFP || CoreVFPMove)
+      return false;
+    return Asm->str(Src0, Dest, getPredicate());
+  }
+  return false;
 }
 
 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 {
   assert(getSrcSize() == 1);
   (void)Func;
   assert(!(isMultiDest() && isMultiSource()) && "Invalid vmov type.");
-  if (isMultiDest())
-    llvm_unreachable("Not yet implemented");
-  if (isMultiSource())
-    llvm_unreachable("Not yet implemented");
-  // Must be single source/dest.
-  emitIASSingleDestSingleSource(Func);
+  if (!(isMultiDest() || isMultiSource())) {
+    // Must be single source/dest.
+    if (emitIASSingleDestSingleSource(Func))
+      return;
+  }
+  emitUsingTextFixup(Func);
 }
 
 void InstARM32Mov::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   assert(getSrcSize() == 1 || getSrcSize() == 2);
   Ostream &Str = Func->getContext()->getStrDump();
   Variable *Dest = getDest();
   Variable *DestHi = getDestHi();
   Dest->dump(Func);
@@ skipping 23 matching lines @@
       Str << getTargetTrue()->getAsmName();
       if (getTargetFalse()) {
         Str << "\n\t"
             << "b"
             << "\t" << getTargetFalse()->getAsmName();
       }
     }
   }
 }
 
-void InstARM32Br::emitIAS(const Cfg *Func) const {
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Br::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "br ";
 
   if (getPredicate() == CondARM32::AL) {
     Str << "label %"
         << (Label ? Label->getName(Func) : getTargetFalse()->getName());
     return;
@@ skipping 28 matching lines @@
     CallTarget->emitWithoutPrefix(Func->getTarget());
   } else {
     Str << "\t"
         << "blx"
         << "\t";
     getCallTarget()->emit(Func);
   }
   Func->getTarget()->resetStackAdjustment();
 }
 
-void InstARM32Call::emitIAS(const Cfg *Func) const {
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Call::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (getDest()) {
     dumpDest(Func);
     Str << " = ";
   }
   Str << "call ";
   getCallTarget()->dump(Func);
 }
 
 void InstARM32Label::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << getName(Func) << ":";
 }
 
-void InstARM32Label::emitIAS(const Cfg *Func) const {
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Label::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << getName(Func) << ":";
 }
 
 template <> void InstARM32Ldr::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 1);
   assert(getDest()->hasReg());
   Variable *Dest = getDest();
   Type DestTy = Dest->getType();
   const bool DestIsVector = isVectorType(DestTy);
   const bool DestIsScalarFloat = isScalarFloatingType(DestTy);
   const char *ActualOpcode =
       DestIsVector ? "vld1" : (DestIsScalarFloat ? "vldr" : "ldr");
   const char *VectorMarker = DestIsVector ? ".64" : "";
   const char *WidthString = DestIsVector ? "" : getWidthString(DestTy);
   Str << "\t" << ActualOpcode << WidthString << getPredicate() << VectorMarker
       << "\t";
   getDest()->emit(Func);
   Str << ", ";
   getSrc(0)->emit(Func);
 }
 
-template <> void InstARM32Ldr::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 1);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 template <> void InstARM32Ldrex::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 1);
   assert(getDest()->hasReg());
   Variable *Dest = getDest();
   Type DestTy = Dest->getType();
   assert(isScalarIntegerType(DestTy));
   const char *WidthString = getWidthString(DestTy);
   Str << "\t" << Opcode << WidthString << getPredicate() << "\t";
   getDest()->emit(Func);
   Str << ", ";
   getSrc(0)->emit(Func);
 }
 
-template <> void InstARM32Ldrex::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 1);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
+template <InstARM32::InstKindARM32 K>
+void InstARM32TwoAddrGPR<K>::emitIAS(const Cfg *Func) const {
+  emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Movw::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 1);
   Str << "\t" << Opcode << getPredicate() << "\t";
   getDest()->emit(Func);
   Str << ", ";
@@ skipping 55 matching lines @@
     if (isScalarIntegerType(Op->getType()))
       continue;
     Str << "\t"
         << "vpop"
         << "\t{";
     Op->emit(Func);
     Str << "}\n";
   }
 }
 
-void InstARM32Pop::emitIAS(const Cfg *Func) const {
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Pop::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "pop"
       << " ";
   for (SizeT I = 0; I < Dests.size(); ++I) {
     if (I > 0)
       Str << ", ";
     Dests[I]->dump(Func);
   }
 }
 
 void InstARM32AdjustStack::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 2);
   Str << "\t"
       << "sub"
       << "\t";
   getDest()->emit(Func);
   Str << ", ";
   getSrc(0)->emit(Func);
   Str << ", ";
   getSrc(1)->emit(Func);
   Func->getTarget()->updateStackAdjustment(Amount);
 }
 
-void InstARM32AdjustStack::emitIAS(const Cfg *Func) const {
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-  Func->getTarget()->updateStackAdjustment(Amount);
-}
-
 void InstARM32AdjustStack::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   getDest()->dump(Func);
   Str << " = sub.i32 ";
   getSrc(0)->dump(Func);
   Str << ", " << Amount << " ; ";
   getSrc(1)->dump(Func);
 }
@@ skipping 30 matching lines @@
         if (PrintComma)
           Str << ", ";
         Op->emit(Func);
         PrintComma = true;
       }
     }
     Str << "}\n";
   }
 }
 
-void InstARM32Push::emitIAS(const Cfg *Func) const {
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Push::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "push"
       << " ";
   dumpSources(Func);
 }
 
 void InstARM32Ret::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   assert(getSrcSize() > 0);
   Variable *LR = llvm::cast<Variable>(getSrc(0));
   assert(LR->hasReg());
   assert(LR->getRegNum() == RegARM32::Reg_lr);
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t"
       << "bx"
       << "\t";
   LR->emit(Func);
 }
 
 void InstARM32Ret::emitIAS(const Cfg *Func) const {
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
-  Asm->bx(RegARM32::Encoded_Reg_lr);
+  if (!Asm->bx(RegARM32::Encoded_Reg_lr))
+    emitUsingTextFixup(Func);
 }
 
 void InstARM32Ret::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Type Ty = (getSrcSize() == 1 ? IceType_void : getSrc(0)->getType());
   Str << "ret." << Ty << " ";
   dumpSources(Func);
 }
 
 void InstARM32Str::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 2);
   Type Ty = getSrc(0)->getType();
   const bool IsVectorStore = isVectorType(Ty);
   const char *Opcode =
       IsVectorStore ? "vst1" : (isScalarFloatingType(Ty) ? "vstr" : "str");
   const char *VecEltWidthString = IsVectorStore ? ".64" : "";
   Str << "\t" << Opcode << getWidthString(Ty) << getPredicate()
       << VecEltWidthString << "\t";
   getSrc(0)->emit(Func);
   Str << ", ";
   getSrc(1)->emit(Func);
 }
 
-void InstARM32Str::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 2);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Str::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Type Ty = getSrc(0)->getType();
   dumpOpcodePred(Str, "str", Ty);
   Str << " ";
   getSrc(1)->dump(Func);
   Str << ", ";
   getSrc(0)->dump(Func);
 }
 
 void InstARM32Strex::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   assert(getSrcSize() == 2);
   Type Ty = getSrc(0)->getType();
   assert(isScalarIntegerType(Ty));
   Variable *Dest = getDest();
   Ostream &Str = Func->getContext()->getStrEmit();
   static constexpr char Opcode[] = "strex";
   const char *WidthString = getWidthString(Ty);
   Str << "\t" << Opcode << WidthString << getPredicate() << "\t";
   Dest->emit(Func);
   Str << ", ";
   emitSources(Func);
 }
 
-void InstARM32Strex::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 2);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Strex::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Variable *Dest = getDest();
   Dest->dump(Func);
   Str << " = ";
   Type Ty = getSrc(0)->getType();
   dumpOpcodePred(Str, "strex", Ty);
   Str << " ";
   getSrc(1)->dump(Func);
   Str << ", ";
   getSrc(0)->dump(Func);
 }
 
 void InstARM32Trap::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 0);
   // There isn't a mnemonic for the special NaCl Trap encoding, so dump
   // the raw bytes.
   Str << "\t.long 0x";
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   for (uint8_t I : Asm->getNonExecBundlePadding()) {
     Str.write_hex(I);
   }
 }
 
-void InstARM32Trap::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 0);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Trap::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "trap";
 }
 
 void InstARM32Umull::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 2);
   assert(getDest()->hasReg());
   Str << "\t"
       << "umull" << getPredicate() << "\t";
   getDest()->emit(Func);
   Str << ", ";
   DestHi->emit(Func);
   Str << ", ";
   getSrc(0)->emit(Func);
   Str << ", ";
   getSrc(1)->emit(Func);
 }
 
-void InstARM32Umull::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 2);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Umull::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = ";
   dumpOpcodePred(Str, "umull", getDest()->getType());
   Str << " ";
   dumpSources(Func);
 }
@@ skipping 32 matching lines @@
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 1);
   assert(getDest()->hasReg());
   Str << "\t"
       << "vcvt" << getPredicate() << vcvtVariantSuffix(Variant) << "\t";
   getDest()->emit(Func);
   Str << ", ";
   getSrc(0)->emit(Func);
 }
 
-void InstARM32Vcvt::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 1);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Vcvt::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = "
       << "vcvt" << getPredicate() << vcvtVariantSuffix(Variant) << " ";
   dumpSources(Func);
 }
 
 void InstARM32Vcmp::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 2);
   Str << "\t"
          "vcmp" << getPredicate() << getVecWidthString(getSrc(0)->getType())
       << "\t";
   getSrc(0)->emit(Func);
   Str << ", ";
   getSrc(1)->emit(Func);
 }
 
-void InstARM32Vcmp::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 2);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Vcmp::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "vcmp" << getPredicate() << getVecWidthString(getSrc(0)->getType());
   dumpSources(Func);
 }
 
 void InstARM32Vmrs::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 0);
   Str << "\t"
          "vmrs" << getPredicate() << "\t"
                                      "APSR_nzcv"
                                      ", "
                                      "FPSCR";
 }
 
-void InstARM32Vmrs::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 0);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Vmrs::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "APSR{n,z,v,c} = vmrs" << getPredicate() << "\t"
                                                      "FPSCR{n,z,c,v}";
 }
 
 void InstARM32Vabs::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 1);
   Str << "\t"
          "vabs" << getPredicate() << getVecWidthString(getSrc(0)->getType())
       << "\t";
   getDest()->emit(Func);
   Str << ", ";
   getSrc(0)->emit(Func);
 }
 
-void InstARM32Vabs::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 1);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Vabs::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = vabs" << getPredicate() << getVecWidthString(getSrc(0)->getType());
 }
 
 void InstARM32Dmb::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 0);
   Str << "\t"
          "dmb"
          "\t"
          "sy";
 }
 
-void InstARM32Dmb::emitIAS(const Cfg *Func) const {
-  assert(getSrcSize() == 1);
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
-}
-
 void InstARM32Dmb::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Func->getContext()->getStrDump() << "dmb\tsy";
 }
 
 void OperandARM32Mem::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
@@ skipping 121 matching lines @@
 template class InstARM32ThreeAddrGPR<InstARM32::Eor>;
 template class InstARM32ThreeAddrGPR<InstARM32::Lsl>;
 template class InstARM32ThreeAddrGPR<InstARM32::Lsr>;
 template class InstARM32ThreeAddrGPR<InstARM32::Mul>;
 template class InstARM32ThreeAddrGPR<InstARM32::Orr>;
 template class InstARM32ThreeAddrGPR<InstARM32::Rsb>;
 template class InstARM32ThreeAddrGPR<InstARM32::Sbc>;
 template class InstARM32ThreeAddrGPR<InstARM32::Sdiv>;
 template class InstARM32ThreeAddrGPR<InstARM32::Sub>;
 template class InstARM32ThreeAddrGPR<InstARM32::Udiv>;
+
 template class InstARM32ThreeAddrFP<InstARM32::Vadd>;
 template class InstARM32ThreeAddrFP<InstARM32::Vdiv>;
 template class InstARM32ThreeAddrFP<InstARM32::Vmul>;
 template class InstARM32ThreeAddrFP<InstARM32::Vsub>;
 
+template class InstARM32TwoAddrGPR<InstARM32::Movt>;
+
 } // end of namespace Ice