1 //===- Thumb1FrameLowering.h - Thumb1-specific frame info stuff ---*- 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 #ifndef LLVM_LIB_TARGET_ARM_THUMB1FRAMELOWERING_H
10 #define LLVM_LIB_TARGET_ARM_THUMB1FRAMELOWERING_H
11 
12 #include "ARMFrameLowering.h"
13 
14 namespace llvm {
15 
16 class ARMSubtarget;
17 class MachineFunction;
18 
19 class Thumb1FrameLowering : public ARMFrameLowering {
20 public:
21   explicit Thumb1FrameLowering(const ARMSubtarget &sti);
22 
23   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
24   /// the function.
25   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
26   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
27 
28   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
29                                  MachineBasicBlock::iterator MI,
30                                  ArrayRef<CalleeSavedInfo> CSI,
31                                  const TargetRegisterInfo *TRI) const override;
32   bool
33   restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
34                               MachineBasicBlock::iterator MI,
35                               MutableArrayRef<CalleeSavedInfo> CSI,
36                               const TargetRegisterInfo *TRI) const override;
37 
38   bool hasReservedCallFrame(const MachineFunction &MF) const override;
39 
40   MachineBasicBlock::iterator
41   eliminateCallFramePseudoInstr(MachineFunction &MF,
42                                 MachineBasicBlock &MBB,
43                                 MachineBasicBlock::iterator MI) const override;
44 
45   /// Check whether or not the given \p MBB can be used as a epilogue
46   /// for the target.
47   /// The epilogue will be inserted before the first terminator of that block.
48   /// This method is used by the shrink-wrapping pass to decide if
49   /// \p MBB will be correctly handled by the target.
50   bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
51 
52   /// Disable shrink wrap as tBfar/BL will be used to adjust for long jumps.
enableShrinkWrapping(const MachineFunction & MF)53   bool enableShrinkWrapping(const MachineFunction &MF) const override {
54     return false;
55   }
56 
57 private:
58   /// Check if the frame lowering of \p MF needs a special fixup
59   /// code sequence for the epilogue.
60   /// Unlike T2 and ARM mode, the T1 pop instruction cannot restore
61   /// to LR, and we can't pop the value directly to the PC when
62   /// we need to update the SP after popping the value. So instead
63   /// we have to emit:
64   ///   POP {r3}
65   ///   ADD sp, #offset
66   ///   BX r3
67   /// If this would clobber a return value, then generate this sequence instead:
68   ///   MOV ip, r3
69   ///   POP {r3}
70   ///   ADD sp, #offset
71   ///   MOV lr, r3
72   ///   MOV r3, ip
73   ///   BX lr
74   bool needPopSpecialFixUp(const MachineFunction &MF) const;
75 
76   /// Emit the special fixup code sequence for the epilogue.
77   /// \see needPopSpecialFixUp for more details.
78   /// \p DoIt, tells this method whether or not to actually insert
79   /// the code sequence in \p MBB. I.e., when \p DoIt is false,
80   /// \p MBB is left untouched.
81   /// \returns For \p DoIt == true: True when the emission succeeded
82   /// false otherwise. For \p DoIt == false: True when the emission
83   /// would have been possible, false otherwise.
84   bool emitPopSpecialFixUp(MachineBasicBlock &MBB, bool DoIt) const;
85 };
86 
87 } // end namespace llvm
88 
89 #endif // LLVM_LIB_TARGET_ARM_THUMB1FRAMELOWERING_H
90