xref: /freebsd/contrib/llvm-project/llvm/lib/Target/AArch64/AArch64FrameLowering.h (revision 5b56413d04e608379c9a306373554a8e4d321bc0)
1 //==-- AArch64FrameLowering.h - TargetFrameLowering for AArch64 --*- 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 //
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_LIB_TARGET_AARCH64_AARCH64FRAMELOWERING_H
14 #define LLVM_LIB_TARGET_AARCH64_AARCH64FRAMELOWERING_H
15 
16 #include "llvm/Support/TypeSize.h"
17 #include "llvm/CodeGen/TargetFrameLowering.h"
18 
19 namespace llvm {
20 
21 class AArch64FrameLowering : public TargetFrameLowering {
22 public:
23   explicit AArch64FrameLowering()
24       : TargetFrameLowering(StackGrowsDown, Align(16), 0, Align(16),
25                             true /*StackRealignable*/) {}
26 
27   void resetCFIToInitialState(MachineBasicBlock &MBB) const override;
28 
29   MachineBasicBlock::iterator
30   eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
31                                 MachineBasicBlock::iterator I) const override;
32 
33   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
34   /// the function.
35   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
36   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
37 
38   bool enableCFIFixup(MachineFunction &MF) const override;
39 
40   bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
41 
42   StackOffset getFrameIndexReference(const MachineFunction &MF, int FI,
43                                      Register &FrameReg) const override;
44   StackOffset resolveFrameIndexReference(const MachineFunction &MF, int FI,
45                                          Register &FrameReg, bool PreferFP,
46                                          bool ForSimm) const;
47   StackOffset resolveFrameOffsetReference(const MachineFunction &MF,
48                                           int64_t ObjectOffset, bool isFixed,
49                                           bool isSVE, Register &FrameReg,
50                                           bool PreferFP, bool ForSimm) const;
51   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
52                                  MachineBasicBlock::iterator MI,
53                                  ArrayRef<CalleeSavedInfo> CSI,
54                                  const TargetRegisterInfo *TRI) const override;
55 
56   bool
57   restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
58                               MachineBasicBlock::iterator MI,
59                               MutableArrayRef<CalleeSavedInfo> CSI,
60                               const TargetRegisterInfo *TRI) const override;
61 
62   /// Can this function use the red zone for local allocations.
63   bool canUseRedZone(const MachineFunction &MF) const;
64 
65   bool hasFP(const MachineFunction &MF) const override;
66   bool hasReservedCallFrame(const MachineFunction &MF) const override;
67 
68   bool assignCalleeSavedSpillSlots(MachineFunction &MF,
69                                    const TargetRegisterInfo *TRI,
70                                    std::vector<CalleeSavedInfo> &CSI,
71                                    unsigned &MinCSFrameIndex,
72                                    unsigned &MaxCSFrameIndex) const override;
73 
74   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
75                             RegScavenger *RS) const override;
76 
77   /// Returns true if the target will correctly handle shrink wrapping.
78   bool enableShrinkWrapping(const MachineFunction &MF) const override {
79     return true;
80   }
81 
82   bool enableStackSlotScavenging(const MachineFunction &MF) const override;
83   TargetStackID::Value getStackIDForScalableVectors() const override;
84 
85   void processFunctionBeforeFrameFinalized(MachineFunction &MF,
86                                            RegScavenger *RS) const override;
87 
88   void
89   processFunctionBeforeFrameIndicesReplaced(MachineFunction &MF,
90                                             RegScavenger *RS) const override;
91 
92   unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override;
93 
94   unsigned getWinEHFuncletFrameSize(const MachineFunction &MF) const;
95 
96   StackOffset
97   getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI,
98                                  Register &FrameReg,
99                                  bool IgnoreSPUpdates) const override;
100   StackOffset getNonLocalFrameIndexReference(const MachineFunction &MF,
101                                              int FI) const override;
102   int getSEHFrameIndexOffset(const MachineFunction &MF, int FI) const;
103 
104   bool isSupportedStackID(TargetStackID::Value ID) const override {
105     switch (ID) {
106     default:
107       return false;
108     case TargetStackID::Default:
109     case TargetStackID::ScalableVector:
110     case TargetStackID::NoAlloc:
111       return true;
112     }
113   }
114 
115   bool isStackIdSafeForLocalArea(unsigned StackId) const override {
116     // We don't support putting SVE objects into the pre-allocated local
117     // frame block at the moment.
118     return StackId != TargetStackID::ScalableVector;
119   }
120 
121   void
122   orderFrameObjects(const MachineFunction &MF,
123                     SmallVectorImpl<int> &ObjectsToAllocate) const override;
124 
125 private:
126   /// Returns true if a homogeneous prolog or epilog code can be emitted
127   /// for the size optimization. If so, HOM_Prolog/HOM_Epilog pseudo
128   /// instructions are emitted in place. When Exit block is given, this check is
129   /// for epilog.
130   bool homogeneousPrologEpilog(MachineFunction &MF,
131                                MachineBasicBlock *Exit = nullptr) const;
132 
133   /// Returns true if CSRs should be paired.
134   bool producePairRegisters(MachineFunction &MF) const;
135 
136   bool shouldCombineCSRLocalStackBump(MachineFunction &MF,
137                                       uint64_t StackBumpBytes) const;
138 
139   int64_t estimateSVEStackObjectOffsets(MachineFrameInfo &MF) const;
140   int64_t assignSVEStackObjectOffsets(MachineFrameInfo &MF,
141                                       int &MinCSFrameIndex,
142                                       int &MaxCSFrameIndex) const;
143   bool shouldCombineCSRLocalStackBumpInEpilogue(MachineBasicBlock &MBB,
144                                                 unsigned StackBumpBytes) const;
145   void emitCalleeSavedGPRLocations(MachineBasicBlock &MBB,
146                                    MachineBasicBlock::iterator MBBI) const;
147   void emitCalleeSavedSVELocations(MachineBasicBlock &MBB,
148                                    MachineBasicBlock::iterator MBBI) const;
149   void emitCalleeSavedGPRRestores(MachineBasicBlock &MBB,
150                                   MachineBasicBlock::iterator MBBI) const;
151   void emitCalleeSavedSVERestores(MachineBasicBlock &MBB,
152                                   MachineBasicBlock::iterator MBBI) const;
153   void allocateStackSpace(MachineBasicBlock &MBB,
154                           MachineBasicBlock::iterator MBBI,
155                           int64_t RealignmentPadding, StackOffset AllocSize,
156                           bool NeedsWinCFI, bool *HasWinCFI, bool EmitCFI,
157                           StackOffset InitialOffset, bool FollowupAllocs) const;
158 
159   /// Emit target zero call-used regs.
160   void emitZeroCallUsedRegs(BitVector RegsToZero,
161                             MachineBasicBlock &MBB) const override;
162 
163   /// Replace a StackProbe stub (if any) with the actual probe code inline
164   void inlineStackProbe(MachineFunction &MF,
165                         MachineBasicBlock &PrologueMBB) const override;
166 
167   void inlineStackProbeFixed(MachineBasicBlock::iterator MBBI,
168                              Register ScratchReg, int64_t FrameSize,
169                              StackOffset CFAOffset) const;
170 
171   MachineBasicBlock::iterator
172   inlineStackProbeLoopExactMultiple(MachineBasicBlock::iterator MBBI,
173                                     int64_t NegProbeSize,
174                                     Register TargetReg) const;
175 };
176 
177 } // End llvm namespace
178 
179 #endif
180