DelaySlotFiller.cpp

Go to the documentation of this file.

//===-- DelaySlotFiller.cpp - SPARC delay slot filler ---------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This is a simple local pass that attempts to fill delay slots with useful
// instructions. If no instructions can be moved into the delay slot, then a
// NOP is placed.
//===----------------------------------------------------------------------===//
 
#include "Sparc.h"
#include "SparcSubtarget.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetInstrInfo.h"
#include "llvm/CodeGen/TargetRegisterInfo.h"
#include "llvm/IR/Analysis.h"
#include "llvm/Pass.h"
#include "llvm/Target/TargetMachine.h"
 
using namespace llvm;
 
#define DEBUG_TYPE "delay-slot-filler"
 
STATISTIC(FilledSlots, "Number of delay slots filled");
 
namespace {
struct SparcDelaySlotFillerLegacy : public MachineFunctionPass {
  static char ID;
  SparcDelaySlotFillerLegacy() : MachineFunctionPass(ID) {}
 
  StringRef getPassName() const override { return "SPARC Delay Slot Filler"; }
 
  bool runOnMachineFunction(MachineFunction &MF) override;
 
  MachineFunctionProperties getRequiredProperties() const override {
    return MachineFunctionProperties().setNoVRegs();
  }
 
  void getAnalysisUsage(AnalysisUsage &AU) const override {
    AU.setPreservesCFG();
    MachineFunctionPass::getAnalysisUsage(AU);
  }
};
char SparcDelaySlotFillerLegacy::ID = 0;
} // end of anonymous namespace
 
/// createSparcDelaySlotFillerPass - Returns a pass that fills in delay
/// slots in Sparc MachineFunctions
///
FunctionPass *llvm::createSparcDelaySlotFillerLegacyPass() {
  return new SparcDelaySlotFillerLegacy;
}
 
static bool combineRestoreADD(MachineBasicBlock &MBB,
                              MachineBasicBlock::iterator RestoreMI,
                              MachineBasicBlock::iterator AddMI,
                              const TargetInstrInfo *TII) {
  // Before:  add  <op0>, <op1>, %i[0-7]
  //          restore %g0, %g0, %i[0-7]
  //
  // After :  restore <op0>, <op1>, %o[0-7]
 
  const TargetRegisterInfo *TRI = &TII->getRegisterInfo();
  Register reg = AddMI->getOperand(0).getReg();
  if (reg < SP::I0 || reg > SP::I7)
    return false;
 
  // Check whether it uses %o7 as its source and the corresponding branch
  // instruction is a call.
  MachineBasicBlock::iterator LastInst = MBB.getFirstTerminator();
  bool IsCall = LastInst != MBB.end() && LastInst->isCall();
 
  if (IsCall && AddMI->getOpcode() == SP::ADDrr &&
      AddMI->readsRegister(SP::O7, TRI))
    return false;
 
  if (IsCall && AddMI->getOpcode() == SP::ADDri &&
      AddMI->readsRegister(SP::O7, TRI))
    return false;
 
  // Erase RESTORE.
  RestoreMI->eraseFromParent();
 
  // Change ADD to RESTORE.
  AddMI->setDesc(TII->get((AddMI->getOpcode() == SP::ADDrr) ? SP::RESTORErr
                                                            : SP::RESTOREri));
 
  // Map the destination register.
  AddMI->getOperand(0).setReg(reg - SP::I0 + SP::O0);
 
  return true;
}
 
