Subzero. Eliminates the use of Variable64On32 as operands in ARM.

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 362 matching lines @@
   addSource(Src1);
 }
 
 InstARM32Vcvt::InstARM32Vcvt(Cfg *Func, Variable *Dest, Variable *Src,
                              VcvtVariant Variant, CondARM32::Cond Predicate)
     : InstARM32Pred(Func, InstARM32::Vcvt, 1, Dest, Predicate),
       Variant(Variant) {
   addSource(Src);
 }
 
+InstARM32Mov::InstARM32Mov(Cfg *Func, Variable *Dest, Operand *Src,
+                           CondARM32::Cond Predicate)
+    : InstARM32Pred(Func, InstARM32::Mov, 2, Dest, Predicate) {
+  auto *Dest64 = llvm::dyn_cast<Variable64On32>(Dest);
+  auto *Src64 = llvm::dyn_cast<Variable64On32>(Src);
+
+  assert(Dest64 == nullptr || Src64 == nullptr);
+
+  if (Dest64 != nullptr) {
+    // this-> is needed below because there is a parameter named Dest.
+    this->Dest = Dest64->getLo();
+    DestHi = Dest64->getHi();
+  }
+
+  if (Src64 == nullptr) {
+    addSource(Src);
+  } else {
+    addSource(Src64->getLo());
+    addSource(Src64->getHi());
+  }
+}
+
 InstARM32Vcmp::InstARM32Vcmp(Cfg *Func, Variable *Src0, Variable *Src1,
                              CondARM32::Cond Predicate)
     : InstARM32Pred(Func, InstARM32::Vcmp, 2, nullptr, Predicate) {
   addSource(Src0);
   addSource(Src1);
 }
 
 InstARM32Vmrs::InstARM32Vmrs(Cfg *Func, CondARM32::Cond Predicate)
     : InstARM32Pred(Func, InstARM32::Vmrs, 0, nullptr, Predicate) {}
 
@@ skipping 51 matching lines @@
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "[ARM32] ";
   Inst::dump(Func);
 }
 
 void InstARM32Mov::emitMultiDestSingleSource(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
-  auto *Dest = llvm::cast<Variable64On32>(getDest());
-  Operand *Src = getSrc(0);
+  Variable *DestLo = getDest();
+  Variable *DestHi = getDestHi();
+  auto *Src = llvm::cast<Variable>(getSrc(0));
 
-  assert(Dest->getType() == IceType_i64);
-  assert(Dest->getHi()->hasReg());
-  assert(Dest->getLo()->hasReg());
-  assert(!llvm::isa<OperandARM32Mem>(Src));
+  assert(DestHi->hasReg());
+  assert(DestLo->hasReg());
+  assert(llvm::isa<Variable>(Src) && Src->hasReg());
 
   Str << "\t"
       << "vmov" << getPredicate() << "\t";
-  Dest->getLo()->emit(Func);
+  DestLo->emit(Func);
   Str << ", ";
-  Dest->getHi()->emit(Func);
+  DestHi->emit(Func);
   Str << ", ";
   Src->emit(Func);
 }
 
 void InstARM32Mov::emitSingleDestMultiSource(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Variable *Dest = getDest();
-  auto *Src = llvm::cast<Variable64On32>(getSrc(0));
+  Variable *SrcLo = llvm::cast<Variable>(getSrc(0));
+  Variable *SrcHi = llvm::cast<Variable>(getSrc(1));
 
-  assert(Src->getType() == IceType_i64);
-  assert(Src->getHi()->hasReg());
-  assert(Src->getLo()->hasReg());
+  assert(SrcHi->hasReg());
+  assert(SrcLo->hasReg());
   assert(Dest->hasReg());
 
   Str << "\t"
       << "vmov" << getPredicate() << "\t";
   Dest->emit(Func);
   Str << ", ";
-  Src->getLo()->emit(Func);
+  SrcLo->emit(Func);
   Str << ", ";
-  Src->getHi()->emit(Func);
+  SrcHi->emit(Func);
 }
 
 namespace {
 
 bool isVariableWithoutRegister(const Operand *Op) {
   if (const auto *OpV = llvm::dyn_cast<const Variable>(Op)) {
     return !OpV->hasReg();
   }
   return false;
 }
@@ skipping 76 matching lines @@
 
 void InstARM32Mov::emitIAS(const Cfg *Func) const {
   assert(getSrcSize() == 1);
   (void)Func;
   llvm_unreachable("Not yet implemented");
 }
 
 void InstARM32Mov::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
-  assert(getSrcSize() == 1);
+  assert(getSrcSize() == 1 || getSrcSize() == 2);
   Ostream &Str = Func->getContext()->getStrDump();
   Variable *Dest = getDest();
-  if (auto *Dest64 = llvm::dyn_cast<Variable64On32>(Dest)) {
-    Dest64->getLo()->dump(Func);
+  Variable *DestHi = getDestHi();
+  Dest->dump(Func);
+  if (DestHi) {
     Str << ", ";
-    Dest64->getHi()->dump(Func);
-  } else {
-    Dest->dump(Func);
+    DestHi->dump(Func);
   }
 
   dumpOpcodePred(Str, " = mov", getDest()->getType());
   Str << " ";
 
-  Operand *Src = getSrc(0);
-  if (auto *Src64 = llvm::dyn_cast<Variable64On32>(Src)) {
-    Src64->getLo()->dump(Func);
-    Str << ", ";
-    Src64->getHi()->dump(Func);
-  } else {
-    Src->dump(Func);
-  }
+  dumpSources(Func);
 }
 
 void InstARM32Br::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t"
       << "b" << getPredicate() << "\t";
   if (Label) {
     Str << Label->getName(Func);
@@ skipping 661 matching lines @@
   if (getShiftOp() != kNoShift) {
     Str << ", " << InstARM32ShiftAttributes[getShiftOp()].EmitString << " ";
     if (Func)
       getShiftAmt()->dump(Func);
     else
       getShiftAmt()->dump(Str);
   }
 }
 
 } // end of namespace Ice