[Subzero][MIPS32] Fix alloca alignment and offset for Om1 and O2 optimization

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 198 matching lines @@
         return;
       }
     }
   }
 }
 
 uint32_t TargetMIPS32::getStackAlignment() const {
   return MIPS32_STACK_ALIGNMENT_BYTES;
 }
 
+uint32_t TargetMIPS32::getCallStackArgumentsSizeBytes(const InstCall *Call) {
+  TargetMIPS32::CallingConv CC;
+  RegNumT DummyReg;
+  size_t OutArgsSizeBytes = 0;
+  for (SizeT i = 0, NumArgs = Call->getNumArgs(); i < NumArgs; ++i) {
+    Operand *Arg = legalizeUndef(Call->getArg(i));
+    const Type Ty = Arg->getType();
+    RegNumT RegNum;
+    if (CC.argInReg(Ty, i, &RegNum)) {
+      continue;
+    }
+
+    OutArgsSizeBytes = applyStackAlignmentTy(OutArgsSizeBytes, Ty);
+    OutArgsSizeBytes += typeWidthInBytesOnStack(Ty);
+  }
+
+  return applyStackAlignment(OutArgsSizeBytes);
+}
+
 void TargetMIPS32::genTargetHelperCallFor(Inst *Instr) {
   constexpr bool NoTailCall = false;
   constexpr bool IsTargetHelperCall = true;
 
   switch (Instr->getKind()) {
   default:
     return;
   case Inst::Arithmetic: {
     Variable *Dest = Instr->getDest();
     const Type DestTy = Dest->getType();
@@ skipping 350 matching lines @@
     Context.init(Node);
     while (!Context.atEnd()) {
       PostIncrLoweringContext PostIncrement(Context);
       Inst *CurInstr = iteratorToInst(Context.getCur());
       if (auto *Call = llvm::dyn_cast<InstCall>(CurInstr)) {
         SizeT OutArgsSizeBytes = getCallStackArgumentsSizeBytes(Call);
         MaxOutArgsSizeBytes = std::max(MaxOutArgsSizeBytes, OutArgsSizeBytes);
       }
     }
   }
+  CurrentAllocaOffset = MaxOutArgsSizeBytes;
 }
 
 void TargetMIPS32::translateO2() {
   TimerMarker T(TimerStack::TT_O2, Func);
 
   // TODO(stichnot): share passes with X86?
   // https://code.google.com/p/nativeclient/issues/detail?id=4094
   genTargetHelperCalls();
 
   unsetIfNonLeafFunc();
@@ skipping 1090 matching lines @@
     } else {
       Target->_sw(SrcR, Addr);
     }
 
     Target->Context.insert<InstFakeDef>(Dest);
     Legalized = true;
   } else if (auto *Var = llvm::dyn_cast<Variable>(Src)) {
     if (Var->isRematerializable()) {
       // This is equivalent to an x86 _lea(RematOffset(%esp/%ebp), Variable).
 
-      // ExtraOffset is only needed for frame-pointer based frames as we have
+      // ExtraOffset is only needed for stack-pointer based frames as we have
       // to account for spill storage.
-      const int32_t ExtraOffset = (Var->getRegNum() == Target->getFrameReg())
+      const int32_t ExtraOffset = (Var->getRegNum() == Target->getStackReg())
                                       ? Target->getFrameFixedAllocaOffset()
                                       : 0;
 
       const int32_t Offset = Var->getStackOffset() + ExtraOffset;
       Variable *Base = Target->getPhysicalRegister(Var->getRegNum());
       Variable *T = newBaseRegister(Base, Offset, Dest->getRegNum());
       Target->_mov(Dest, T);
       Legalized = true;
     } else {
       if (!Var->hasReg()) {
@@ skipping 203 matching lines @@
     FixedAllocaSizeBytes += Value;
     // Constant size alloca.
     if (!UseFramePointer) {
       // If we don't need a Frame Pointer, this alloca has a known offset to the
       // stack pointer. We don't need adjust the stack pointer, nor assign any
       // value to Dest, as Dest is rematerializable.
       assert(Dest->isRematerializable());
       Context.insert<InstFakeDef>(Dest);
       return;
     }
+
+    if (Alignment > MIPS32_STACK_ALIGNMENT_BYTES) {
+      CurrentAllocaOffset =
+          Utils::applyAlignment(CurrentAllocaOffset, Alignment);
+    }
+    auto *T = I32Reg();
+    _addiu(T, SP, CurrentAllocaOffset);
+    _mov(Dest, T);
+    CurrentAllocaOffset += Value;
+    return;
+
   } else {
     // Non-constant sizes need to be adjusted to the next highest multiple of
     // the required alignment at runtime.
     VariableAllocaUsed = true;
     Variable *AlignAmount;
     auto *TotalSizeR = legalizeToReg(TotalSize, Legal_Reg);
     auto *T1 = I32Reg();
     auto *T2 = I32Reg();
     auto *T3 = I32Reg();
     auto *T4 = I32Reg();
     auto *T5 = I32Reg();
     _addiu(T1, TotalSizeR, MIPS32_STACK_ALIGNMENT_BYTES - 1);
     _addiu(T2, getZero(), -MIPS32_STACK_ALIGNMENT_BYTES);
     _and(T3, T1, T2);
     _subu(T4, SP, T3);
     if (Instr->getAlignInBytes()) {
       AlignAmount =
           legalizeToReg(Ctx->getConstantInt32(-AlignmentParam), Legal_Reg);
       _and(T5, T4, AlignAmount);
       _mov(Dest, T5);
     } else {
       _mov(Dest, T4);
     }
     _mov(SP, Dest);
     return;
   }
-
-  // Add enough to the returned address to account for the out args area.
-  if (MaxOutArgsSizeBytes > 0) {
-    Variable *T = makeReg(getPointerType());
-    _addiu(T, SP, MaxOutArgsSizeBytes);
-    _mov(Dest, T);
-  } else {
-    _mov(Dest, SP);
-  }
 }
 
 void TargetMIPS32::lowerInt64Arithmetic(const InstArithmetic *Instr,
                                         Variable *Dest, Operand *Src0,
                                         Operand *Src1) {
   InstArithmetic::OpKind Op = Instr->getOp();
   auto *DestLo = llvm::cast<Variable>(loOperand(Dest));
   auto *DestHi = llvm::cast<Variable>(hiOperand(Dest));
   Variable *Src0LoR = nullptr;
   Variable *Src1LoR = nullptr;
@@ skipping 259 matching lines @@
     return;
   }
   default:
     UnimplementedLoweringError(this, Instr);
     return;
   }
 }
 
 void TargetMIPS32::lowerArithmetic(const InstArithmetic *Instr) {
   Variable *Dest = Instr->getDest();
+
+  if (Dest->isRematerializable()) {
+    Context.insert<InstFakeDef>(Dest);
+    return;
+  }
+
   // We need to signal all the UnimplementedLoweringError errors before any
   // legalization into new variables, otherwise Om1 register allocation may fail
   // when it sees variables that are defined but not used.
   Type DestTy = Dest->getType();
   Operand *Src0 = legalizeUndef(Instr->getSrc(0));
   Operand *Src1 = legalizeUndef(Instr->getSrc(1));
   if (DestTy == IceType_i64) {
     lowerInt64Arithmetic(Instr, Instr->getDest(), Src0, Src1);
     return;
   }
@@ skipping 2751 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