static bool combineRestoreOR(MachineBasicBlock &MBB,
                             MachineBasicBlock::iterator RestoreMI,
                             MachineBasicBlock::iterator OrMI,
                             const TargetInstrInfo *TII) {
  // Before:  or  <op0>, <op1>, %i[0-7]
  //          restore %g0, %g0, %i[0-7]
  //    and <op0> or <op1> is zero,
  //
  // After :  restore <op0>, <op1>, %o[0-7]
 
  const TargetRegisterInfo *TRI = &TII->getRegisterInfo();
  Register reg = OrMI->getOperand(0).getReg();
  if (reg < SP::I0 || reg > SP::I7)
    return false;
 
  // check whether it is a copy.
  if (OrMI->getOpcode() == SP::ORrr && OrMI->getOperand(1).getReg() != SP::G0 &&
      OrMI->getOperand(2).getReg() != SP::G0)
    return false;
 
  if (OrMI->getOpcode() == SP::ORri && OrMI->getOperand(1).getReg() != SP::G0 &&
      (!OrMI->getOperand(2).isImm() || OrMI->getOperand(2).getImm() != 0))
    return false;
 
  // Check whether it uses %o7 as its source and the corresponding branch
  // instruction is a call.
  MachineBasicBlock::iterator LastInst = MBB.getFirstTerminator();
  bool IsCall = LastInst != MBB.end() && LastInst->isCall();
 
  if (IsCall && OrMI->getOpcode() == SP::ORrr &&
      OrMI->readsRegister(SP::O7, TRI))
    return false;
 
  // Erase RESTORE.
  RestoreMI->eraseFromParent();
 
  // Change OR to RESTORE.
  OrMI->setDesc(TII->get((OrMI->getOpcode() == SP::ORrr) ? SP::RESTORErr
                                                         : SP::RESTOREri));
 
  // Map the destination register.
  OrMI->getOperand(0).setReg(reg - SP::I0 + SP::O0);
 
  return true;
}
 
static bool combineRestoreSETHIi(MachineBasicBlock::iterator RestoreMI,
                                 MachineBasicBlock::iterator SetHiMI,
                                 const TargetInstrInfo *TII) {
  // Before:  sethi imm3, %i[0-7]
  //          restore %g0, %g0, %g0
  //
  // After :  restore %g0, (imm3<<10), %o[0-7]
 
  Register reg = SetHiMI->getOperand(0).getReg();
  if (reg < SP::I0 || reg > SP::I7)
    return false;
 
  if (!SetHiMI->getOperand(1).isImm())
    return false;
 
  int64_t imm = SetHiMI->getOperand(1).getImm();
 
  // Is it a 3 bit immediate?
  if (!isInt<3>(imm))
    return false;
 
  // Make it a 13 bit immediate.
  imm = (imm << 10) & 0x1FFF;
 
  assert(RestoreMI->getOpcode() == SP::RESTORErr);
 
  RestoreMI->setDesc(TII->get(SP::RESTOREri));
 
  RestoreMI->getOperand(0).setReg(reg - SP::I0 + SP::O0);
  RestoreMI->getOperand(1).setReg(SP::G0);
  RestoreMI->getOperand(2).ChangeToImmediate(imm);
 
  // Erase the original SETHI.
  SetHiMI->eraseFromParent();
 
  return true;
}
 
static bool tryCombineRestoreWithPrevInst(MachineBasicBlock &MBB,
                                          MachineBasicBlock::iterator MBBI,
                                          const SparcSubtarget *Subtarget) {
  // No previous instruction.
  if (MBBI == MBB.begin())
    return false;
 
  // assert that MBBI is a "restore %g0, %g0, %g0".
  assert(MBBI->getOpcode() == SP::RESTORErr &&
         MBBI->getOperand(0).getReg() == SP::G0 &&
         MBBI->getOperand(1).getReg() == SP::G0 &&
         MBBI->getOperand(2).getReg() == SP::G0);
 
  MachineBasicBlock::iterator PrevInst = std::prev(MBBI);
 
  // It cannot be combined with a bundled instruction.
  if (PrevInst->isBundledWithSucc())
    return false;
 
  const TargetInstrInfo *TII = Subtarget->getInstrInfo();
 
  switch (PrevInst->getOpcode()) {
  default:
    break;
  case SP::ADDrr:
  case SP::ADDri:
    return combineRestoreADD(MBB, MBBI, PrevInst, TII);
  case SP::ORrr:
  case SP::ORri:
    return combineRestoreOR(MBB, MBBI, PrevInst, TII);
  case SP::SETHIi:
    return combineRestoreSETHIi(MBBI, PrevInst, TII);
    break;
  }
  // It cannot combine with the previous instruction.
  return false;
}
 
