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 MCCFIInstruction;
22 
23 class AArch64FrameLowering : public TargetFrameLowering {
24 public:
AArch64FrameLowering()25   explicit AArch64FrameLowering()
26       : TargetFrameLowering(StackGrowsDown, Align(16), 0, Align(16),
27                             true /*StackRealignable*/) {}
28 
29   void
30   emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
31                             MachineBasicBlock::iterator MBBI) const override;
32 
33   MachineBasicBlock::iterator
34   eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
35                                 MachineBasicBlock::iterator I) const override;
36 
37   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
38   /// the function.
39   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
40   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
41 
42   bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
43 
44   StackOffset getFrameIndexReference(const MachineFunction &MF, int FI,
45                                      Register &FrameReg) const override;
46   StackOffset resolveFrameIndexReference(const MachineFunction &MF, int FI,
47                                          Register &FrameReg, bool PreferFP,
48                                          bool ForSimm) const;
49   StackOffset resolveFrameOffsetReference(const MachineFunction &MF,
50                                           int64_t ObjectOffset, bool isFixed,
51                                           bool isSVE, Register &FrameReg,
52                                           bool PreferFP, bool ForSimm) const;
53   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
54                                  MachineBasicBlock::iterator MI,
55                                  ArrayRef<CalleeSavedInfo> CSI,
56                                  const TargetRegisterInfo *TRI) const override;
57 
58   bool
59   restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
60                               MachineBasicBlock::iterator MI,
61                               MutableArrayRef<CalleeSavedInfo> CSI,
62                               const TargetRegisterInfo *TRI) const override;
63 
64   /// Can this function use the red zone for local allocations.
65   bool canUseRedZone(const MachineFunction &MF) const;
66 
67   bool hasFP(const MachineFunction &MF) const override;
68   bool hasReservedCallFrame(const MachineFunction &MF) const override;
69 
70   bool
71   assignCalleeSavedSpillSlots(MachineFunction &MF,
72                               const TargetRegisterInfo *TRI,
73                               std::vector<CalleeSavedInfo> &CSI) const override;
74 
75   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
76                             RegScavenger *RS) const override;
77 
78   /// Returns true if the target will correctly handle shrink wrapping.
enableShrinkWrapping(const MachineFunction & MF)79   bool enableShrinkWrapping(const MachineFunction &MF) const override {
80     return true;
81   }
82 
83   bool enableStackSlotScavenging(const MachineFunction &MF) const override;
84   TargetStackID::Value getStackIDForScalableVectors() const override;
85 
86   void processFunctionBeforeFrameFinalized(MachineFunction &MF,
87                                              RegScavenger *RS) const override;
88 
89   void
90   processFunctionBeforeFrameIndicesReplaced(MachineFunction &MF,
91                                             RegScavenger *RS) const override;
92 
93   unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override;
94 
95   unsigned getWinEHFuncletFrameSize(const MachineFunction &MF) const;
96 
97   StackOffset
98   getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI,
99                                  Register &FrameReg,
100                                  bool IgnoreSPUpdates) const override;
101   StackOffset getNonLocalFrameIndexReference(const MachineFunction &MF,
102                                              int FI) const override;
103   int getSEHFrameIndexOffset(const MachineFunction &MF, int FI) const;
104 
isSupportedStackID(TargetStackID::Value ID)105   bool isSupportedStackID(TargetStackID::Value ID) const override {
106     switch (ID) {
107     default:
108       return false;
109     case TargetStackID::Default:
110     case TargetStackID::ScalableVector:
111     case TargetStackID::NoAlloc:
112       return true;
113     }
114   }
115 
isStackIdSafeForLocalArea(unsigned StackId)116   bool isStackIdSafeForLocalArea(unsigned StackId) const override {
117     // We don't support putting SVE objects into the pre-allocated local
118     // frame block at the moment.
119     return StackId != TargetStackID::ScalableVector;
120   }
121 
122   void
123   orderFrameObjects(const MachineFunction &MF,
124                     SmallVectorImpl<int> &ObjectsToAllocate) const override;
125 
126 private:
127   bool shouldCombineCSRLocalStackBump(MachineFunction &MF,
128                                       uint64_t StackBumpBytes) const;
129 
130   int64_t estimateSVEStackObjectOffsets(MachineFrameInfo &MF) const;
131   int64_t assignSVEStackObjectOffsets(MachineFrameInfo &MF,
132                                       int &MinCSFrameIndex,
133                                       int &MaxCSFrameIndex) const;
134   MCCFIInstruction
135   createDefCFAExpressionFromSP(const TargetRegisterInfo &TRI,
136                                const StackOffset &OffsetFromSP) const;
137   MCCFIInstruction createCfaOffset(const TargetRegisterInfo &MRI, unsigned DwarfReg,
138                                    const StackOffset &OffsetFromDefCFA) const;
139   bool shouldCombineCSRLocalStackBumpInEpilogue(MachineBasicBlock &MBB,
140                                                 unsigned StackBumpBytes) const;
141 };
142 
143 } // End llvm namespace
144 
145 #endif
146