Subzero: implement 64 bit multiply in mips32

src/IceTargetLoweringMIPS32.cpp

 //===- subzero/src/IceTargetLoweringMIPS32.cpp - MIPS32 lowering ----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 564 matching lines @@
 void TargetMIPS32::lowerInt64Arithmetic(const InstArithmetic *Instr,
                                         Variable *Dest, Operand *Src0,
                                         Operand *Src1) {
   InstArithmetic::OpKind Op = Instr->getOp();
   switch (Op) {
   case InstArithmetic::Add:
   case InstArithmetic::And:
   case InstArithmetic::Or:
   case InstArithmetic::Sub:
   case InstArithmetic::Xor:
+  case InstArithmetic::Mul:
     break;
   default:
     UnimplementedLoweringError(this, Instr);
     return;
   }
   auto *DestLo = llvm::cast<Variable>(loOperand(Dest));
   auto *DestHi = llvm::cast<Variable>(hiOperand(Dest));
   Variable *Src0LoR = legalizeToReg(loOperand(Src0));
   Variable *Src1LoR = legalizeToReg(loOperand(Src1));
   Variable *Src0HiR = legalizeToReg(hiOperand(Src0));
@@ skipping 42 matching lines @@
     return;
   }
   case InstArithmetic::Xor: {
     auto *T_Lo = I32Reg(), *T_Hi = I32Reg();
     _xor(T_Lo, Src0LoR, Src1LoR);
     _mov(DestLo, T_Lo);
     _xor(T_Hi, Src0HiR, Src1HiR);
     _mov(DestHi, T_Hi);
     return;
   }
+  case InstArithmetic::Mul: {
+    auto *T_Lo = I32Reg(RegMIPS32::Reg_LO), *T_Hi = I32Reg(RegMIPS32::Reg_HI);
+    auto *T1 = I32Reg(), *T2 = I32Reg();
+    auto *TM1 = I32Reg(), *TM2 = I32Reg(), *TM3 = I32Reg(), *TM4 = I32Reg();
+    _multu(T_Lo, Src0LoR, Src1LoR);
+    Context.insert<InstFakeDef>(T_Hi, T_Lo);
+    _mflo(T1, T_Lo);
+    _mfhi(T2, T_Hi);
+    _mov(DestLo, T1);
+    _mul(TM1, Src0HiR, Src1LoR);

[John, 2016/02/19 02:52:40]

I'm late to the party, but what's the difference between mult and mul?

[rkotlerimgtec, 2016/02/19 04:50:25]

mult is signed 64 bit result in Lo/Hi
mul is 32 bit signed result

+    _mul(TM2, Src0LoR, Src1HiR);
+    _addu(TM3, TM1, T2);
+    _addu(TM4, TM3, TM2);
+    _mov(DestHi, TM4);
+    return;
+  }
   default:
     UnimplementedLoweringError(this, Instr);
     return;
   }
 }
 
 void TargetMIPS32::lowerArithmetic(const InstArithmetic *Instr) {
   Variable *Dest = Instr->getDest();
   // We need to signal all the UnimplementedLoweringError errors before any
   // legalization into new variables, otherwise Om1 register allocation may fail
@@ skipping 635 matching lines @@
   Str << "\t.set\t"
       << "nomips16\n";
 }
 
 llvm::SmallBitVector TargetMIPS32::TypeToRegisterSet[RCMIPS32_NUM];
 llvm::SmallBitVector TargetMIPS32::TypeToRegisterSetUnfiltered[RCMIPS32_NUM];
 llvm::SmallBitVector TargetMIPS32::RegisterAliases[RegMIPS32::Reg_NUM];
 
 } // end of namespace MIPS32
 } // end of namespace Ice