[SubZero] Fix code generation issues occurred in Cross-test and PNaCL smoke-tests

src/IceTargetLoweringMIPS32.h

 //===- subzero/src/IceTargetLoweringMIPS32.h - MIPS32 lowering ---*- C++-*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 374 matching lines @@
       Instr->setDestRedefined();
       if (Instr->getDestHi() != nullptr) {
         // If Instr is multi-dest, then Dest must be a Variable64On32. We add a
         // fake-def for Instr.DestHi here.
         assert(llvm::isa<Variable64On32>(Dest));
         Context.insert<InstFakeDef>(Instr->getDestHi());
       }
     }
   }
 
+  void _mov_fp64_to_i64(Variable *Dest, Operand *Src, Int64Part Int64HiLo) {
+    assert(Dest != nullptr);
+    Context.insert<InstMIPS32MovFP64ToI64>(Dest, Src, Int64HiLo);
+  }
+
   void _mov_d(Variable *Dest, Variable *Src) {
     Context.insert<InstMIPS32Mov_d>(Dest, Src);
   }
 
   void _mov_s(Variable *Dest, Variable *Src) {
     Context.insert<InstMIPS32Mov_s>(Dest, Src);
   }
 
   void _movf(Variable *Dest, Variable *Src0, Operand *FCC) {
     Context.insert<InstMIPS32Movf>(Dest, Src0, FCC)->setDestRedefined();
@@ skipping 247 matching lines @@
   Operand *legalize(Operand *From, LegalMask Allowed = Legal_Default,
                     RegNumT RegNum = RegNumT());
 
   Variable *legalizeToVar(Operand *From, RegNumT RegNum = RegNumT());
 
   Variable *legalizeToReg(Operand *From, RegNumT RegNum = RegNumT());
 
   Variable *makeReg(Type Ty, RegNumT RegNum = RegNumT());
 
   Variable *getZero() {
-    return getPhysicalRegister(RegMIPS32::Reg_ZERO, IceType_i32);
+    auto *Zero = makeReg(IceType_i32, RegMIPS32::Reg_ZERO);
+    Context.insert<InstFakeDef>(Zero);
+    return Zero;
   }
 
   Variable *I32Reg(RegNumT RegNum = RegNumT()) {
     return makeReg(IceType_i32, RegNum);
   }
 
   Variable *F32Reg(RegNumT RegNum = RegNumT()) {
     return makeReg(IceType_f32, RegNum);
   }
 
@@ skipping 129 matching lines @@
 
     /// Legalizes Immediate if larger value overflows range of 16 bits
     Variable *legalizeImmediate(int32_t Imm);
 
     /// Legalizes Mov if its Source (or Destination) is a spilled Variable, or
     /// if its Source is a Rematerializable variable (this form is used in lieu
     /// of lea, which is not available in MIPS.)
     ///
     /// Moves to memory become store instructions, and moves from memory, loads.
     void legalizeMov(InstMIPS32Mov *Mov);
+    void legalizeMovFp(InstMIPS32MovFP64ToI64 *MovInstr);
 
   private:
     /// Creates a new Base register centered around [Base, +/- Offset].
     Variable *newBaseRegister(Variable *Base, int32_t Offset,
                               RegNumT ScratchRegNum);
 
     TargetMIPS32 *const Target;
     Variable *const StackOrFrameReg;
   };
 
@@ skipping 224 matching lines @@
   uint32_t Flags1 = AFL_FLAGS1_ODDSPREG;
   uint32_t Flags2 = AFL_FLAGS2_NONE;
 
   MipsABIFlagsSection() = default;
 };
 
 } // end of namespace MIPS32
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGMIPS32_H