/// The restore before a tail call must run in its delay slot: `jmp %reg`
/// reads a register of the current window, and `call` writes %o7. For the
/// same reason a leaf `call` needs the copy of %o7 back from %g1 that
/// SparcFrameLowering emits.
static MachineBasicBlock::iterator
findRequiredDelayInstr(MachineBasicBlock &MBB,
                       MachineBasicBlock::iterator slot) {
  unsigned Opc = slot->getOpcode();
  if ((Opc != SP::TAIL_CALL && Opc != SP::TAIL_CALLri) || slot == MBB.begin())
    return MBB.end();
 
  MachineBasicBlock::iterator J = slot;
  do {
    --J;
  } while (J->isMetaInstruction() && J != MBB.begin());
 
  if (J->getOpcode() == SP::RESTORErr || J->getOpcode() == SP::RESTOREri)
    return J;
  if (Opc == SP::TAIL_CALL && J->getOpcode() == SP::ORrr &&
      J->getOperand(0).getReg() == SP::O7)
    return J;
  return MBB.end();
}
 
static void insertCallDefsUses(MachineBasicBlock::iterator MI,
                               SmallSet<unsigned, 32> &RegDefs,
                               SmallSet<unsigned, 32> &RegUses) {
  // Regular calls define o7, which is visible to the instruction in delay slot.
  // On the other hand, tail calls preserve it.
  switch (MI->getOpcode()) {
  default:
    llvm_unreachable("Unknown opcode.");
  case SP::CALL:
    RegDefs.insert(SP::O7);
    break;
  case SP::TAIL_CALL:
    break;
  case SP::CALLrr:
  case SP::CALLri:
    RegDefs.insert(SP::O7);
    [[fallthrough]];
  case SP::TAIL_CALLri:
    assert(MI->getNumOperands() >= 2);
    const MachineOperand &Reg = MI->getOperand(0);
    assert(Reg.isReg() && "CALL first operand is not a register.");
    assert(Reg.isUse() && "CALL first operand is not a use.");
    RegUses.insert(Reg.getReg());
 
    const MachineOperand &Operand1 = MI->getOperand(1);
    if (Operand1.isImm() || Operand1.isGlobal())
      break;
    assert(Operand1.isReg() && "CALLrr second operand is not a register.");
    assert(Operand1.isUse() && "CALLrr second operand is not a use.");
    RegUses.insert(Operand1.getReg());
    break;
  }
}
 
// Insert Defs and Uses of MI into the sets RegDefs and RegUses.
static void insertDefsUses(MachineBasicBlock::iterator MI,
                           SmallSet<unsigned, 32> &RegDefs,
                           SmallSet<unsigned, 32> &RegUses,
                           const SparcSubtarget *Subtarget) {
  for (const MachineOperand &MO : MI->operands()) {
    if (!MO.isReg())
      continue;
 
    Register Reg = MO.getReg();
    if (Reg == 0 || Subtarget->getRegisterInfo()->isConstantPhysReg(Reg))
      continue;
    if (MO.isDef())
      RegDefs.insert(Reg);
    if (MO.isUse()) {
      // Implicit register uses of retl are return values and
      // retl does not use them.
      if (MO.isImplicit() && MI->getOpcode() == SP::RETL)
        continue;
      RegUses.insert(Reg);
    }
  }
}
 
// returns true if the Reg or its alias is in the RegSet.
static bool IsRegInSet(SmallSet<unsigned, 32> &RegSet, unsigned Reg,
                       const SparcSubtarget *Subtarget) {
  // Check Reg and all aliased Registers.
  for (MCRegAliasIterator AI(Reg, Subtarget->getRegisterInfo(), true);
       AI.isValid(); ++AI)
    if (RegSet.count(*AI))
      return true;
  return false;
}
 
