Subzero, MIPS32: Remove duplicate functionalities

src/IceTargetLoweringMIPS32.cpp

 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Implements the TargetLoweringMIPS32 class, which consists almost
@@ skipping 1821 matching lines @@
   Operand *Src0 = legalizeUndef(Instr->getSrc(0));
   Operand *Src1 = legalizeUndef(Instr->getSrc(1));
   if (DestTy == IceType_i64) {
     lowerInt64Arithmetic(Instr, Instr->getDest(), Src0, Src1);
     return;
   }
   if (isVectorType(Dest->getType())) {
     UnimplementedLoweringError(this, Instr);
     return;
   }
-  switch (Instr->getOp()) {
-  default:
-    break;
-  case InstArithmetic::Frem:
-    UnimplementedLoweringError(this, Instr);
-    return;
-  }
 
-  // At this point Dest->getType() is non-i64 scalar
-
   Variable *T = makeReg(Dest->getType());
   Variable *Src0R = legalizeToReg(Src0);
   Variable *Src1R = legalizeToReg(Src1);
   constexpr uint32_t DivideByZeroTrapCode = 7;
 
   switch (Instr->getOp()) {
   case InstArithmetic::_num:
     break;
   case InstArithmetic::Add:
     _addu(T, Src0R, Src1R);
@@ skipping 110 matching lines @@
       _mov(Dest, T);
       return;
     }
     if (DestTy == IceType_f64) {
       _div_d(T, Src0R, Src1R);
       _mov(Dest, T);
       return;
     }
     break;
   case InstArithmetic::Frem:
