Add workaround to allow testing of ARM integrated 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 43 matching lines @@
   CondARM32::Cond Opposite;
   const char *EmitString;
 } InstARM32CondAttributes[] = {
 #define X(tag, encode, opp, emit)                                              \
   { CondARM32::opp, emit }                                                     \
   ,
     ICEINSTARM32COND_TABLE
 #undef X
 };
 
+// Holds the list of ARM assembler instructions that are safe (i.e. spec2k works
+// when these instructions are translated into bytes.
+static InstARM32::InstKindARM32 SafeIASMInsts[] = {

[Jim Stichnoth, 2015/11/03 00:21:42]

I think a blacklist of unsafe instructions would be much better than a whitelist
of safe instructions, because it's easier (commented out instructions
notwithstanding) to tell how close to completion you are.

[Karl, 2015/11/03 18:56:11]

Done.

+    // TODO(kschimpf): Figure out why commented out instructions are not
+    // (always)
+    // translated correctly.
+    InstARM32::Adc,  InstARM32::Add, InstARM32::And,
+    // InstARM32::Br,
+    InstARM32::Cmp,  InstARM32::Eor, InstARM32::Ldr,
+    // InstARM32::Mov,
+    // InstARM32::Movw,
+    // InstARM32::Movt,
+    InstARM32::Mul,  InstARM32::Orr, InstARM32::Sbc,
+    InstARM32::Sdiv, InstARM32::Str, InstARM32::Sub,
+    InstARM32::Udiv, InstARM32::Ret, InstARM32::Label};
+
 } // end of anonymous namespace
 
+bool InstARM32::isIasSafeImpl(InstKind Kind) const {
+  for (unsigned i = 0; i < llvm::array_lengthof(SafeIASMInsts); ++i) {

[Jim Stichnoth, 2015/11/03 00:21:42]

I realize it's only temporary, but this linear search offends my sense of
efficiency. :)

I think you could do something like this:

static std::unordered_set<uint32_t> SafeIASMInsts(
    {// TODO(kschimpf): Figure out why commented out instructions are not
     // (always)
     // translated correctly.
     InstARM32::Adc, InstARM32::Add, InstARM32::And,
     // InstARM32::Br,
     InstARM32::Cmp, InstARM32::Eor, InstARM32::Ldr,
     // InstARM32::Mov,
     // InstARM32::Movw,
     // InstARM32::Movt,
     InstARM32::Mul, InstARM32::Orr, InstARM32::Sbc, InstARM32::Sdiv,
     InstARM32::Str, InstARM32::Sub, InstARM32::Udiv, InstARM32::Ret,
     InstARM32::Label});

} // end of anonymous namespace

bool InstARM32::isIasSafeImpl(InstKind Kind) const {
  return SafeIASMInsts.find((uint32_t)Kind) != SafeIASMInsts.end();
}

[Karl, 2015/11/03 18:56:11]

Actually, reducing the footprint by moving this to a simpler test in each of
these four instructions.