static bool delayHasHazard(MachineBasicBlock::iterator candidate, bool &sawLoad,
                           bool &sawStore, SmallSet<unsigned, 32> &RegDefs,
                           SmallSet<unsigned, 32> &RegUses,
                           const SparcSubtarget *Subtarget) {
 
  if (candidate->isImplicitDef() || candidate->isKill())
    return true;
 
  if (candidate->mayLoad()) {
    sawLoad = true;
    if (sawStore)
      return true;
  }
 
  if (candidate->mayStore()) {
    if (sawStore)
      return true;
    sawStore = true;
    if (sawLoad)
      return true;
  }
 
  for (const MachineOperand &MO : candidate->operands()) {
    if (!MO.isReg())
      continue; // skip
 
    Register Reg = MO.getReg();
 
    if (MO.isDef()) {
      // check whether Reg is defined or used before delay slot.
      if (IsRegInSet(RegDefs, Reg, Subtarget) ||
          IsRegInSet(RegUses, Reg, Subtarget))
        return true;
    }
    if (MO.isUse()) {
      // check whether Reg is defined before delay slot.
      if (IsRegInSet(RegDefs, Reg, Subtarget))
        return true;
    }
  }
 
  unsigned Opcode = candidate->getOpcode();
  // LD and LDD may have NOPs inserted afterwards in the case of some LEON
  // processors, so we can't use the delay slot if this feature is switched-on.
  if (Subtarget->insertNOPLoad()
      &&
      Opcode >=  SP::LDDArr && Opcode <= SP::LDrr)
    return true;
 
  // Same as above for FDIV and FSQRT on some LEON processors.
  if (Subtarget->fixAllFDIVSQRT()
      &&
      Opcode >=  SP::FDIVD && Opcode <= SP::FSQRTD)
    return true;
 
  if (Subtarget->fixTN0009() && candidate->mayStore())
    return true;
 
  if (Subtarget->fixTN0013()) {
    switch (Opcode) {
    case SP::FDIVS:
    case SP::FDIVD:
    case SP::FSQRTS:
    case SP::FSQRTD:
      return true;
    default:
      break;
    }
  }
 
  return false;
}
 
static MachineBasicBlock::iterator
findDelayInstr(MachineBasicBlock &MBB, MachineBasicBlock::iterator slot,
               const SparcSubtarget *Subtarget) {
  SmallSet<unsigned, 32> RegDefs;
  SmallSet<unsigned, 32> RegUses;
  bool sawLoad = false;
  bool sawStore = false;
 
  if (slot == MBB.begin())
    return MBB.end();
 
  unsigned Opc = slot->getOpcode();
 
  if (Opc == SP::RET || Opc == SP::TLS_CALL)
    return MBB.end();
 
  if (Opc == SP::RETL || Opc == SP::TAIL_CALL || Opc == SP::TAIL_CALLri) {
    MachineBasicBlock::iterator J = slot;
    --J;
 
    if (J->getOpcode() == SP::RESTORErr || J->getOpcode() == SP::RESTOREri) {
      // change retl to ret.
      if (Opc == SP::RETL)
        slot->setDesc(Subtarget->getInstrInfo()->get(SP::RET));
      return J;
    }
  }
 
  // Call's delay filler can def some of call's uses.
  if (slot->isCall())
    insertCallDefsUses(slot, RegDefs, RegUses);
  else
    insertDefsUses(slot, RegDefs, RegUses, Subtarget);
 
  bool done = false;
 
  MachineBasicBlock::iterator I = slot;
 
  while (!done) {
    done = (I == MBB.begin());
 
    if (!done)
      --I;
 
    // Skip meta instructions.
    if (I->isMetaInstruction())
      continue;
 
    if (I->hasUnmodeledSideEffects() || I->isInlineAsm() || I->isPosition() ||
        I->hasDelaySlot() || I->isBundledWithSucc())
      break;
 
    if (delayHasHazard(I, sawLoad, sawStore, RegDefs, RegUses, Subtarget)) {
      insertDefsUses(I, RegDefs, RegUses, Subtarget);
      continue;
    }
 
    return I;
  }
  return MBB.end();
}
 