+    llvm::report_fatal_error("frem should have been prelowered.");
     break;
   }
   UnimplementedLoweringError(this, Instr);
 }
 
 void TargetMIPS32::lowerAssign(const InstAssign *Instr) {
   Variable *Dest = Instr->getDest();
 
   if (Dest->isRematerializable()) {
     Context.insert<InstFakeDef>(Dest);
@@ skipping 416 matching lines @@
   case InstCast::Fpext: {
     assert(Dest->getType() == IceType_f64);
     assert(Src0->getType() == IceType_f32);
     auto *DestR = legalizeToReg(Dest);
     auto *Src0R = legalizeToReg(Src0);
     _cvt_d_s(DestR, Src0R);
     _mov(Dest, DestR);
     break;
   }
   case InstCast::Fptosi: {
+    if (llvm::isa<Variable64On32>(Dest)) {
+      llvm::report_fatal_error("fp-to-i64 should have been prelowered.");
+      return;      
+    }
     if (Src0Ty == IceType_f32 && DestTy == IceType_i32) {
       Variable *Src0R = legalizeToReg(Src0);
       Variable *FTmp = makeReg(IceType_f32);
       _trunc_w_s(FTmp, Src0R);
       _mov(Dest, FTmp);
     } else {
       UnimplementedLoweringError(this, Instr);
     }
     break;
   }
   case InstCast::Fptoui:
+    if (llvm::isa<Variable64On32>(Dest)) {
+      llvm::report_fatal_error("fp-to-i64 should have been prelowered.");
+      return;      
+    }
     UnimplementedLoweringError(this, Instr);
     break;
   case InstCast::Sitofp: {
+    if (llvm::isa<Variable64On32>(Dest)) {
+      llvm::report_fatal_error("i64-to-fp should have been prelowered.");
+      return;      
+    }
     if (Src0Ty == IceType_i32 && DestTy == IceType_f32) {
       Variable *Src0R = legalizeToReg(Src0);
       Variable *FTmp1 = makeReg(IceType_f32);
       Variable *FTmp2 = makeReg(IceType_f32);
       _mov(FTmp1, Src0R);
       _cvt_s_w(FTmp2, FTmp1);
       _mov(Dest, FTmp2);
     } else {
       UnimplementedLoweringError(this, Instr);
     }
     break;
   }
   case InstCast::Uitofp: {
+    if (llvm::isa<Variable64On32>(Dest)) {
+      llvm::report_fatal_error("i64-to-fp should have been prelowered.");
+      return;      
+    }
     UnimplementedLoweringError(this, Instr);
     break;
   }
   case InstCast::Bitcast: {
-    UnimplementedLoweringError(this, Instr);
+    switch (DestTy) {
+    case IceType_NUM:
+    case IceType_void:
+      llvm::report_fatal_error("Unexpected bitcast.");
+    case IceType_i1:
+      UnimplementedLoweringError(this, Instr);
+      break;
+    case IceType_i8:
+      assert(Src0->getType() == IceType_v8i1);
+      llvm::report_fatal_error(
+          "i8 to v8i1 conversion should have been prelowered.");
+      break;
+    case IceType_i16:
+      assert(Src0->getType() == IceType_v16i1);
+      llvm::report_fatal_error(
+          "i16 to v16i1 conversion should have been prelowered.");
+      break;
+    case IceType_v8i1:
+      assert(Src0->getType() == IceType_i8);
+      llvm::report_fatal_error(
+          "v8i1 to i8 conversion should have been prelowered.");
+      break;
+    case IceType_v16i1:
+      assert(Src0->getType() == IceType_i16);
+      llvm::report_fatal_error(
+          "v16i1 to i16 conversion should have been prelowered.");
+      break;
+    default:
+      UnimplementedLoweringError(this, Instr);
+    }
     break;
   }
   }
 }
 
 void TargetMIPS32::lowerExtractElement(const InstExtractElement *Instr) {
   UnimplementedLoweringError(this, Instr);
 }
 
 void TargetMIPS32::lowerFcmp(const InstFcmp *Instr) {
@@ skipping 338 matching lines @@
     return;
   case Intrinsics::AtomicStore: {
     UnimplementedLoweringError(this, Instr);
     return;
   }
   case Intrinsics::Bswap: {
     UnimplementedLoweringError(this, Instr);
     return;
   }
   case Intrinsics::Ctpop: {
-    UnimplementedLoweringError(this, Instr);
+    llvm::report_fatal_error("Ctpop should have been prelowered.");
     return;
   }
   case Intrinsics::Ctlz: {
     UnimplementedLoweringError(this, Instr);
     return;
   }
   case Intrinsics::Cttz: {
     UnimplementedLoweringError(this, Instr);
     return;
   }
   case Intrinsics::Fabs: {
     if (isScalarFloatingType(DestTy)) {
       Variable *T = makeReg(DestTy);
       if (DestTy == IceType_f32) {
         _abs_s(T, legalizeToReg(Instr->getArg(0)));
       } else {
         _abs_d(T, legalizeToReg(Instr->getArg(0)));
       }
       _mov(Dest, T);
     }
     return;
   }
   case Intrinsics::Longjmp: {
-    InstCall *Call = makeHelperCall(RuntimeHelper::H_call_longjmp, nullptr, 2);
-    Call->addArg(Instr->getArg(0));
-    Call->addArg(Instr->getArg(1));
-    lowerCall(Call);
+    llvm::report_fatal_error("longjmp should have been prelowered.");
     return;
   }
   case Intrinsics::Memcpy: {
-    // In the future, we could potentially emit an inline memcpy/memset, etc.
-    // for intrinsic calls w/ a known length.
-    InstCall *Call = makeHelperCall(RuntimeHelper::H_call_memcpy, nullptr, 3);
-    Call->addArg(Instr->getArg(0));
-    Call->addArg(Instr->getArg(1));
-    Call->addArg(Instr->getArg(2));
-    lowerCall(Call);
+    llvm::report_fatal_error("memcpy should have been prelowered.");
     return;
   }
   case Intrinsics::Memmove: {
-    InstCall *Call = makeHelperCall(RuntimeHelper::H_call_memmove, nullptr, 3);
-    Call->addArg(Instr->getArg(0));
-    Call->addArg(Instr->getArg(1));
-    Call->addArg(Instr->getArg(2));
-    lowerCall(Call);
+    llvm::report_fatal_error("memmove should have been prelowered.");
     return;
   }
   case Intrinsics::Memset: {
-    // The value operand needs to be extended to a stack slot size because the
-    // PNaCl ABI requires arguments to be at least 32 bits wide.
-    Operand *ValOp = Instr->getArg(1);
-    assert(ValOp->getType() == IceType_i8);
-    Variable *ValExt = Func->makeVariable(stackSlotType());
-    lowerCast(InstCast::create(Func, InstCast::Zext, ValExt, ValOp));
-    InstCall *Call = makeHelperCall(RuntimeHelper::H_call_memset, nullptr, 3);
-    Call->addArg(Instr->getArg(0));
-    Call->addArg(ValExt);
-    Call->addArg(Instr->getArg(2));
-    lowerCall(Call);
+    llvm::report_fatal_error("memset should have been prelowered.");
     return;
   }
   case Intrinsics::NaClReadTP: {
     if (getFlags().getUseSandboxing()) {
       UnimplementedLoweringError(this, Instr);
     } else {
       InstCall *Call =
           makeHelperCall(RuntimeHelper::H_call_read_tp, Instr->getDest(), 0);
       lowerCall(Call);
     }
     return;
   }
   case Intrinsics::Setjmp: {
-    InstCall *Call =
-        makeHelperCall(RuntimeHelper::H_call_setjmp, Instr->getDest(), 1);
-    Call->addArg(Instr->getArg(0));
-    lowerCall(Call);
+    llvm::report_fatal_error("setjmp should have been prelowered.");
     return;
   }
   case Intrinsics::Sqrt: {
     if (isScalarFloatingType(DestTy)) {
       Variable *T = makeReg(DestTy);
       if (DestTy == IceType_f32) {
         _sqrt_s(T, legalizeToReg(Instr->getArg(0)));
       } else {
         _sqrt_d(T, legalizeToReg(Instr->getArg(0)));
       }
@@ skipping 835 matching lines @@
   Str << "\t.set\t"
       << "nomips16\n";
 }
 
 SmallBitVector TargetMIPS32::TypeToRegisterSet[RCMIPS32_NUM];
 SmallBitVector TargetMIPS32::TypeToRegisterSetUnfiltered[RCMIPS32_NUM];
 SmallBitVector TargetMIPS32::RegisterAliases[RegMIPS32::Reg_NUM];
 
 } // end of namespace MIPS32
 } // end of namespace Ice