[SubZero] Generate relocations for MIPS

src/IceInstMIPS32.cpp

 //===- subzero/src/IceInstMips32.cpp - Mips32 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 44 matching lines @@
   Vars = &this->Base;
 }
 
 const char *InstMIPS32::getWidthString(Type Ty) {
   (void)Ty;
   return "TBD";
 }
 
 template <> const char *InstMIPS32Abs_d::Opcode = "abs.d";
 template <> const char *InstMIPS32Abs_s::Opcode = "abs.s";
+template <> const char *InstMIPS32Addi::Opcode = "addi";
 template <> const char *InstMIPS32Add::Opcode = "add";
 template <> const char *InstMIPS32Add_d::Opcode = "add.d";
 template <> const char *InstMIPS32Add_s::Opcode = "add.s";
 template <> const char *InstMIPS32Addiu::Opcode = "addiu";
 template <> const char *InstMIPS32Addu::Opcode = "addu";
 template <> const char *InstMIPS32And::Opcode = "and";
 template <> const char *InstMIPS32Andi::Opcode = "andi";
 template <> const char *InstMIPS32C_eq_d::Opcode = "c.eq.d";
 template <> const char *InstMIPS32C_eq_s::Opcode = "c.eq.s";
 template <> const char *InstMIPS32C_ole_d::Opcode = "c.ole.d";
@@ skipping 461 matching lines @@
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 1);
   if (llvm::isa<ConstantInteger32>(getCallTarget())) {
     // This shouldn't happen (typically have to copy the full 32-bits to a
     // register and do an indirect jump).
     llvm::report_fatal_error("MIPS2Call to ConstantInteger32");
   } else if (const auto *CallTarget =
                  llvm::dyn_cast<ConstantRelocatable>(getCallTarget())) {
-    // Calls only have 24-bits, but the linker should insert veneers to extend
+    // Calls only have 26-bits, but the linker should insert veneers to extend
     // the range if needed.
     Str << "\t"
            "jal"
            "\t";
     CallTarget->emitWithoutPrefix(Func->getTarget());
   } else {
     Str << "\t"
            "jal"
            "\t";
     getCallTarget()->emit(Func);
   }
 }
 
 void InstMIPS32Call::emitIAS(const Cfg *Func) const {
-  (void)Func;
-  llvm_unreachable("Not yet implemented");
+  assert(getSrcSize() == 1);
+  auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
+  if (const auto *CallTarget =
+          llvm::dyn_cast<ConstantRelocatable>(getCallTarget())) {
+    Asm->jal(CallTarget);
+  } else {
+    llvm::report_fatal_error("MIPS32Call: Invalid operand");
+  }
 }
 
 void InstMIPS32Call::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (getDest()) {
     dumpDest(Func);
     Str << " = ";
   }
@@ skipping 76 matching lines @@
     Str << "\t" << ActualOpcode << "\t";
     getDest()->emit(Func);
     Str << ", ";
     getSrc(0)->emit(Func);
     return;
   }
 
   llvm::report_fatal_error("Invalid mov instruction. Dest or Src is memory.");
 }
 
-// TODO(jaydeep.patil) Handle all types of operands in mov
 void InstMIPS32Mov::emitIAS(const Cfg *Func) const {
   Variable *Dest = getDest();
   Operand *Src = getSrc(0);
   auto *SrcV = llvm::dyn_cast<Variable>(Src);
   assert(!llvm::isa<Constant>(Src));
   const bool DestIsReg = Dest->hasReg();
   const bool SrcIsReg = (SrcV && SrcV->hasReg());
 
   // reg to reg
   if (DestIsReg && SrcIsReg) {
     auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
     Asm->move(getDest(), getSrc(0));
     return;
   }
-  llvm_unreachable("Not yet implemented");
+
+  llvm::report_fatal_error("InstMIPS32Mov invalid operands");
 }
 
 void InstMIPS32Mov::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);
   if (DestHi) {
     Str << ", ";
     DestHi->dump(Func);
   }
   dumpOpcode(Str, " = mov", getDest()->getType());
   Str << " ";
   dumpSources(Func);
 }
 
 template <> void InstMIPS32Abs_d::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->abs_d(getDest(), getSrc(0));
 }
 
 template <> void InstMIPS32Abs_s::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->abs_s(getDest(), getSrc(0));
 }
 
+template <> void InstMIPS32Addi::emitIAS(const Cfg *Func) const {
+  auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
+  Asm->addi(getDest(), getSrc(0), Imm);
+}
+
 template <> void InstMIPS32Add_d::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->add_d(getDest(), getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Add_s::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->add_s(getDest(), getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Addiu::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
-  Asm->addiu(getDest(), getSrc(0), Imm);
+  if (Reloc == RO_No) {
+    Asm->addiu(getDest(), getSrc(0), Imm);
+  } else {
+    Asm->addiu(getDest(), getSrc(0), getSrc(1), Reloc);
+  }
 }
 
 template <> void InstMIPS32Addu::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->addu(getDest(), getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32And::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->and_(getDest(), getSrc(0), getSrc(1));
@@ skipping 104 matching lines @@
   Asm->cvt_s_l(getDest(), getSrc(0));
 }
 
 template <> void InstMIPS32Cvt_s_w::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->cvt_s_w(getDest(), getSrc(0));
 }
 
 template <> void InstMIPS32Div::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