/// runOnMachineBasicBlock - Fill in delay slots for the given basic block.
/// We assume there is only one delay slot per delayed instruction.
///
static bool runOnMachineBasicBlock(MachineBasicBlock &MBB) {
  bool Changed = false;
  const SparcSubtarget *Subtarget =
      &MBB.getParent()->getSubtarget<SparcSubtarget>();
  bool FillSlots =
      !Subtarget->getCLOpts().disable_sparc_delay_filler &&
      MBB.getParent()->getTarget().getOptLevel() != CodeGenOptLevel::None;
  const SparcInstrInfo *TII = Subtarget->getInstrInfo();
 
  for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end();) {
    MachineBasicBlock::iterator MI = I;
    ++I;
 
    // If MI is restore, try combining it with previous inst.
    if (FillSlots && (MI->getOpcode() == SP::RESTORErr ||
                      MI->getOpcode() == SP::RESTOREri)) {
      Changed |= tryCombineRestoreWithPrevInst(MBB, MI, Subtarget);
      continue;
    }
 
    // TODO: If we ever want to support v7, this needs to be extended
    // to cover all floating point operations.
    if (!Subtarget->isV9() &&
        (MI->getOpcode() == SP::FCMPS || MI->getOpcode() == SP::FCMPD ||
         MI->getOpcode() == SP::FCMPQ)) {
      BuildMI(MBB, I, MI->getDebugLoc(), TII->get(SP::NOP));
      Changed = true;
      continue;
    }
 
    // If MI has no delay slot, skip.
    if (!MI->hasDelaySlot())
      continue;
 
    MachineBasicBlock::iterator D = findRequiredDelayInstr(MBB, MI);
 
    if (D == MBB.end() && FillSlots)
      D = findDelayInstr(MBB, MI, Subtarget);
 
    ++FilledSlots;
    Changed = true;
 
    if (D == MBB.end())
      BuildMI(MBB, I, MI->getDebugLoc(), TII->get(SP::NOP));
    else
      MBB.splice(I, &MBB, D);
 
    unsigned structSize = 0;
    if (TII->needsUnimp(*MI, structSize)) {
      MachineBasicBlock::iterator J = MI;
      ++J; // skip the delay filler.
      assert(J != MBB.end() && "MI needs a delay instruction.");
      BuildMI(MBB, ++J, MI->getDebugLoc(), TII->get(SP::UNIMP))
          .addImm(structSize);
      // Bundle the delay filler and unimp with the instruction.
      MIBundleBuilder(MBB, MachineBasicBlock::iterator(MI), J);
    } else {
      MIBundleBuilder(MBB, MachineBasicBlock::iterator(MI), I);
    }
  }
  return Changed;
}
 
static bool runDelaySlotFillerOnMachineFunction(MachineFunction &MF) {
  bool Changed = false;
 
  // This pass invalidates liveness information when it reorders
  // instructions to fill delay slot.
  MF.getRegInfo().invalidateLiveness();
 
  for (MachineBasicBlock &MBB : MF)
    Changed |= runOnMachineBasicBlock(MBB);
  return Changed;
}
 
bool SparcDelaySlotFillerLegacy::runOnMachineFunction(MachineFunction &MF) {
  return runDelaySlotFillerOnMachineFunction(MF);
}
 
PreservedAnalyses
SparcDelaySlotFillerPass::run(MachineFunction &MF,
                              MachineFunctionAnalysisManager &MFAM) {
  MFPropsModifier _(*this, MF);
  return runDelaySlotFillerOnMachineFunction(MF)
             ? getMachineFunctionPassPreservedAnalyses()
                   .preserveSet<CFGAnalyses>()
             : PreservedAnalyses::all();
}