Subzero, MIPS32: Add missing functions for genTargetHelperCallFor

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 291 matching lines @@
     const Type DestTy = Dest->getType();
     const Type SrcTy = Src0->getType();
     auto *CastInstr = llvm::cast<InstCast>(Instr);
     const InstCast::OpKind CastKind = CastInstr->getCastKind();
 
     switch (CastKind) {
     default:
       return;
     case InstCast::Fptosi:
     case InstCast::Fptoui: {
-      if (DestTy != IceType_i64) {
+      if ((DestTy != IceType_i32) && (DestTy != IceType_i64)) {
         return;
       }
+      const bool DestIs32 = DestTy == IceType_i32;
       const bool DestIsSigned = CastKind == InstCast::Fptosi;
       const bool Src0IsF32 = isFloat32Asserting32Or64(SrcTy);
-      Operand *TargetHelper = Ctx->getRuntimeHelperFunc(
-          Src0IsF32 ? (DestIsSigned ? RuntimeHelper::H_fptosi_f32_i64
-                                    : RuntimeHelper::H_fptoui_f32_i64)
-                    : (DestIsSigned ? RuntimeHelper::H_fptosi_f64_i64
-                                    : RuntimeHelper::H_fptoui_f64_i64));
+      RuntimeHelper RTHFunc = RuntimeHelper::H_Num;
+      if (DestIsSigned) {
+        if (DestIs32) {
+          return;
+        }
+        RTHFunc = Src0IsF32 ? RuntimeHelper::H_fptosi_f32_i64
+                            : RuntimeHelper::H_fptosi_f64_i64;
+      } else {
+        RTHFunc = Src0IsF32 ? (DestIs32 ? RuntimeHelper::H_fptoui_f32_i32
+                                        : RuntimeHelper::H_fptoui_f32_i64)
+                            : (DestIs32 ? RuntimeHelper::H_fptoui_f64_i32
+                                        : RuntimeHelper::H_fptoui_f64_i64);
+      }
+      Operand *TargetHelper = Ctx->getRuntimeHelperFunc(RTHFunc);
       static constexpr SizeT MaxArgs = 1;
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(Src0);
       Instr->setDeleted();
       return;
     }
     case InstCast::Sitofp:
     case InstCast::Uitofp: {
-      if (SrcTy != IceType_i64) {
+      if ((SrcTy != IceType_i32) && (SrcTy != IceType_i64)) {
         return;
       }
+      const bool SourceIs32 = SrcTy == IceType_i32;
       const bool SourceIsSigned = CastKind == InstCast::Sitofp;
       const bool DestIsF32 = isFloat32Asserting32Or64(Dest->getType());
-      Operand *TargetHelper = Ctx->getRuntimeHelperFunc(
-          DestIsF32 ? (SourceIsSigned ? RuntimeHelper::H_sitofp_i64_f32
-                                      : RuntimeHelper::H_uitofp_i64_f32)
-                    : (SourceIsSigned ? RuntimeHelper::H_sitofp_i64_f64
-                                      : RuntimeHelper::H_uitofp_i64_f64));
+      RuntimeHelper RTHFunc = RuntimeHelper::H_Num;
+      if (SourceIsSigned) {
+        if (SourceIs32) {
+          return;
+        }
+        RTHFunc = DestIsF32 ? RuntimeHelper::H_sitofp_i64_f32
+                            : RuntimeHelper::H_sitofp_i64_f64;
+      } else {
+        RTHFunc = DestIsF32 ? (SourceIs32 ? RuntimeHelper::H_uitofp_i32_f32
+                                          : RuntimeHelper::H_uitofp_i64_f32)
+                            : (SourceIs32 ? RuntimeHelper::H_uitofp_i32_f64
+                                          : RuntimeHelper::H_uitofp_i64_f64);
+      }
+      Operand *TargetHelper = Ctx->getRuntimeHelperFunc(RTHFunc);
       static constexpr SizeT MaxArgs = 1;
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(Src0);
       Instr->setDeleted();
       return;
     }
     case InstCast::Bitcast: {
       if (DestTy == SrcTy) {
         return;
@@ skipping 2226 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: {
+  case InstCast::Fptosi:
+  case InstCast::Fptoui: {
     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;
+    if (DestTy != IceType_i64) {
+      if (Src0Ty == IceType_f32 && isScalarIntegerType(DestTy)) {
+        Variable *Src0R = legalizeToReg(Src0);
+        Variable *FTmp = makeReg(IceType_f32);
+        _trunc_w_s(FTmp, Src0R);
+        _mov(Dest, FTmp);
+        return;
+      }
+      if (Src0Ty == IceType_f64 && isScalarIntegerType(DestTy)) {
+        Variable *Src0R = legalizeToReg(Src0);
+        Variable *FTmp = makeReg(IceType_f64);
+        _trunc_w_d(FTmp, Src0R);
+        _mov(Dest, FTmp);
+        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::Sitofp:
   case InstCast::Uitofp: {
     if (llvm::isa<Variable64On32>(Dest)) {
       llvm::report_fatal_error("i64-to-fp should have been prelowered.");
       return;
     }
+    if (Src0Ty != IceType_i64) {
+      if (isScalarIntegerType(Src0Ty) && DestTy == IceType_f32) {
+        Variable *Src0R = legalizeToReg(Src0);
+        Variable *FTmp1 = makeReg(IceType_f32);
+        Variable *FTmp2 = makeReg(IceType_f32);
+        _mtc1(FTmp1, Src0R);
+        _cvt_s_w(FTmp2, FTmp1);
+        _mov(Dest, FTmp2);
+        return;
+      }
+      if (isScalarIntegerType(Src0Ty) && DestTy == IceType_f64) {
+        Variable *Src0R = legalizeToReg(Src0);
+        Variable *FTmp1 = makeReg(IceType_f64);
+        Variable *FTmp2 = makeReg(IceType_f64);
+        _mtc1(FTmp1, Src0R);
+        _cvt_d_w(FTmp2, FTmp1);
+        _mov(Dest, FTmp2);
+        return;
+      }
+    }
     UnimplementedLoweringError(this, Instr);
     break;
   }
   case InstCast::Bitcast: {
+    Operand *Src0 = Instr->getSrc(0);
+    if (DestTy == Src0->getType()) {
+      auto *Assign = InstAssign::create(Func, Dest, Src0);
+      lowerAssign(Assign);
+      return;
+    }
     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(
@@ skipping 1335 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