Subzero, MIPS32: Changes for improving sandbox crosstest results

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 5826 matching lines @@
     // tryOptimizedCmpxchgCmpBr().
     Iter->second.Instr->setDead();
     ++Iter;
   }
 }
 
 TargetHeaderMIPS32::TargetHeaderMIPS32(GlobalContext *Ctx)
     : TargetHeaderLowering(Ctx) {}
 
 void TargetHeaderMIPS32::lower() {
   OstreamLocker L(Ctx);

[Jim Stichnoth, 2016/11/21 20:08:39]

Just noticed this...  Use the normal pattern at the start of this method:

  if (!BuildDefs::dump())
    return;

[Stefan Maksimovic, 2016/11/22 11:38:13]

Done.

   Ostream &Str = Ctx->getStrEmit();
   Str << "\t.set\t"
       << "nomicromips\n";
   Str << "\t.set\t"
       << "nomips16\n";
   Str << "\t.set\t"
       << "noat\n";
+  if(getFlags().getUseSandboxing())
+    Str << "\t.bundle_align_mode 4\n";
 }
 
 SmallBitVector TargetMIPS32::TypeToRegisterSet[RCMIPS32_NUM];
 SmallBitVector TargetMIPS32::TypeToRegisterSetUnfiltered[RCMIPS32_NUM];
 SmallBitVector TargetMIPS32::RegisterAliases[RegMIPS32::Reg_NUM];
 
 TargetMIPS32::Sandboxer::Sandboxer(TargetMIPS32 *Target,
                                    InstBundleLock::Option BundleOption)
     : Target(Target), BundleOption(BundleOption) {}
 
@@ skipping 16 matching lines @@
 }
 
 void TargetMIPS32::Sandboxer::lw(Variable *Dest, OperandMIPS32Mem *Mem) {
   Variable *Base = Mem->getBase();
   Variable *T7 = Target->getPhysicalRegister(RegMIPS32::Reg_T7);
   if (Target->NeedSandboxing && (Target->getStackReg() != Base->getRegNum())) {
     createAutoBundle();
     Target->_and(Base, Base, T7);
   }
   Target->_lw(Dest, Mem);
+  if (Target->NeedSandboxing && (Dest->getRegNum() == Target->getStackReg()))
+    Target->_and(Dest, Dest, T7);
 }
 
 void TargetMIPS32::Sandboxer::sw(Variable *Dest, OperandMIPS32Mem *Mem) {
   Variable *Base = Mem->getBase();
   Variable *T7 = Target->getPhysicalRegister(RegMIPS32::Reg_T7);
   if (Target->NeedSandboxing && (Target->getStackReg() != Base->getRegNum())) {
     createAutoBundle();
     Target->_and(Base, Base, T7);
   }
   Target->_sw(Dest, Mem);
@@ skipping 38 matching lines @@
 void TargetMIPS32::Sandboxer::reset_sp(Variable *Src) {
   Variable *SP = Target->getPhysicalRegister(RegMIPS32::Reg_SP);
   if (!Target->NeedSandboxing) {
     Target->_mov(SP, Src);
     return;
   }
   Variable *T7 = Target->getPhysicalRegister(RegMIPS32::Reg_T7);
   createAutoBundle();
   Target->_mov(SP, Src);
   Target->_and(SP, SP, T7);
+  Target->getContext().insert<InstFakeUse>(SP);
 }
 
 InstMIPS32Call *TargetMIPS32::Sandboxer::jal(Variable *ReturnReg,
                                              Operand *CallTarget) {
-  if (Target->NeedSandboxing)
+  if (Target->NeedSandboxing) {
     createAutoBundle();
+    if (auto *CallTargetR = llvm::dyn_cast<Variable>(CallTarget)) {
+      Variable *T6 = Target->getPhysicalRegister(RegMIPS32::Reg_T6);
+      Target->_and(CallTargetR, CallTargetR, T6);
+    }
+  }
   return Target->Context.insert<InstMIPS32Call>(ReturnReg, CallTarget);
 }
 
 } // end of namespace MIPS32
 } // end of namespace Ice