Add MIPS segmented stacks

Author: brson

lib/Target/Mips/MipsFrameLowering.cpp

@@ -132,3 +132,179 @@ uint64_t MipsFrameLowering::estimateStackSize(const MachineFunction &MF) const {
 
   return RoundUpToAlignment(Offset, getStackAlignment());
 }
+
+// The stack limit in the TCB is set to this manyu bytes above the actual
+// stack limit.
+static const uint64_t kSplitStackAvailable = 256;
+
+// helper function for loading immediate
+static void loadImm(MachineBasicBlock *MBB, DebugLoc DL,
+                    const TargetInstrInfo &TII,
+                    unsigned Reg, int64_t Imm) {
+    if (isInt<16>(Imm)) {
+      // addiu $Reg, $zero, Imm
+      BuildMI(MBB, DL, TII.get(Mips::ADDiu), Reg)
+              .addReg(Mips::ZERO).addImm(Imm);
+    } else {
+      // lui $Reg, (Imm >> 16)
+      BuildMI(MBB, DL, TII.get(Mips::LUi), Reg)
+              .addImm(Imm >> 16);
+      // ori $Reg, $Reg, (Imm & 0xffff)
+      BuildMI(MBB, DL, TII.get(Mips::ORi), Reg)
+              .addReg(Reg).addImm(Imm & 0xffff);
+    }
+}
+
+// Adjust function prologue to enable split stack.
+void
+MipsFrameLowering::adjustForSegmentedStacks(MachineFunction &MF) const {
+  const TargetMachine &TM = MF.getTarget();
+  const MipsSubtarget *ST = &TM.getSubtarget<MipsSubtarget>();
+
+  // Doesn't support vararg function.
+  if (MF.getFunction()->isVarArg())
+    report_fatal_error("Segmented stacks do not support vararg functions.");
+  // Doesn't support other than linux o32 with pic relocation.
+  if (!ST->isLinux() || !ST->isABI_O32() || TM.getRelocationModel() != Reloc::PIC_)
+    report_fatal_error("Segmented statks not supported on this platfrom.");
+
+  MachineBasicBlock &prologueMBB = MF.front();
+  MachineFrameInfo* MFI = MF.getFrameInfo();
+  const TargetInstrInfo &TII = *TM.getInstrInfo();
+  MipsFunctionInfo* MipsFI = MF.getInfo<MipsFunctionInfo>();
+  DebugLoc DL;
+
+  // Use t6 and t7 as scratch register.
+  unsigned ScratchReg0 = Mips::T6;
+  unsigned ScratchReg1 = Mips::T7;
+  // Use the private field of tcb head.
+  unsigned TlsOffset = 0x7004;
+
+  MachineBasicBlock* allocMBB = MF.CreateMachineBasicBlock();
+  MachineBasicBlock* checkMBB = MF.CreateMachineBasicBlock();
+
+  for (MachineBasicBlock::livein_iterator i = prologueMBB.livein_begin(),
+         e = prologueMBB.livein_end(); i != e; ++i) {
+    allocMBB->addLiveIn(*i);
+    checkMBB->addLiveIn(*i);
+  }
+
+  MF.push_front(allocMBB);
+  MF.push_front(checkMBB);
+
+  uint64_t StackSize = MFI->getStackSize();
+
+  // When the frame size is less than 256 we just compare the stack
+  // boundary directly to the value of the stack pointer, per gcc.
+  bool CompareStackPointer = StackSize < kSplitStackAvailable;
+
+  if (!MipsFI->globalBaseRegSet()) {
+    // lui $v0, %hi(_gp_disp)
+    BuildMI(checkMBB, DL, TII.get(Mips::LUi), Mips::V0)
+            .addExternalSymbol("_gp_disp", MipsII::MO_ABS_HI);
+    // addiu $v0, $v0, %lo(_gp_disp)
+    BuildMI(checkMBB, DL, TII.get(Mips::ADDiu), Mips::V0)
+            .addReg(Mips::V0)
+            .addExternalSymbol("_gp_disp", MipsII::MO_ABS_LO);
+    allocMBB->addLiveIn(Mips::V0);
+    allocMBB->addLiveIn(Mips::T9);
+  }
+
+  if (CompareStackPointer) {
+    // addu $SR1, $sp, $zero
+    BuildMI(checkMBB, DL, TII.get(Mips::ADDu), ScratchReg1)
+            .addReg(Mips::SP).addReg(Mips::ZERO);
+  } else {
+    // li $SR1, -StackSize
+    loadImm(checkMBB, DL, TII, ScratchReg1, -StackSize);
+    // addu $SR1, $sp, $SR1
+    BuildMI(checkMBB, DL, TII.get(Mips::ADDu), ScratchReg1)
+            .addReg(Mips::SP).addReg(ScratchReg1);
+  }
+
+  // rdhwr $v1, $sp
+  BuildMI(checkMBB, DL, TII.get(Mips::RDHWR), Mips::V1)
+          .addReg(Mips::HWR29);
+
+  // addiu $v1, $v1, -TlsOffset
+  BuildMI(checkMBB, DL, TII.get(Mips::ADDiu), Mips::V1)
+          .addReg(Mips::V1).addImm((-TlsOffset) & 0xffff);
+
+  // Get stack limit.
+  // lw $SR0, 0($v1)
+  BuildMI(checkMBB, DL, TII.get(Mips::LW), ScratchReg0)
+          .addReg(Mips::V1).addImm(0);
+
+  // Compare stack limit with stack size requested.
+  // sltu $v1, $SR0, $SR1
+  BuildMI(checkMBB, DL, TII.get(Mips::SLTu), Mips::V1)
+          .addReg(ScratchReg0).addReg(ScratchReg1);
+
+  // This jump is taken if StackLimit < (SP - stack required).
+  // bne $v1, $zero, $prologueMBB
+  BuildMI(checkMBB, DL, TII.get(Mips::BNE))
+          .addReg(Mips::V1).addReg(Mips::ZERO).addMBB(&prologueMBB);
+
+  // Calling __morestack(StackSize, Size of stack arguments).
+  // __morestack knows that the stack size requested is in SR0(t6)
+  // and amount size of stack arguments is in SR1(t7).
+
+  // Pass first argument for the __morestack by Scratch Register #0.
+  // The amount size of stack required
+  // li $SR0, StackSize
+  loadImm(allocMBB, DL, TII, ScratchReg0, StackSize);
+
+  // Pass second argument for the __morestack by Scratch Register #1.
+  // The amount size of stack consumed to save function arguments.
+  // li $SR1, ArgumentStackSize
+  loadImm(allocMBB, DL, TII, ScratchReg1, MipsFI->getArgumentStackSize());
+
+  // addiu $sp, $sp, -12
+  BuildMI(allocMBB, DL, TII.get(Mips::ADDiu), Mips::SP)
+          .addReg(Mips::SP).addImm(-12);
+  // Save return address of this function.
+  // sw $ra, 8($sp)
+  BuildMI(allocMBB, DL, TII.get(Mips::SW))
+          .addReg(Mips::RA).addReg(Mips::SP).addImm(8);
+  // Save function address and _gp_disp for PIC.
+  // sw $t9, 4($sp)
+  BuildMI(allocMBB, DL, TII.get(Mips::SW))
+          .addReg(Mips::T9).addReg(Mips::SP).addImm(4);
+  // sw $v0, 0($sp)
+  BuildMI(allocMBB, DL, TII.get(Mips::SW))
+          .addReg(Mips::V0).addReg(Mips::SP).addImm(0);
+
+  // addu $gp, $v0, $t9
+  BuildMI(allocMBB, DL, TII.get(Mips::ADDu), Mips::GP)
+          .addReg(Mips::V0).addReg(Mips::T9);
+  // lw $t9, %call16(__morestack)($gp)
+  BuildMI(allocMBB, DL, TII.get(Mips::LW), Mips::T9)
+          .addReg(Mips::GP)
+          .addExternalSymbol("__morestack", MipsII::MO_GOT_CALL);
+  // jalr $t9
+  BuildMI(allocMBB, DL, TII.get(Mips::JALR), Mips::RA)
+          .addReg(Mips::T9);
+
+  // Restore return address of this original function.
+  // lw $ra, 8($sp)
+  BuildMI(allocMBB, DL, TII.get(Mips::LW), Mips::RA)
+          .addReg(Mips::SP).addImm(8);
+  // addiu $sp, $sp, 12
+  BuildMI(allocMBB, DL, TII.get(Mips::ADDiu), Mips::SP)
+          .addReg(Mips::SP).addImm(12);
+
+  // Return from this function.
+  // jr $ra
+  BuildMI(allocMBB, DL, TII.get(Mips::JR))
+          .addReg(Mips::RA);
+
+  // Organizing MBB lists
+  allocMBB->addSuccessor(&prologueMBB);
+
+  checkMBB->addSuccessor(allocMBB);
+  checkMBB->addSuccessor(&prologueMBB);
+
+#ifdef XDEBUG
+  MF.verify();
+#endif
+}

