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

source code of llvm/lib/Target/M68k/M68kFrameLowering.h