/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/Target/PowerPC/PPCFrameLowering.h
Line | Count | Source |
1 | | //===-- PPCFrameLowering.h - Define frame lowering for PowerPC --*- 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 | | #ifndef LLVM_LIB_TARGET_POWERPC_PPCFRAMELOWERING_H |
13 | | #define LLVM_LIB_TARGET_POWERPC_PPCFRAMELOWERING_H |
14 | | |
15 | | #include "llvm/ADT/STLExtras.h" |
16 | | #include "llvm/CodeGen/TargetFrameLowering.h" |
17 | | #include "llvm/Target/TargetMachine.h" |
18 | | |
19 | | namespace llvm { |
20 | | class PPCSubtarget; |
21 | | |
22 | | class PPCFrameLowering: public TargetFrameLowering { |
23 | | const PPCSubtarget &Subtarget; |
24 | | const unsigned ReturnSaveOffset; |
25 | | const unsigned TOCSaveOffset; |
26 | | const unsigned FramePointerSaveOffset; |
27 | | const unsigned LinkageSize; |
28 | | const unsigned BasePointerSaveOffset; |
29 | | |
30 | | /** |
31 | | * Find register[s] that can be used in function prologue and epilogue |
32 | | * |
33 | | * Find register[s] that can be use as scratch register[s] in function |
34 | | * prologue and epilogue to save various registers (Link Register, Base |
35 | | * Pointer, etc.). Prefer R0/R12, if available. Otherwise choose whatever |
36 | | * register[s] are available. |
37 | | * |
38 | | * This method will return true if it is able to find enough unique scratch |
39 | | * registers (1 or 2 depending on the requirement). If it is unable to find |
40 | | * enough available registers in the block, it will return false and set |
41 | | * any passed output parameter that corresponds to a required unique register |
42 | | * to PPC::NoRegister. |
43 | | * |
44 | | * \param[in] MBB The machine basic block to find an available register for |
45 | | * \param[in] UseAtEnd Specify whether the scratch register will be used at |
46 | | * the end of the basic block (i.e., will the scratch |
47 | | * register kill a register defined in the basic block) |
48 | | * \param[in] TwoUniqueRegsRequired Specify whether this basic block will |
49 | | * require two unique scratch registers. |
50 | | * \param[out] SR1 The scratch register to use |
51 | | * \param[out] SR2 The second scratch register. If this pointer is not null |
52 | | * the function will attempt to set it to an available |
53 | | * register regardless of whether there is a hard requirement |
54 | | * for two unique scratch registers. |
55 | | * \return true if the required number of registers was found. |
56 | | * false if the required number of scratch register weren't available. |
57 | | * If either output parameter refers to a required scratch register |
58 | | * that isn't available, it will be set to an invalid value. |
59 | | */ |
60 | | bool findScratchRegister(MachineBasicBlock *MBB, |
61 | | bool UseAtEnd, |
62 | | bool TwoUniqueRegsRequired = false, |
63 | | unsigned *SR1 = nullptr, |
64 | | unsigned *SR2 = nullptr) const; |
65 | | bool twoUniqueScratchRegsRequired(MachineBasicBlock *MBB) const; |
66 | | |
67 | | /** |
68 | | * Create branch instruction for PPC::TCRETURN* (tail call return) |
69 | | * |
70 | | * \param[in] MBB that is terminated by PPC::TCRETURN* |
71 | | */ |
72 | | void createTailCallBranchInstr(MachineBasicBlock &MBB) const; |
73 | | |
74 | | /** |
75 | | * Check if the conditions are correct to allow for the stack update |
76 | | * to be moved past the CSR save/restore code. |
77 | | */ |
78 | | bool stackUpdateCanBeMoved(MachineFunction &MF) const; |
79 | | |
80 | | public: |
81 | | PPCFrameLowering(const PPCSubtarget &STI); |
82 | | |
83 | | /** |
84 | | * Determine the frame layout and update the machine function. |
85 | | */ |
86 | | unsigned determineFrameLayoutAndUpdate(MachineFunction &MF, |
87 | | bool UseEstimate = false) const; |
88 | | |
89 | | /** |
90 | | * Determine the frame layout but do not update the machine function. |
91 | | * The MachineFunction object can be const in this case as it is not |
92 | | * modified. |
93 | | */ |
94 | | unsigned determineFrameLayout(const MachineFunction &MF, |
95 | | bool UseEstimate = false, |
96 | | unsigned *NewMaxCallFrameSize = nullptr) const; |
97 | | |
98 | | /// emitProlog/emitEpilog - These methods insert prolog and epilog code into |
99 | | /// the function. |
100 | | void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override; |
101 | | void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override; |
102 | | |
103 | | bool hasFP(const MachineFunction &MF) const override; |
104 | | bool needsFP(const MachineFunction &MF) const; |
105 | | void replaceFPWithRealFP(MachineFunction &MF) const; |
106 | | |
107 | | void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, |
108 | | RegScavenger *RS = nullptr) const override; |
109 | | void processFunctionBeforeFrameFinalized(MachineFunction &MF, |
110 | | RegScavenger *RS = nullptr) const override; |
111 | | void addScavengingSpillSlot(MachineFunction &MF, RegScavenger *RS) const; |
112 | | |
113 | | bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, |
114 | | MachineBasicBlock::iterator MI, |
115 | | const std::vector<CalleeSavedInfo> &CSI, |
116 | | const TargetRegisterInfo *TRI) const override; |
117 | | /// This function will assign callee saved gprs to volatile vector registers |
118 | | /// for prologue spills when applicable. It returns false if there are any |
119 | | /// registers which were not spilled to volatile vector registers. |
120 | | bool |
121 | | assignCalleeSavedSpillSlots(MachineFunction &MF, |
122 | | const TargetRegisterInfo *TRI, |
123 | | std::vector<CalleeSavedInfo> &CSI) const override; |
124 | | |
125 | | MachineBasicBlock::iterator |
126 | | eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, |
127 | | MachineBasicBlock::iterator I) const override; |
128 | | |
129 | | bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, |
130 | | MachineBasicBlock::iterator MI, |
131 | | std::vector<CalleeSavedInfo> &CSI, |
132 | | const TargetRegisterInfo *TRI) const override; |
133 | | |
134 | | /// targetHandlesStackFrameRounding - Returns true if the target is |
135 | | /// responsible for rounding up the stack frame (probably at emitPrologue |
136 | | /// time). |
137 | 11.2k | bool targetHandlesStackFrameRounding() const override { return true; } |
138 | | |
139 | | /// getReturnSaveOffset - Return the previous frame offset to save the |
140 | | /// return address. |
141 | 22.6k | unsigned getReturnSaveOffset() const { return ReturnSaveOffset; } |
142 | | |
143 | | /// getTOCSaveOffset - Return the previous frame offset to save the |
144 | | /// TOC register -- 64-bit SVR4 ABI only. |
145 | 290 | unsigned getTOCSaveOffset() const { return TOCSaveOffset; } |
146 | | |
147 | | /// getFramePointerSaveOffset - Return the previous frame offset to save the |
148 | | /// frame pointer. |
149 | 155 | unsigned getFramePointerSaveOffset() const { return FramePointerSaveOffset; } |
150 | | |
151 | | /// getBasePointerSaveOffset - Return the previous frame offset to save the |
152 | | /// base pointer. |
153 | 26 | unsigned getBasePointerSaveOffset() const { return BasePointerSaveOffset; } |
154 | | |
155 | | /// getLinkageSize - Return the size of the PowerPC ABI linkage area. |
156 | | /// |
157 | 19.7k | unsigned getLinkageSize() const { return LinkageSize; } |
158 | | |
159 | | const SpillSlot * |
160 | | getCalleeSavedSpillSlots(unsigned &NumEntries) const override; |
161 | | |
162 | | bool enableShrinkWrapping(const MachineFunction &MF) const override; |
163 | | |
164 | | /// Methods used by shrink wrapping to determine if MBB can be used for the |
165 | | /// function prologue/epilogue. |
166 | | bool canUseAsPrologue(const MachineBasicBlock &MBB) const override; |
167 | | bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override; |
168 | | }; |
169 | | } // End llvm namespace |
170 | | |
171 | | #endif |