+    if (static_cast<InstKind>(SafeIASMInsts[i]) == Kind)
+      return true;
+  }
+  return false;
+}
+
 const char *InstARM32::getWidthString(Type Ty) {
   return TypeARM32Attributes[Ty].WidthString;
 }
 
 const char *InstARM32::getVecWidthString(Type Ty) {
   return TypeARM32Attributes[Ty].VecWidthString;
 }
 
 const char *InstARM32Pred::predString(CondARM32::Cond Pred) {
   return InstARM32CondAttributes[Pred].EmitString;
@@ skipping 262 matching lines @@
   }
   return Found;
 }
 
 template <InstARM32::InstKindARM32 K>
 void InstARM32ThreeAddrGPR<K>::emitIAS(const Cfg *Func) const {
   emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Adc::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->adc(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Add::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->add(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32And::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->and_(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Eor::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->eor(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Orr::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->orr(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Mul::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->mul(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Sbc::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->sbc(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Sdiv::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   assert(!SetFlags);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->sdiv(getDest(), getSrc(0), getSrc(1), getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Sub::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->sub(getDest(), getSrc(0), getSrc(1), SetFlags, getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Udiv::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   assert(!SetFlags);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->udiv(getDest(), getSrc(0), getSrc(1), getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 InstARM32Call::InstARM32Call(Cfg *Func, Variable *Dest, Operand *CallTarget)
     : InstARM32(Func, InstARM32::Call, 1, Dest) {
   HasSideEffects = true;
@@ skipping 84 matching lines @@
     addSource(Src64->getHi());
   }
 }
 
 template <InstARM32::InstKindARM32 K>
 void InstARM32CmpLike<K>::emitIAS(const Cfg *Func) const {
   emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Cmp::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   assert(getSrcSize() == 2);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->cmp(getSrc(0), getSrc(1), getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 InstARM32Vcmp::InstARM32Vcmp(Cfg *Func, Variable *Src0, Variable *Src1,
                              CondARM32::Cond Predicate)
     : InstARM32Pred(Func, InstARM32::Vcmp, 2, nullptr, Predicate) {
@@ skipping 217 matching lines @@
 
   if (isMultiSource()) {
     emitSingleDestMultiSource(Func);
     return;
   }
 
   emitSingleDestSingleSource(Func);
 }
 
 void InstARM32Mov::emitIAS(const Cfg *Func) const {
-  (void)Func;
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   assert(!(isMultiDest() && isMultiSource()) && "Invalid vmov type.");
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   if (!(isMultiDest() || isMultiSource())) {
     // Must be single source/dest.
     emitIASSingleDestSingleSource(Func);
   }
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
@@ skipping 32 matching lines @@
       if (getTargetFalse()) {
         Str << "\n\t"
             << "b"
             << "\t" << getTargetFalse()->getAsmName();
       }
     }
   }
 }
 
 void InstARM32Br::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   if (Label) {
     Asm->b(Asm->getOrCreateLocalLabel(Label->getNumber()), getPredicate());
   } else if (isUnconditionalBranch()) {
     Asm->b(Asm->getOrCreateCfgNodeLabel(getTargetFalse()->getIndex()),
            getPredicate());
   } else {
     Asm->b(Asm->getOrCreateCfgNodeLabel(getTargetTrue()->getIndex()),
            getPredicate());
     if (const CfgNode *False = getTargetFalse())
@@ skipping 64 matching lines @@
 }
 
 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 {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
-  Asm->bindLocalLabel(Number);
+  Asm->bindLocalLabel(Func, this, Number);
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 void InstARM32Label::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << getName(Func) << ":";
 }
@@ skipping 18 matching lines @@
   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 {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   assert(getSrcSize() == 1);
   Variable *Dest = getDest();
   Type DestTy = Dest->getType();
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   if (isVectorType(DestTy) || isScalarFloatingType(DestTy))
     // TODO(kschimpf) Handle case.
     Asm->setNeedsTextFixup();
   else
     Asm->ldr(Dest, getSrc(0), getPredicate());
   if (Asm->needsTextFixup())
@@ skipping 37 matching lines @@
   Constant *Src0 = llvm::cast<Constant>(getSrc(0));
   if (auto *CR = llvm::dyn_cast<ConstantRelocatable>(Src0)) {
     Str << "#:lower16:";
     CR->emitWithoutPrefix(Func->getTarget());
   } else {
     Src0->emit(Func);
   }
 }
 
 template <> void InstARM32Movw::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   assert(getSrcSize() == 1);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->movw(getDest(), getSrc(0), getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 template <> void InstARM32Movt::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 2);
   Variable *Dest = getDest();
   Constant *Src1 = llvm::cast<Constant>(getSrc(1));
   Str << "\t" << Opcode << getPredicate() << "\t";
   Dest->emit(Func);
   Str << ", ";
   if (auto *CR = llvm::dyn_cast<ConstantRelocatable>(Src1)) {
     Str << "#:upper16:";
     CR->emitWithoutPrefix(Func->getTarget());
   } else {
     Src1->emit(Func);
   }
 }
 
 template <> void InstARM32Movt::emitIAS(const Cfg *Func) const {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   assert(getSrcSize() == 2);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->movt(getDest(), getSrc(1), getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 void InstARM32Pop::emit(const Cfg *Func) const {
   // TODO(jpp): Improve FP register save/restore.
   if (!BuildDefs::dump())
@@ skipping 128 matching lines @@
   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 {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   Asm->bx(RegARM32::Encoded_Reg_lr);
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
 }
 
 void InstARM32Ret::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
@@ skipping 13 matching lines @@
       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 {
+  if (!isIasSafe(getKind()))
+    return emitUsingTextFixup(Func);
   assert(getSrcSize() == 2);
   Type Ty = getSrc(0)->getType();
   ARM32::AssemblerARM32 *Asm = Func->getAssembler<ARM32::AssemblerARM32>();
   if (isVectorType(Ty) || isScalarFloatingType(Ty))
     // TODO(kschimpf) Handle case.
     Asm->setNeedsTextFixup();
   else
     Asm->str(getSrc(0), getSrc(1), getPredicate());
   if (Asm->needsTextFixup())
     emitUsingTextFixup(Func);
@@ skipping 373 matching lines @@
 template class InstARM32UnaryopGPR<InstARM32::Rbit, false>;
 template class InstARM32UnaryopGPR<InstARM32::Rev, false>;
 template class InstARM32UnaryopGPR<InstARM32::Sxt, true>;
 template class InstARM32UnaryopGPR<InstARM32::Uxt, true>;
 template class InstARM32UnaryopFP<InstARM32::Vsqrt>;
 
 template class InstARM32CmpLike<InstARM32::Cmp>;
 template class InstARM32CmpLike<InstARM32::Tst>;
 
 } // end of namespace Ice