lib/Target/Mips/MipsFrameLowering.h

@@ -34,6 +34,8 @@ class MipsFrameLowering : public TargetFrameLowering {
 
   bool hasFP(const MachineFunction &MF) const;
 
+  void adjustForSegmentedStacks(MachineFunction &MF) const;
+
 protected:
   uint64_t estimateStackSize(const MachineFunction &MF) const;
 };

lib/Target/Mips/MipsISelLowering.cpp

@@ -2732,6 +2732,8 @@ MipsTargetLowering::LowerFormalArguments(SDValue Chain,
                         &OutChains[0], OutChains.size());
   }
 
+  MipsFI->setArgumentStackSize(CCInfo.getNextStackOffset());
+
   return Chain;
 }
 

lib/Target/Mips/MipsMachineFunction.h

@@ -69,6 +69,9 @@ class MipsFunctionInfo : public MachineFunctionInfo {
   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
   void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
 
+  unsigned getArgumentStackSize() const { return ArgumentStackSize; }
+  void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; }
+
   bool hasByvalArg() const { return HasByvalArg; }
   void setFormalArgInfo(unsigned Size, bool HasByval) {
     IncomingArgSize = Size;
@@ -126,6 +129,10 @@ class MipsFunctionInfo : public MachineFunctionInfo {
   /// Frame objects for spilling eh data registers.
   int EhDataRegFI[4];
 
+  /// ArgumentStackSize - amount of bytes on stack consumed by the arguments
+  /// being passed on the stack
+  unsigned ArgumentStackSize;
+
   /// MipsCallEntry maps.
   StringMap<const MipsCallEntry *> ExternalCallEntries;
   ValueMap<const GlobalValue *, const MipsCallEntry *> GlobalCallEntries;