-  Asm->div(getDest(), getSrc(0));
+  Asm->div(getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Div_d::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->div_d(getDest(), getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Div_s::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->div_s(getDest(), getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Divu::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
-  Asm->divu(getDest(), getSrc(0));
+  Asm->divu(getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Lui::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
-  auto *C32 = llvm::dyn_cast<ConstantInteger32>(getSrc(0));
-  uint16_t Imm = static_cast<uint16_t>(C32->getValue());
-  Asm->lui(getDest(), Imm);
+  Asm->lui(getDest(), getSrc(0), Reloc);
+}
+
+template <> void InstMIPS32Ldc1::emitIAS(const Cfg *Func) const {
+  auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
+  auto *Mem = llvm::dyn_cast<OperandMIPS32Mem>(getSrc(0));
+  Asm->ldc1(getDest(), Mem->getBase(), Mem->getOffset(), Reloc);
 }
 
 template <> void InstMIPS32Lw::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   auto *Mem = llvm::dyn_cast<OperandMIPS32Mem>(getSrc(0));
   ConstantInteger32 *Offset = llvm::cast<ConstantInteger32>(Mem->getOffset());
   uint32_t Imm = static_cast<uint32_t>(Offset->getValue());
   Asm->lw(getDest(), Mem->getBase(), Imm);
 }
 
+template <> void InstMIPS32Lwc1::emitIAS(const Cfg *Func) const {
+  auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
+  auto *Mem = llvm::dyn_cast<OperandMIPS32Mem>(getSrc(0));
+  Asm->lwc1(getDest(), Mem->getBase(), Mem->getOffset(), Reloc);
+}
+
 template <> void InstMIPS32Mfc1::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->mfc1(getDest(), getSrc(0));
 }
 
 template <> void InstMIPS32Mflo::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   emitUnaryopGPRFLoHi(Opcode, this, Func);
 }
@@ skipping 70 matching lines @@
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 1);
   Str << "\t" << Opcode << "\t";
   getSrc(0)->emit(Func);
   Str << ", ";
   getDest()->emit(Func);
 }
 
 template <> void InstMIPS32Mtc1::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
-  Asm->mtc1(getDest(), getSrc(0));
+  Asm->mtc1(getSrc(0), getDest());
 }
 
 template <> void InstMIPS32Mtlo::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   emitUnaryopGPRTLoHi(Opcode, this, Func);
 }
 
 template <> void InstMIPS32Mtlo::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
@@ skipping 25 matching lines @@
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->mul_s(getDest(), getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Mult::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   emitThreeAddrLoHi(Opcode, this, Func);
 }
 
+template <> void InstMIPS32Mult::emitIAS(const Cfg *Func) const {
+  auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
+  Asm->mult(getDest(), getSrc(0));
+}
+
 template <> void InstMIPS32Multu::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   emitThreeAddrLoHi(Opcode, this, Func);
 }
 
 template <> void InstMIPS32Multu::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
-  Asm->multu(getDest(), getSrc(0));
+  Asm->multu(getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Nor::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->nor(getDest(), getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Or::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->or_(getDest(), getSrc(0), getSrc(1));
@@ skipping 72 matching lines @@
 template <> void InstMIPS32Sub_s::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->sub_s(getDest(), getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Subu::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->subu(getDest(), getSrc(0), getSrc(1));
 }
 
+template <> void InstMIPS32Sdc1::emitIAS(const Cfg *Func) const {
+  auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
+  auto *Mem = llvm::dyn_cast<OperandMIPS32Mem>(getSrc(0));
+  Asm->sdc1(getSrc(0), Mem->getBase(), Mem->getOffset(), Reloc);
+}
+
 template <> void InstMIPS32Sw::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   auto *Mem = llvm::dyn_cast<OperandMIPS32Mem>(getSrc(1));
   ConstantInteger32 *Offset = llvm::cast<ConstantInteger32>(Mem->getOffset());
   uint32_t Imm = static_cast<uint32_t>(Offset->getValue());
   Asm->sw(getSrc(0), Mem->getBase(), Imm);
 }
 
+template <> void InstMIPS32Swc1::emitIAS(const Cfg *Func) const {
+  auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
+  auto *Mem = llvm::dyn_cast<OperandMIPS32Mem>(getSrc(0));
+  Asm->swc1(getSrc(0), Mem->getBase(), Mem->getOffset(), Reloc);
+}
+
 template <> void InstMIPS32Teq::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->teq(getSrc(0), getSrc(1), getTrapCode());
 }
 
 template <> void InstMIPS32Trunc_l_d::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->trunc_l_d(getDest(), getSrc(0));
 }
 
@@ skipping 17 matching lines @@
   Asm->xor_(getDest(), getSrc(0), getSrc(1));
 }
 
 template <> void InstMIPS32Xori::emitIAS(const Cfg *Func) const {
   auto *Asm = Func->getAssembler<MIPS32::AssemblerMIPS32>();
   Asm->xori(getDest(), getSrc(0), Imm);
 }
 
 } // end of namespace MIPS32
 } // end of namespace Ice