1//===-- M68kFrameLowering.h - Define frame lowering for M68k ----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// This file contains the M68k declaration of TargetFrameLowering class.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_M68K_M68KFRAMELOWERING_H
15#define LLVM_LIB_TARGET_M68K_M68KFRAMELOWERING_H
16
17#include "M68k.h"
18
19#include "llvm/CodeGen/TargetFrameLowering.h"
20
21namespace llvm {
22class MachineInstrBuilder;
23class MCCFIInstruction;
24class M68kSubtarget;
25class M68kRegisterInfo;
26struct Align;
27
28class M68kFrameLowering : public TargetFrameLowering {
29  // Cached subtarget predicates.
30  const M68kSubtarget &STI;
31  const TargetInstrInfo &TII;
32  const M68kRegisterInfo *TRI;
33
34  /// Stack slot size in bytes.
35  unsigned SlotSize;
36
37  unsigned StackPtr;
38
39  /// If we're forcing a stack realignment we can't rely on just the frame
40  /// info, we need to know the ABI stack alignment as well in case we have a
41  /// call out.  Otherwise just make sure we have some alignment - we'll go
42  /// with the minimum SlotSize.
43  uint64_t calculateMaxStackAlign(const MachineFunction &MF) const;
44
45  /// Adjusts the stack pointer using LEA, SUB, or ADD.
46  MachineInstrBuilder BuildStackAdjustment(MachineBasicBlock &MBB,
47                                           MachineBasicBlock::iterator MBBI,
48                                           const DebugLoc &DL, int64_t Offset,
49                                           bool InEpilogue) const;
50
51  /// Aligns the stack pointer by ANDing it with -MaxAlign.
52  void BuildStackAlignAND(MachineBasicBlock &MBB,
53                          MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
54                          unsigned Reg, uint64_t MaxAlign) const;
55
56  /// Wraps up getting a CFI index and building a MachineInstr for it.
57  void BuildCFI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
58                const DebugLoc &DL, const MCCFIInstruction &CFIInst) const;
59
60  void emitPrologueCalleeSavedFrameMoves(MachineBasicBlock &MBB,
61                                         MachineBasicBlock::iterator MBBI,
62                                         const DebugLoc &DL) const;
63
64  unsigned getPSPSlotOffsetFromSP(const MachineFunction &MF) const;
65
66public:
67  explicit M68kFrameLowering(const M68kSubtarget &sti, Align Alignment);
68
69  static const M68kFrameLowering *create(const M68kSubtarget &ST);
70
71  /// This method is called during prolog/epilog code insertion to eliminate
72  /// call frame setup and destroy pseudo instructions (but only if the Target
73  /// is using them).  It is responsible for eliminating these instructions,
74  /// replacing them with concrete instructions.  This method need only be
75  /// implemented if using call frame setup/destroy pseudo instructions.
76  /// Returns an iterator pointing to the instruction after the replaced one.
77  MachineBasicBlock::iterator
78  eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
79                                MachineBasicBlock::iterator MI) const override;
80
81  /// Insert prolog code into the function.
82  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
83
84  /// Insert epilog code into the function.
85  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
86
87  /// This method determines which of the registers reported by
88  /// TargetRegisterInfo::getCalleeSavedRegs() should actually get saved.
89  /// The default implementation checks populates the \p SavedRegs bitset with
90  /// all registers which are modified in the function, targets may override
91  /// this function to save additional registers.
92  /// This method also sets up the register scavenger ensuring there is a free
93  /// register or a frameindex available.
94  void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
95                            RegScavenger *RS = nullptr) const override;
96
97  /// Allows target to override spill slot assignment logic.  If implemented,
98  /// assignCalleeSavedSpillSlots() should assign frame slots to all CSI
99  /// entries and return true.  If this method returns false, spill slots will
100  /// be assigned using generic implementation.  assignCalleeSavedSpillSlots()
101  /// may add, delete or rearrange elements of CSI.
102  bool
103  assignCalleeSavedSpillSlots(MachineFunction &MF,
104                              const TargetRegisterInfo *TRI,
105                              std::vector<CalleeSavedInfo> &CSI) const override;
106
107  /// Issues instruction(s) to spill all callee saved registers and returns
108  /// true if it isn't possible / profitable to do so by issuing a series of
109  /// store instructions via storeRegToStackSlot(). Returns false otherwise.
110  bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
111                                 MachineBasicBlock::iterator MI,
112                                 ArrayRef<CalleeSavedInfo> CSI,
113                                 const TargetRegisterInfo *TRI) const override;
114
115  /// Issues instruction(s) to restore all callee saved registers and returns
116  /// true if it isn't possible / profitable to do so by issuing a series of
117  /// load instructions via loadRegToStackSlot().  Returns false otherwise.
118  bool
119  restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
120                              MachineBasicBlock::iterator MI,
121                              MutableArrayRef<CalleeSavedInfo> CSI,
122                              const TargetRegisterInfo *TRI) const override;
123
124  /// Return true if the specified function should have a dedicated frame
125  /// pointer register.  This is true if the function has variable sized
126  /// allocas, if it needs dynamic stack realignment, if frame pointer
127  /// elimination is disabled, or if the frame address is taken.
128  bool hasFP(const MachineFunction &MF) const override;
129
130  /// Under normal circumstances, when a frame pointer is not required, we
131  /// reserve argument space for call sites in the function immediately on
132  /// entry to the current function. This eliminates the need for add/sub sp
133  /// brackets around call sites. Returns true if the call frame is included as
134  /// part of the stack frame.
135  bool hasReservedCallFrame(const MachineFunction &MF) const override;
136
137  /// If there is a reserved call frame, the call frame pseudos can be
138  /// simplified.  Having a FP, as in the default implementation, is not
139  /// sufficient here since we can't always use it.  Use a more nuanced
140  /// condition.
141  bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;
142
143  // Do we need to perform FI resolution for this function. Normally, this is
144  // required only when the function has any stack objects. However, FI
145  // resolution actually has another job, not apparent from the title - it
146  // resolves callframe setup/destroy that were not simplified earlier.
147  //
148  // So, this is required for M68k functions that have push sequences even
149  // when there are no stack objects.
150  bool needsFrameIndexResolution(const MachineFunction &MF) const override;
151
152  /// This method should return the base register and offset used to reference
153  /// a frame index location. The offset is returned directly, and the base
154  /// register is returned via FrameReg.
155  StackOffset getFrameIndexReference(const MachineFunction &MF, int FI,
156                                     Register &FrameReg) const override;
157
158  /// Check the instruction before/after the passed instruction. If
159  /// it is an ADD/SUB/LEA instruction it is deleted argument and the
160  /// stack adjustment is returned as a positive value for ADD/LEA and
161  /// a negative for SUB.
162  int mergeSPUpdates(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
163                     bool doMergeWithPrevious) const;
164
165  /// Emit a series of instructions to increment / decrement the stack
166  /// pointer by a constant value.
167  void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
168                    int64_t NumBytes, bool InEpilogue) const;
169};
170} // namespace llvm
171
172#endif // LLVM_LIB_TARGET_M68K_M68KFRAMELOWERING_H
173