| //===- M68kFrameLowering.h - Define frame lowering for M68k -*- C++ -*-===// |
| // |
| // 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 |
| // |
| //===----------------------------------------------------------------------===// |
| /// |
| /// \file |
| /// This file contains the M68k declaration of TargetFrameLowering class. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_LIB_TARGET_M68K_M68KFRAMELOWERING_H |
| #define LLVM_LIB_TARGET_M68K_M68KFRAMELOWERING_H |
| |
| #include "M68k.h" |
| |
| #include "llvm/CodeGen/TargetFrameLowering.h" |
| |
| namespace llvm { |
| class MachineInstrBuilder; |
| class MCCFIInstruction; |
| class M68kSubtarget; |
| class M68kRegisterInfo; |
| struct Align; |
| |
| class M68kFrameLowering : public TargetFrameLowering { |
| // Cached subtarget predicates. |
| const M68kSubtarget &STI; |
| const TargetInstrInfo &TII; |
| const M68kRegisterInfo *TRI; |
| |
| /// Stack slot size in bytes. |
| unsigned SlotSize; |
| |
| unsigned StackPtr; |
| |
| /// If we're forcing a stack realignment we can't rely on just the frame |
| /// info, we need to know the ABI stack alignment as well in case we have a |
| /// call out. Otherwise just make sure we have some alignment - we'll go |
| /// with the minimum SlotSize. |
| uint64_t calculateMaxStackAlign(const MachineFunction &MF) const; |
| |
| /// Adjusts the stack pointer using LEA, SUB, or ADD. |
| MachineInstrBuilder BuildStackAdjustment(MachineBasicBlock &MBB, |
| MachineBasicBlock::iterator MBBI, |
| const DebugLoc &DL, int64_t Offset, |
| bool InEpilogue) const; |
| |
| /// Aligns the stack pointer by ANDing it with -MaxAlign. |
| void BuildStackAlignAND(MachineBasicBlock &MBB, |
| MachineBasicBlock::iterator MBBI, const DebugLoc &DL, |
| unsigned Reg, uint64_t MaxAlign) const; |
| |
| /// Wraps up getting a CFI index and building a MachineInstr for it. |
| void BuildCFI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, |
| const DebugLoc &DL, const MCCFIInstruction &CFIInst) const; |
| |
| void emitPrologueCalleeSavedFrameMoves(MachineBasicBlock &MBB, |
| MachineBasicBlock::iterator MBBI, |
| const DebugLoc &DL) const; |
| |
| unsigned getPSPSlotOffsetFromSP(const MachineFunction &MF) const; |
| |
| public: |
| explicit M68kFrameLowering(const M68kSubtarget &sti, Align Alignment); |
| |
| static const M68kFrameLowering *create(const M68kSubtarget &ST); |
| |
| /// This method is called during prolog/epilog code insertion to eliminate |
| /// call frame setup and destroy pseudo instructions (but only if the Target |
| /// is using them). It is responsible for eliminating these instructions, |
| /// replacing them with concrete instructions. This method need only be |
| /// implemented if using call frame setup/destroy pseudo instructions. |
| /// Returns an iterator pointing to the instruction after the replaced one. |
| MachineBasicBlock::iterator |
| eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, |
| MachineBasicBlock::iterator MI) const override; |
| |
| /// Insert prolog code into the function. |
| void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override; |
| |
| /// Insert epilog code into the function. |
| void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override; |
| |
| /// This method determines which of the registers reported by |
| /// TargetRegisterInfo::getCalleeSavedRegs() should actually get saved. |
| /// The default implementation checks populates the \p SavedRegs bitset with |
| /// all registers which are modified in the function, targets may override |
| /// this function to save additional registers. |
| /// This method also sets up the register scavenger ensuring there is a free |
| /// register or a frameindex available. |
| void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, |
| RegScavenger *RS = nullptr) const override; |
| |
| /// Allows target to override spill slot assignment logic. If implemented, |
| /// assignCalleeSavedSpillSlots() should assign frame slots to all CSI |
| /// entries and return true. If this method returns false, spill slots will |
| /// be assigned using generic implementation. assignCalleeSavedSpillSlots() |
| /// may add, delete or rearrange elements of CSI. |
| bool |
| assignCalleeSavedSpillSlots(MachineFunction &MF, |
| const TargetRegisterInfo *TRI, |
| std::vector<CalleeSavedInfo> &CSI) const override; |
| |
| /// Issues instruction(s) to spill all callee saved registers and returns |
| /// true if it isn't possible / profitable to do so by issuing a series of |
| /// store instructions via storeRegToStackSlot(). Returns false otherwise. |
| bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, |
| MachineBasicBlock::iterator MI, |
| ArrayRef<CalleeSavedInfo> CSI, |
| const TargetRegisterInfo *TRI) const override; |
| |
| /// Issues instruction(s) to restore all callee saved registers and returns |
| /// true if it isn't possible / profitable to do so by issuing a series of |
| /// load instructions via loadRegToStackSlot(). Returns false otherwise. |
| bool |
| restoreCalleeSavedRegisters(MachineBasicBlock &MBB, |
| MachineBasicBlock::iterator MI, |
| MutableArrayRef<CalleeSavedInfo> CSI, |
| const TargetRegisterInfo *TRI) const override; |
| |
| /// Return true if the specified function should have a dedicated frame |
| /// pointer register. This is true if the function has variable sized |
| /// allocas, if it needs dynamic stack realignment, if frame pointer |
| /// elimination is disabled, or if the frame address is taken. |
| bool hasFP(const MachineFunction &MF) const override; |
| |
| /// Under normal circumstances, when a frame pointer is not required, we |
| /// reserve argument space for call sites in the function immediately on |
| /// entry to the current function. This eliminates the need for add/sub sp |
| /// brackets around call sites. Returns true if the call frame is included as |
| /// part of the stack frame. |
| bool hasReservedCallFrame(const MachineFunction &MF) const override; |
| |
| /// If there is a reserved call frame, the call frame pseudos can be |
| /// simplified. Having a FP, as in the default implementation, is not |
| /// sufficient here since we can't always use it. Use a more nuanced |
| /// condition. |
| bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override; |
| |
| // Do we need to perform FI resolution for this function. Normally, this is |
| // required only when the function has any stack objects. However, FI |
| // resolution actually has another job, not apparent from the title - it |
| // resolves callframe setup/destroy that were not simplified earlier. |
| // |
| // So, this is required for M68k functions that have push sequences even |
| // when there are no stack objects. |
| bool needsFrameIndexResolution(const MachineFunction &MF) const override; |
| |
| /// This method should return the base register and offset used to reference |
| /// a frame index location. The offset is returned directly, and the base |
| /// register is returned via FrameReg. |
| StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, |
| Register &FrameReg) const override; |
| |
| /// Check the instruction before/after the passed instruction. If |
| /// it is an ADD/SUB/LEA instruction it is deleted argument and the |
| /// stack adjustment is returned as a positive value for ADD/LEA and |
| /// a negative for SUB. |
| int mergeSPUpdates(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, |
| bool doMergeWithPrevious) const; |
| |
| /// Emit a series of instructions to increment / decrement the stack |
| /// pointer by a constant value. |
| void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, |
| int64_t NumBytes, bool InEpilogue) const; |
| }; |
| } // namespace llvm |
| |
| #endif |