File: | llvm/lib/Target/AMDGPU/SIAddIMGInit.cpp |
Warning: | line 80, column 27 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===-- SIAddIMGInit.cpp - Add any required IMG inits ---------------------===// | |||
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 | /// Any MIMG instructions that use tfe or lwe require an initialization of the | |||
11 | /// result register that will be written in the case of a memory access failure | |||
12 | /// The required code is also added to tie this init code to the result of the | |||
13 | /// img instruction | |||
14 | /// | |||
15 | //===----------------------------------------------------------------------===// | |||
16 | // | |||
17 | ||||
18 | #include "AMDGPU.h" | |||
19 | #include "GCNSubtarget.h" | |||
20 | #include "MCTargetDesc/AMDGPUMCTargetDesc.h" | |||
21 | #include "llvm/CodeGen/MachineFunctionPass.h" | |||
22 | ||||
23 | #define DEBUG_TYPE"si-img-init" "si-img-init" | |||
24 | ||||
25 | using namespace llvm; | |||
26 | ||||
27 | namespace { | |||
28 | ||||
29 | class SIAddIMGInit : public MachineFunctionPass { | |||
30 | public: | |||
31 | static char ID; | |||
32 | ||||
33 | public: | |||
34 | SIAddIMGInit() : MachineFunctionPass(ID) { | |||
35 | initializeSIAddIMGInitPass(*PassRegistry::getPassRegistry()); | |||
36 | } | |||
37 | ||||
38 | bool runOnMachineFunction(MachineFunction &MF) override; | |||
39 | ||||
40 | void getAnalysisUsage(AnalysisUsage &AU) const override { | |||
41 | AU.setPreservesCFG(); | |||
42 | MachineFunctionPass::getAnalysisUsage(AU); | |||
43 | } | |||
44 | }; | |||
45 | ||||
46 | } // End anonymous namespace. | |||
47 | ||||
48 | INITIALIZE_PASS(SIAddIMGInit, DEBUG_TYPE, "SI Add IMG Init", false, false)static void *initializeSIAddIMGInitPassOnce(PassRegistry & Registry) { PassInfo *PI = new PassInfo( "SI Add IMG Init", "si-img-init" , &SIAddIMGInit::ID, PassInfo::NormalCtor_t(callDefaultCtor <SIAddIMGInit>), false, false); Registry.registerPass(* PI, true); return PI; } static llvm::once_flag InitializeSIAddIMGInitPassFlag ; void llvm::initializeSIAddIMGInitPass(PassRegistry &Registry ) { llvm::call_once(InitializeSIAddIMGInitPassFlag, initializeSIAddIMGInitPassOnce , std::ref(Registry)); } | |||
49 | ||||
50 | char SIAddIMGInit::ID = 0; | |||
51 | ||||
52 | char &llvm::SIAddIMGInitID = SIAddIMGInit::ID; | |||
53 | ||||
54 | FunctionPass *llvm::createSIAddIMGInitPass() { return new SIAddIMGInit(); } | |||
55 | ||||
56 | bool SIAddIMGInit::runOnMachineFunction(MachineFunction &MF) { | |||
57 | MachineRegisterInfo &MRI = MF.getRegInfo(); | |||
58 | const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>(); | |||
59 | const SIInstrInfo *TII = ST.getInstrInfo(); | |||
60 | const SIRegisterInfo *RI = ST.getRegisterInfo(); | |||
61 | bool Changed = false; | |||
62 | ||||
63 | for (MachineFunction::iterator BI = MF.begin(), BE = MF.end(); BI != BE; | |||
| ||||
64 | ++BI) { | |||
65 | MachineBasicBlock &MBB = *BI; | |||
66 | MachineBasicBlock::iterator I, Next; | |||
67 | for (I = MBB.begin(); I != MBB.end(); I = Next) { | |||
68 | Next = std::next(I); | |||
69 | MachineInstr &MI = *I; | |||
70 | ||||
71 | auto Opcode = MI.getOpcode(); | |||
72 | if (TII->isMIMG(Opcode) && !MI.mayStore()) { | |||
73 | MachineOperand *TFE = TII->getNamedOperand(MI, AMDGPU::OpName::tfe); | |||
74 | MachineOperand *LWE = TII->getNamedOperand(MI, AMDGPU::OpName::lwe); | |||
75 | MachineOperand *D16 = TII->getNamedOperand(MI, AMDGPU::OpName::d16); | |||
76 | ||||
77 | if (!TFE && !LWE) // intersect_ray | |||
78 | continue; | |||
79 | ||||
80 | unsigned TFEVal = TFE->getImm(); | |||
| ||||
81 | unsigned LWEVal = LWE->getImm(); | |||
82 | unsigned D16Val = D16 ? D16->getImm() : 0; | |||
83 | ||||
84 | if (TFEVal || LWEVal) { | |||
85 | // At least one of TFE or LWE are non-zero | |||
86 | // We have to insert a suitable initialization of the result value and | |||
87 | // tie this to the dest of the image instruction. | |||
88 | ||||
89 | const DebugLoc &DL = MI.getDebugLoc(); | |||
90 | ||||
91 | int DstIdx = | |||
92 | AMDGPU::getNamedOperandIdx(MI.getOpcode(), AMDGPU::OpName::vdata); | |||
93 | ||||
94 | // Calculate which dword we have to initialize to 0. | |||
95 | MachineOperand *MO_Dmask = | |||
96 | TII->getNamedOperand(MI, AMDGPU::OpName::dmask); | |||
97 | ||||
98 | // check that dmask operand is found. | |||
99 | assert(MO_Dmask && "Expected dmask operand in instruction")((MO_Dmask && "Expected dmask operand in instruction" ) ? static_cast<void> (0) : __assert_fail ("MO_Dmask && \"Expected dmask operand in instruction\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/lib/Target/AMDGPU/SIAddIMGInit.cpp" , 99, __PRETTY_FUNCTION__)); | |||
100 | ||||
101 | unsigned dmask = MO_Dmask->getImm(); | |||
102 | // Determine the number of active lanes taking into account the | |||
103 | // Gather4 special case | |||
104 | unsigned ActiveLanes = | |||
105 | TII->isGather4(Opcode) ? 4 : countPopulation(dmask); | |||
106 | ||||
107 | bool Packed = !ST.hasUnpackedD16VMem(); | |||
108 | ||||
109 | unsigned InitIdx = | |||
110 | D16Val && Packed ? ((ActiveLanes + 1) >> 1) + 1 : ActiveLanes + 1; | |||
111 | ||||
112 | // Abandon attempt if the dst size isn't large enough | |||
113 | // - this is in fact an error but this is picked up elsewhere and | |||
114 | // reported correctly. | |||
115 | uint32_t DstSize = | |||
116 | RI->getRegSizeInBits(*TII->getOpRegClass(MI, DstIdx)) / 32; | |||
117 | if (DstSize < InitIdx) | |||
118 | continue; | |||
119 | ||||
120 | // Create a register for the intialization value. | |||
121 | Register PrevDst = | |||
122 | MRI.createVirtualRegister(TII->getOpRegClass(MI, DstIdx)); | |||
123 | unsigned NewDst = 0; // Final initialized value will be in here | |||
124 | ||||
125 | // If PRTStrictNull feature is enabled (the default) then initialize | |||
126 | // all the result registers to 0, otherwise just the error indication | |||
127 | // register (VGPRn+1) | |||
128 | unsigned SizeLeft = ST.usePRTStrictNull() ? InitIdx : 1; | |||
129 | unsigned CurrIdx = ST.usePRTStrictNull() ? 0 : (InitIdx - 1); | |||
130 | ||||
131 | if (DstSize == 1) { | |||
132 | // In this case we can just initialize the result directly | |||
133 | BuildMI(MBB, MI, DL, TII->get(AMDGPU::V_MOV_B32_e32), PrevDst) | |||
134 | .addImm(0); | |||
135 | NewDst = PrevDst; | |||
136 | } else { | |||
137 | BuildMI(MBB, MI, DL, TII->get(AMDGPU::IMPLICIT_DEF), PrevDst); | |||
138 | for (; SizeLeft; SizeLeft--, CurrIdx++) { | |||
139 | NewDst = | |||
140 | MRI.createVirtualRegister(TII->getOpRegClass(MI, DstIdx)); | |||
141 | // Initialize dword | |||
142 | Register SubReg = | |||
143 | MRI.createVirtualRegister(&AMDGPU::VGPR_32RegClass); | |||
144 | BuildMI(MBB, MI, DL, TII->get(AMDGPU::V_MOV_B32_e32), SubReg) | |||
145 | .addImm(0); | |||
146 | // Insert into the super-reg | |||
147 | BuildMI(MBB, I, DL, TII->get(TargetOpcode::INSERT_SUBREG), NewDst) | |||
148 | .addReg(PrevDst) | |||
149 | .addReg(SubReg) | |||
150 | .addImm(SIRegisterInfo::getSubRegFromChannel(CurrIdx)); | |||
151 | ||||
152 | PrevDst = NewDst; | |||
153 | } | |||
154 | } | |||
155 | ||||
156 | // Add as an implicit operand | |||
157 | MachineInstrBuilder(MF, MI).addReg(NewDst, RegState::Implicit); | |||
158 | ||||
159 | // Tie the just added implicit operand to the dst | |||
160 | MI.tieOperands(DstIdx, MI.getNumOperands() - 1); | |||
161 | ||||
162 | Changed = true; | |||
163 | } | |||
164 | } | |||
165 | } | |||
166 | } | |||
167 | ||||
168 | return Changed; | |||
169 | } |
1 | //===- llvm/ADT/ilist_iterator.h - Intrusive List Iterator ------*- 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_ADT_ILIST_ITERATOR_H |
10 | #define LLVM_ADT_ILIST_ITERATOR_H |
11 | |
12 | #include "llvm/ADT/ilist_node.h" |
13 | #include <cassert> |
14 | #include <cstddef> |
15 | #include <iterator> |
16 | #include <type_traits> |
17 | |
18 | namespace llvm { |
19 | |
20 | namespace ilist_detail { |
21 | |
22 | /// Find const-correct node types. |
23 | template <class OptionsT, bool IsConst> struct IteratorTraits; |
24 | template <class OptionsT> struct IteratorTraits<OptionsT, false> { |
25 | using value_type = typename OptionsT::value_type; |
26 | using pointer = typename OptionsT::pointer; |
27 | using reference = typename OptionsT::reference; |
28 | using node_pointer = ilist_node_impl<OptionsT> *; |
29 | using node_reference = ilist_node_impl<OptionsT> &; |
30 | }; |
31 | template <class OptionsT> struct IteratorTraits<OptionsT, true> { |
32 | using value_type = const typename OptionsT::value_type; |
33 | using pointer = typename OptionsT::const_pointer; |
34 | using reference = typename OptionsT::const_reference; |
35 | using node_pointer = const ilist_node_impl<OptionsT> *; |
36 | using node_reference = const ilist_node_impl<OptionsT> &; |
37 | }; |
38 | |
39 | template <bool IsReverse> struct IteratorHelper; |
40 | template <> struct IteratorHelper<false> : ilist_detail::NodeAccess { |
41 | using Access = ilist_detail::NodeAccess; |
42 | |
43 | template <class T> static void increment(T *&I) { I = Access::getNext(*I); } |
44 | template <class T> static void decrement(T *&I) { I = Access::getPrev(*I); } |
45 | }; |
46 | template <> struct IteratorHelper<true> : ilist_detail::NodeAccess { |
47 | using Access = ilist_detail::NodeAccess; |
48 | |
49 | template <class T> static void increment(T *&I) { I = Access::getPrev(*I); } |
50 | template <class T> static void decrement(T *&I) { I = Access::getNext(*I); } |
51 | }; |
52 | |
53 | } // end namespace ilist_detail |
54 | |
55 | /// Iterator for intrusive lists based on ilist_node. |
56 | template <class OptionsT, bool IsReverse, bool IsConst> |
57 | class ilist_iterator : ilist_detail::SpecificNodeAccess<OptionsT> { |
58 | friend ilist_iterator<OptionsT, IsReverse, !IsConst>; |
59 | friend ilist_iterator<OptionsT, !IsReverse, IsConst>; |
60 | friend ilist_iterator<OptionsT, !IsReverse, !IsConst>; |
61 | |
62 | using Traits = ilist_detail::IteratorTraits<OptionsT, IsConst>; |
63 | using Access = ilist_detail::SpecificNodeAccess<OptionsT>; |
64 | |
65 | public: |
66 | using value_type = typename Traits::value_type; |
67 | using pointer = typename Traits::pointer; |
68 | using reference = typename Traits::reference; |
69 | using difference_type = ptrdiff_t; |
70 | using iterator_category = std::bidirectional_iterator_tag; |
71 | using const_pointer = typename OptionsT::const_pointer; |
72 | using const_reference = typename OptionsT::const_reference; |
73 | |
74 | private: |
75 | using node_pointer = typename Traits::node_pointer; |
76 | using node_reference = typename Traits::node_reference; |
77 | |
78 | node_pointer NodePtr = nullptr; |
79 | |
80 | public: |
81 | /// Create from an ilist_node. |
82 | explicit ilist_iterator(node_reference N) : NodePtr(&N) {} |
83 | |
84 | explicit ilist_iterator(pointer NP) : NodePtr(Access::getNodePtr(NP)) {} |
85 | explicit ilist_iterator(reference NR) : NodePtr(Access::getNodePtr(&NR)) {} |
86 | ilist_iterator() = default; |
87 | |
88 | // This is templated so that we can allow constructing a const iterator from |
89 | // a nonconst iterator... |
90 | template <bool RHSIsConst> |
91 | ilist_iterator(const ilist_iterator<OptionsT, IsReverse, RHSIsConst> &RHS, |
92 | std::enable_if_t<IsConst || !RHSIsConst, void *> = nullptr) |
93 | : NodePtr(RHS.NodePtr) {} |
94 | |
95 | // This is templated so that we can allow assigning to a const iterator from |
96 | // a nonconst iterator... |
97 | template <bool RHSIsConst> |
98 | std::enable_if_t<IsConst || !RHSIsConst, ilist_iterator &> |
99 | operator=(const ilist_iterator<OptionsT, IsReverse, RHSIsConst> &RHS) { |
100 | NodePtr = RHS.NodePtr; |
101 | return *this; |
102 | } |
103 | |
104 | /// Explicit conversion between forward/reverse iterators. |
105 | /// |
106 | /// Translate between forward and reverse iterators without changing range |
107 | /// boundaries. The resulting iterator will dereference (and have a handle) |
108 | /// to the previous node, which is somewhat unexpected; but converting the |
109 | /// two endpoints in a range will give the same range in reverse. |
110 | /// |
111 | /// This matches std::reverse_iterator conversions. |
112 | explicit ilist_iterator( |
113 | const ilist_iterator<OptionsT, !IsReverse, IsConst> &RHS) |
114 | : ilist_iterator(++RHS.getReverse()) {} |
115 | |
116 | /// Get a reverse iterator to the same node. |
117 | /// |
118 | /// Gives a reverse iterator that will dereference (and have a handle) to the |
119 | /// same node. Converting the endpoint iterators in a range will give a |
120 | /// different range; for range operations, use the explicit conversions. |
121 | ilist_iterator<OptionsT, !IsReverse, IsConst> getReverse() const { |
122 | if (NodePtr) |
123 | return ilist_iterator<OptionsT, !IsReverse, IsConst>(*NodePtr); |
124 | return ilist_iterator<OptionsT, !IsReverse, IsConst>(); |
125 | } |
126 | |
127 | /// Const-cast. |
128 | ilist_iterator<OptionsT, IsReverse, false> getNonConst() const { |
129 | if (NodePtr) |
130 | return ilist_iterator<OptionsT, IsReverse, false>( |
131 | const_cast<typename ilist_iterator<OptionsT, IsReverse, |
132 | false>::node_reference>(*NodePtr)); |
133 | return ilist_iterator<OptionsT, IsReverse, false>(); |
134 | } |
135 | |
136 | // Accessors... |
137 | reference operator*() const { |
138 | assert(!NodePtr->isKnownSentinel())((!NodePtr->isKnownSentinel()) ? static_cast<void> ( 0) : __assert_fail ("!NodePtr->isKnownSentinel()", "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/ADT/ilist_iterator.h" , 138, __PRETTY_FUNCTION__)); |
139 | return *Access::getValuePtr(NodePtr); |
140 | } |
141 | pointer operator->() const { return &operator*(); } |
142 | |
143 | // Comparison operators |
144 | friend bool operator==(const ilist_iterator &LHS, const ilist_iterator &RHS) { |
145 | return LHS.NodePtr == RHS.NodePtr; |
146 | } |
147 | friend bool operator!=(const ilist_iterator &LHS, const ilist_iterator &RHS) { |
148 | return LHS.NodePtr != RHS.NodePtr; |
149 | } |
150 | |
151 | // Increment and decrement operators... |
152 | ilist_iterator &operator--() { |
153 | NodePtr = IsReverse ? NodePtr->getNext() : NodePtr->getPrev(); |
154 | return *this; |
155 | } |
156 | ilist_iterator &operator++() { |
157 | NodePtr = IsReverse ? NodePtr->getPrev() : NodePtr->getNext(); |
158 | return *this; |
159 | } |
160 | ilist_iterator operator--(int) { |
161 | ilist_iterator tmp = *this; |
162 | --*this; |
163 | return tmp; |
164 | } |
165 | ilist_iterator operator++(int) { |
166 | ilist_iterator tmp = *this; |
167 | ++*this; |
168 | return tmp; |
169 | } |
170 | |
171 | /// Get the underlying ilist_node. |
172 | node_pointer getNodePtr() const { return static_cast<node_pointer>(NodePtr); } |
173 | |
174 | /// Check for end. Only valid if ilist_sentinel_tracking<true>. |
175 | bool isEnd() const { return NodePtr ? NodePtr->isSentinel() : false; } |
176 | }; |
177 | |
178 | template <typename From> struct simplify_type; |
179 | |
180 | /// Allow ilist_iterators to convert into pointers to a node automatically when |
181 | /// used by the dyn_cast, cast, isa mechanisms... |
182 | /// |
183 | /// FIXME: remove this, since there is no implicit conversion to NodeTy. |
184 | template <class OptionsT, bool IsConst> |
185 | struct simplify_type<ilist_iterator<OptionsT, false, IsConst>> { |
186 | using iterator = ilist_iterator<OptionsT, false, IsConst>; |
187 | using SimpleType = typename iterator::pointer; |
188 | |
189 | static SimpleType getSimplifiedValue(const iterator &Node) { return &*Node; } |
190 | }; |
191 | template <class OptionsT, bool IsConst> |
192 | struct simplify_type<const ilist_iterator<OptionsT, false, IsConst>> |
193 | : simplify_type<ilist_iterator<OptionsT, false, IsConst>> {}; |
194 | |
195 | } // end namespace llvm |
196 | |
197 | #endif // LLVM_ADT_ILIST_ITERATOR_H |
1 | //===- llvm/CodeGen/MachineInstrBundleIterator.h ----------------*- 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 | // Defines an iterator class that bundles MachineInstr. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #ifndef LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H |
14 | #define LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H |
15 | |
16 | #include "llvm/ADT/ilist.h" |
17 | #include "llvm/ADT/simple_ilist.h" |
18 | #include <cassert> |
19 | #include <iterator> |
20 | #include <type_traits> |
21 | |
22 | namespace llvm { |
23 | |
24 | template <class T, bool IsReverse> struct MachineInstrBundleIteratorTraits; |
25 | template <class T> struct MachineInstrBundleIteratorTraits<T, false> { |
26 | using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>; |
27 | using instr_iterator = typename list_type::iterator; |
28 | using nonconst_instr_iterator = typename list_type::iterator; |
29 | using const_instr_iterator = typename list_type::const_iterator; |
30 | }; |
31 | template <class T> struct MachineInstrBundleIteratorTraits<T, true> { |
32 | using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>; |
33 | using instr_iterator = typename list_type::reverse_iterator; |
34 | using nonconst_instr_iterator = typename list_type::reverse_iterator; |
35 | using const_instr_iterator = typename list_type::const_reverse_iterator; |
36 | }; |
37 | template <class T> struct MachineInstrBundleIteratorTraits<const T, false> { |
38 | using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>; |
39 | using instr_iterator = typename list_type::const_iterator; |
40 | using nonconst_instr_iterator = typename list_type::iterator; |
41 | using const_instr_iterator = typename list_type::const_iterator; |
42 | }; |
43 | template <class T> struct MachineInstrBundleIteratorTraits<const T, true> { |
44 | using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>; |
45 | using instr_iterator = typename list_type::const_reverse_iterator; |
46 | using nonconst_instr_iterator = typename list_type::reverse_iterator; |
47 | using const_instr_iterator = typename list_type::const_reverse_iterator; |
48 | }; |
49 | |
50 | template <bool IsReverse> struct MachineInstrBundleIteratorHelper; |
51 | template <> struct MachineInstrBundleIteratorHelper<false> { |
52 | /// Get the beginning of the current bundle. |
53 | template <class Iterator> static Iterator getBundleBegin(Iterator I) { |
54 | if (!I.isEnd()) |
55 | while (I->isBundledWithPred()) |
56 | --I; |
57 | return I; |
58 | } |
59 | |
60 | /// Get the final node of the current bundle. |
61 | template <class Iterator> static Iterator getBundleFinal(Iterator I) { |
62 | if (!I.isEnd()) |
63 | while (I->isBundledWithSucc()) |
64 | ++I; |
65 | return I; |
66 | } |
67 | |
68 | /// Increment forward ilist iterator. |
69 | template <class Iterator> static void increment(Iterator &I) { |
70 | I = std::next(getBundleFinal(I)); |
71 | } |
72 | |
73 | /// Decrement forward ilist iterator. |
74 | template <class Iterator> static void decrement(Iterator &I) { |
75 | I = getBundleBegin(std::prev(I)); |
76 | } |
77 | }; |
78 | |
79 | template <> struct MachineInstrBundleIteratorHelper<true> { |
80 | /// Get the beginning of the current bundle. |
81 | template <class Iterator> static Iterator getBundleBegin(Iterator I) { |
82 | return MachineInstrBundleIteratorHelper<false>::getBundleBegin( |
83 | I.getReverse()) |
84 | .getReverse(); |
85 | } |
86 | |
87 | /// Get the final node of the current bundle. |
88 | template <class Iterator> static Iterator getBundleFinal(Iterator I) { |
89 | return MachineInstrBundleIteratorHelper<false>::getBundleFinal( |
90 | I.getReverse()) |
91 | .getReverse(); |
92 | } |
93 | |
94 | /// Increment reverse ilist iterator. |
95 | template <class Iterator> static void increment(Iterator &I) { |
96 | I = getBundleBegin(std::next(I)); |
97 | } |
98 | |
99 | /// Decrement reverse ilist iterator. |
100 | template <class Iterator> static void decrement(Iterator &I) { |
101 | I = std::prev(getBundleFinal(I)); |
102 | } |
103 | }; |
104 | |
105 | /// MachineBasicBlock iterator that automatically skips over MIs that are |
106 | /// inside bundles (i.e. walk top level MIs only). |
107 | template <typename Ty, bool IsReverse = false> |
108 | class MachineInstrBundleIterator : MachineInstrBundleIteratorHelper<IsReverse> { |
109 | using Traits = MachineInstrBundleIteratorTraits<Ty, IsReverse>; |
110 | using instr_iterator = typename Traits::instr_iterator; |
111 | |
112 | instr_iterator MII; |
113 | |
114 | public: |
115 | using value_type = typename instr_iterator::value_type; |
116 | using difference_type = typename instr_iterator::difference_type; |
117 | using pointer = typename instr_iterator::pointer; |
118 | using reference = typename instr_iterator::reference; |
119 | using const_pointer = typename instr_iterator::const_pointer; |
120 | using const_reference = typename instr_iterator::const_reference; |
121 | using iterator_category = std::bidirectional_iterator_tag; |
122 | |
123 | private: |
124 | using nonconst_instr_iterator = typename Traits::nonconst_instr_iterator; |
125 | using const_instr_iterator = typename Traits::const_instr_iterator; |
126 | using nonconst_iterator = |
127 | MachineInstrBundleIterator<typename nonconst_instr_iterator::value_type, |
128 | IsReverse>; |
129 | using reverse_iterator = MachineInstrBundleIterator<Ty, !IsReverse>; |
130 | |
131 | public: |
132 | MachineInstrBundleIterator(instr_iterator MI) : MII(MI) { |
133 | assert((!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred()) &&(((!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred ()) && "It's not legal to initialize MachineInstrBundleIterator with a " "bundled MI") ? static_cast<void> (0) : __assert_fail ( "(!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred()) && \"It's not legal to initialize MachineInstrBundleIterator with a \" \"bundled MI\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h" , 135, __PRETTY_FUNCTION__)) |
134 | "It's not legal to initialize MachineInstrBundleIterator with a "(((!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred ()) && "It's not legal to initialize MachineInstrBundleIterator with a " "bundled MI") ? static_cast<void> (0) : __assert_fail ( "(!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred()) && \"It's not legal to initialize MachineInstrBundleIterator with a \" \"bundled MI\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h" , 135, __PRETTY_FUNCTION__)) |
135 | "bundled MI")(((!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred ()) && "It's not legal to initialize MachineInstrBundleIterator with a " "bundled MI") ? static_cast<void> (0) : __assert_fail ( "(!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred()) && \"It's not legal to initialize MachineInstrBundleIterator with a \" \"bundled MI\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h" , 135, __PRETTY_FUNCTION__)); |
136 | } |
137 | |
138 | MachineInstrBundleIterator(reference MI) : MII(MI) { |
139 | assert(!MI.isBundledWithPred() && "It's not legal to initialize "((!MI.isBundledWithPred() && "It's not legal to initialize " "MachineInstrBundleIterator with a " "bundled MI") ? static_cast <void> (0) : __assert_fail ("!MI.isBundledWithPred() && \"It's not legal to initialize \" \"MachineInstrBundleIterator with a \" \"bundled MI\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h" , 141, __PRETTY_FUNCTION__)) |
140 | "MachineInstrBundleIterator with a "((!MI.isBundledWithPred() && "It's not legal to initialize " "MachineInstrBundleIterator with a " "bundled MI") ? static_cast <void> (0) : __assert_fail ("!MI.isBundledWithPred() && \"It's not legal to initialize \" \"MachineInstrBundleIterator with a \" \"bundled MI\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h" , 141, __PRETTY_FUNCTION__)) |
141 | "bundled MI")((!MI.isBundledWithPred() && "It's not legal to initialize " "MachineInstrBundleIterator with a " "bundled MI") ? static_cast <void> (0) : __assert_fail ("!MI.isBundledWithPred() && \"It's not legal to initialize \" \"MachineInstrBundleIterator with a \" \"bundled MI\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h" , 141, __PRETTY_FUNCTION__)); |
142 | } |
143 | |
144 | MachineInstrBundleIterator(pointer MI) : MII(MI) { |
145 | // FIXME: This conversion should be explicit. |
146 | assert((!MI || !MI->isBundledWithPred()) && "It's not legal to initialize "(((!MI || !MI->isBundledWithPred()) && "It's not legal to initialize " "MachineInstrBundleIterator " "with a bundled MI") ? static_cast <void> (0) : __assert_fail ("(!MI || !MI->isBundledWithPred()) && \"It's not legal to initialize \" \"MachineInstrBundleIterator \" \"with a bundled MI\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h" , 148, __PRETTY_FUNCTION__)) |
147 | "MachineInstrBundleIterator "(((!MI || !MI->isBundledWithPred()) && "It's not legal to initialize " "MachineInstrBundleIterator " "with a bundled MI") ? static_cast <void> (0) : __assert_fail ("(!MI || !MI->isBundledWithPred()) && \"It's not legal to initialize \" \"MachineInstrBundleIterator \" \"with a bundled MI\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h" , 148, __PRETTY_FUNCTION__)) |
148 | "with a bundled MI")(((!MI || !MI->isBundledWithPred()) && "It's not legal to initialize " "MachineInstrBundleIterator " "with a bundled MI") ? static_cast <void> (0) : __assert_fail ("(!MI || !MI->isBundledWithPred()) && \"It's not legal to initialize \" \"MachineInstrBundleIterator \" \"with a bundled MI\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h" , 148, __PRETTY_FUNCTION__)); |
149 | } |
150 | |
151 | // Template allows conversion from const to nonconst. |
152 | template <class OtherTy> |
153 | MachineInstrBundleIterator( |
154 | const MachineInstrBundleIterator<OtherTy, IsReverse> &I, |
155 | std::enable_if_t<std::is_convertible<OtherTy *, Ty *>::value, void *> = |
156 | nullptr) |
157 | : MII(I.getInstrIterator()) {} |
158 | |
159 | MachineInstrBundleIterator() : MII(nullptr) {} |
160 | |
161 | /// Explicit conversion between forward/reverse iterators. |
162 | /// |
163 | /// Translate between forward and reverse iterators without changing range |
164 | /// boundaries. The resulting iterator will dereference (and have a handle) |
165 | /// to the previous node, which is somewhat unexpected; but converting the |
166 | /// two endpoints in a range will give the same range in reverse. |
167 | /// |
168 | /// This matches std::reverse_iterator conversions. |
169 | explicit MachineInstrBundleIterator( |
170 | const MachineInstrBundleIterator<Ty, !IsReverse> &I) |
171 | : MachineInstrBundleIterator(++I.getReverse()) {} |
172 | |
173 | /// Get the bundle iterator for the given instruction's bundle. |
174 | static MachineInstrBundleIterator getAtBundleBegin(instr_iterator MI) { |
175 | return MachineInstrBundleIteratorHelper<IsReverse>::getBundleBegin(MI); |
176 | } |
177 | |
178 | reference operator*() const { return *MII; } |
179 | pointer operator->() const { return &operator*(); } |
180 | |
181 | /// Check for null. |
182 | bool isValid() const { return MII.getNodePtr(); } |
183 | |
184 | friend bool operator==(const MachineInstrBundleIterator &L, |
185 | const MachineInstrBundleIterator &R) { |
186 | return L.MII == R.MII; |
187 | } |
188 | friend bool operator==(const MachineInstrBundleIterator &L, |
189 | const const_instr_iterator &R) { |
190 | return L.MII == R; // Avoid assertion about validity of R. |
191 | } |
192 | friend bool operator==(const const_instr_iterator &L, |
193 | const MachineInstrBundleIterator &R) { |
194 | return L == R.MII; // Avoid assertion about validity of L. |
195 | } |
196 | friend bool operator==(const MachineInstrBundleIterator &L, |
197 | const nonconst_instr_iterator &R) { |
198 | return L.MII == R; // Avoid assertion about validity of R. |
199 | } |
200 | friend bool operator==(const nonconst_instr_iterator &L, |
201 | const MachineInstrBundleIterator &R) { |
202 | return L == R.MII; // Avoid assertion about validity of L. |
203 | } |
204 | friend bool operator==(const MachineInstrBundleIterator &L, const_pointer R) { |
205 | return L == const_instr_iterator(R); // Avoid assertion about validity of R. |
206 | } |
207 | friend bool operator==(const_pointer L, const MachineInstrBundleIterator &R) { |
208 | return const_instr_iterator(L) == R; // Avoid assertion about validity of L. |
209 | } |
210 | friend bool operator==(const MachineInstrBundleIterator &L, |
211 | const_reference R) { |
212 | return L == &R; // Avoid assertion about validity of R. |
213 | } |
214 | friend bool operator==(const_reference L, |
215 | const MachineInstrBundleIterator &R) { |
216 | return &L == R; // Avoid assertion about validity of L. |
217 | } |
218 | |
219 | friend bool operator!=(const MachineInstrBundleIterator &L, |
220 | const MachineInstrBundleIterator &R) { |
221 | return !(L == R); |
222 | } |
223 | friend bool operator!=(const MachineInstrBundleIterator &L, |
224 | const const_instr_iterator &R) { |
225 | return !(L == R); |
226 | } |
227 | friend bool operator!=(const const_instr_iterator &L, |
228 | const MachineInstrBundleIterator &R) { |
229 | return !(L == R); |
230 | } |
231 | friend bool operator!=(const MachineInstrBundleIterator &L, |
232 | const nonconst_instr_iterator &R) { |
233 | return !(L == R); |
234 | } |
235 | friend bool operator!=(const nonconst_instr_iterator &L, |
236 | const MachineInstrBundleIterator &R) { |
237 | return !(L == R); |
238 | } |
239 | friend bool operator!=(const MachineInstrBundleIterator &L, const_pointer R) { |
240 | return !(L == R); |
241 | } |
242 | friend bool operator!=(const_pointer L, const MachineInstrBundleIterator &R) { |
243 | return !(L == R); |
244 | } |
245 | friend bool operator!=(const MachineInstrBundleIterator &L, |
246 | const_reference R) { |
247 | return !(L == R); |
248 | } |
249 | friend bool operator!=(const_reference L, |
250 | const MachineInstrBundleIterator &R) { |
251 | return !(L == R); |
252 | } |
253 | |
254 | // Increment and decrement operators... |
255 | MachineInstrBundleIterator &operator--() { |
256 | this->decrement(MII); |
257 | return *this; |
258 | } |
259 | MachineInstrBundleIterator &operator++() { |
260 | this->increment(MII); |
261 | return *this; |
262 | } |
263 | MachineInstrBundleIterator operator--(int) { |
264 | MachineInstrBundleIterator Temp = *this; |
265 | --*this; |
266 | return Temp; |
267 | } |
268 | MachineInstrBundleIterator operator++(int) { |
269 | MachineInstrBundleIterator Temp = *this; |
270 | ++*this; |
271 | return Temp; |
272 | } |
273 | |
274 | instr_iterator getInstrIterator() const { return MII; } |
275 | |
276 | nonconst_iterator getNonConstIterator() const { return MII.getNonConst(); } |
277 | |
278 | /// Get a reverse iterator to the same node. |
279 | /// |
280 | /// Gives a reverse iterator that will dereference (and have a handle) to the |
281 | /// same node. Converting the endpoint iterators in a range will give a |
282 | /// different range; for range operations, use the explicit conversions. |
283 | reverse_iterator getReverse() const { return MII.getReverse(); } |
284 | }; |
285 | |
286 | } // end namespace llvm |
287 | |
288 | #endif // LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H |
1 | //===- llvm/CodeGen/MachineInstr.h - MachineInstr class ---------*- 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 | // This file contains the declaration of the MachineInstr class, which is the | ||||||||
10 | // basic representation for all target dependent machine instructions used by | ||||||||
11 | // the back end. | ||||||||
12 | // | ||||||||
13 | //===----------------------------------------------------------------------===// | ||||||||
14 | |||||||||
15 | #ifndef LLVM_CODEGEN_MACHINEINSTR_H | ||||||||
16 | #define LLVM_CODEGEN_MACHINEINSTR_H | ||||||||
17 | |||||||||
18 | #include "llvm/ADT/DenseMapInfo.h" | ||||||||
19 | #include "llvm/ADT/PointerSumType.h" | ||||||||
20 | #include "llvm/ADT/ilist.h" | ||||||||
21 | #include "llvm/ADT/ilist_node.h" | ||||||||
22 | #include "llvm/ADT/iterator_range.h" | ||||||||
23 | #include "llvm/CodeGen/MachineMemOperand.h" | ||||||||
24 | #include "llvm/CodeGen/MachineOperand.h" | ||||||||
25 | #include "llvm/CodeGen/TargetOpcodes.h" | ||||||||
26 | #include "llvm/IR/DebugLoc.h" | ||||||||
27 | #include "llvm/IR/InlineAsm.h" | ||||||||
28 | #include "llvm/MC/MCInstrDesc.h" | ||||||||
29 | #include "llvm/MC/MCSymbol.h" | ||||||||
30 | #include "llvm/Support/ArrayRecycler.h" | ||||||||
31 | #include "llvm/Support/TrailingObjects.h" | ||||||||
32 | #include <algorithm> | ||||||||
33 | #include <cassert> | ||||||||
34 | #include <cstdint> | ||||||||
35 | #include <utility> | ||||||||
36 | |||||||||
37 | namespace llvm { | ||||||||
38 | |||||||||
39 | class AAResults; | ||||||||
40 | template <typename T> class ArrayRef; | ||||||||
41 | class DIExpression; | ||||||||
42 | class DILocalVariable; | ||||||||
43 | class MachineBasicBlock; | ||||||||
44 | class MachineFunction; | ||||||||
45 | class MachineRegisterInfo; | ||||||||
46 | class ModuleSlotTracker; | ||||||||
47 | class raw_ostream; | ||||||||
48 | template <typename T> class SmallVectorImpl; | ||||||||
49 | class SmallBitVector; | ||||||||
50 | class StringRef; | ||||||||
51 | class TargetInstrInfo; | ||||||||
52 | class TargetRegisterClass; | ||||||||
53 | class TargetRegisterInfo; | ||||||||
54 | |||||||||
55 | //===----------------------------------------------------------------------===// | ||||||||
56 | /// Representation of each machine instruction. | ||||||||
57 | /// | ||||||||
58 | /// This class isn't a POD type, but it must have a trivial destructor. When a | ||||||||
59 | /// MachineFunction is deleted, all the contained MachineInstrs are deallocated | ||||||||
60 | /// without having their destructor called. | ||||||||
61 | /// | ||||||||
62 | class MachineInstr | ||||||||
63 | : public ilist_node_with_parent<MachineInstr, MachineBasicBlock, | ||||||||
64 | ilist_sentinel_tracking<true>> { | ||||||||
65 | public: | ||||||||
66 | using mmo_iterator = ArrayRef<MachineMemOperand *>::iterator; | ||||||||
67 | |||||||||
68 | /// Flags to specify different kinds of comments to output in | ||||||||
69 | /// assembly code. These flags carry semantic information not | ||||||||
70 | /// otherwise easily derivable from the IR text. | ||||||||
71 | /// | ||||||||
72 | enum CommentFlag { | ||||||||
73 | ReloadReuse = 0x1, // higher bits are reserved for target dep comments. | ||||||||
74 | NoSchedComment = 0x2, | ||||||||
75 | TAsmComments = 0x4 // Target Asm comments should start from this value. | ||||||||
76 | }; | ||||||||
77 | |||||||||
78 | enum MIFlag { | ||||||||
79 | NoFlags = 0, | ||||||||
80 | FrameSetup = 1 << 0, // Instruction is used as a part of | ||||||||
81 | // function frame setup code. | ||||||||
82 | FrameDestroy = 1 << 1, // Instruction is used as a part of | ||||||||
83 | // function frame destruction code. | ||||||||
84 | BundledPred = 1 << 2, // Instruction has bundled predecessors. | ||||||||
85 | BundledSucc = 1 << 3, // Instruction has bundled successors. | ||||||||
86 | FmNoNans = 1 << 4, // Instruction does not support Fast | ||||||||
87 | // math nan values. | ||||||||
88 | FmNoInfs = 1 << 5, // Instruction does not support Fast | ||||||||
89 | // math infinity values. | ||||||||
90 | FmNsz = 1 << 6, // Instruction is not required to retain | ||||||||
91 | // signed zero values. | ||||||||
92 | FmArcp = 1 << 7, // Instruction supports Fast math | ||||||||
93 | // reciprocal approximations. | ||||||||
94 | FmContract = 1 << 8, // Instruction supports Fast math | ||||||||
95 | // contraction operations like fma. | ||||||||
96 | FmAfn = 1 << 9, // Instruction may map to Fast math | ||||||||
97 | // instrinsic approximation. | ||||||||
98 | FmReassoc = 1 << 10, // Instruction supports Fast math | ||||||||
99 | // reassociation of operand order. | ||||||||
100 | NoUWrap = 1 << 11, // Instruction supports binary operator | ||||||||
101 | // no unsigned wrap. | ||||||||
102 | NoSWrap = 1 << 12, // Instruction supports binary operator | ||||||||
103 | // no signed wrap. | ||||||||
104 | IsExact = 1 << 13, // Instruction supports division is | ||||||||
105 | // known to be exact. | ||||||||
106 | NoFPExcept = 1 << 14, // Instruction does not raise | ||||||||
107 | // floatint-point exceptions. | ||||||||
108 | NoMerge = 1 << 15, // Passes that drop source location info | ||||||||
109 | // (e.g. branch folding) should skip | ||||||||
110 | // this instruction. | ||||||||
111 | }; | ||||||||
112 | |||||||||
113 | private: | ||||||||
114 | const MCInstrDesc *MCID; // Instruction descriptor. | ||||||||
115 | MachineBasicBlock *Parent = nullptr; // Pointer to the owning basic block. | ||||||||
116 | |||||||||
117 | // Operands are allocated by an ArrayRecycler. | ||||||||
118 | MachineOperand *Operands = nullptr; // Pointer to the first operand. | ||||||||
119 | unsigned NumOperands = 0; // Number of operands on instruction. | ||||||||
120 | |||||||||
121 | uint16_t Flags = 0; // Various bits of additional | ||||||||
122 | // information about machine | ||||||||
123 | // instruction. | ||||||||
124 | |||||||||
125 | uint8_t AsmPrinterFlags = 0; // Various bits of information used by | ||||||||
126 | // the AsmPrinter to emit helpful | ||||||||
127 | // comments. This is *not* semantic | ||||||||
128 | // information. Do not use this for | ||||||||
129 | // anything other than to convey comment | ||||||||
130 | // information to AsmPrinter. | ||||||||
131 | |||||||||
132 | // OperandCapacity has uint8_t size, so it should be next to AsmPrinterFlags | ||||||||
133 | // to properly pack. | ||||||||
134 | using OperandCapacity = ArrayRecycler<MachineOperand>::Capacity; | ||||||||
135 | OperandCapacity CapOperands; // Capacity of the Operands array. | ||||||||
136 | |||||||||
137 | /// Internal implementation detail class that provides out-of-line storage for | ||||||||
138 | /// extra info used by the machine instruction when this info cannot be stored | ||||||||
139 | /// in-line within the instruction itself. | ||||||||
140 | /// | ||||||||
141 | /// This has to be defined eagerly due to the implementation constraints of | ||||||||
142 | /// `PointerSumType` where it is used. | ||||||||
143 | class ExtraInfo final | ||||||||
144 | : TrailingObjects<ExtraInfo, MachineMemOperand *, MCSymbol *, MDNode *> { | ||||||||
145 | public: | ||||||||
146 | static ExtraInfo *create(BumpPtrAllocator &Allocator, | ||||||||
147 | ArrayRef<MachineMemOperand *> MMOs, | ||||||||
148 | MCSymbol *PreInstrSymbol = nullptr, | ||||||||
149 | MCSymbol *PostInstrSymbol = nullptr, | ||||||||
150 | MDNode *HeapAllocMarker = nullptr) { | ||||||||
151 | bool HasPreInstrSymbol = PreInstrSymbol != nullptr; | ||||||||
152 | bool HasPostInstrSymbol = PostInstrSymbol != nullptr; | ||||||||
153 | bool HasHeapAllocMarker = HeapAllocMarker != nullptr; | ||||||||
154 | auto *Result = new (Allocator.Allocate( | ||||||||
155 | totalSizeToAlloc<MachineMemOperand *, MCSymbol *, MDNode *>( | ||||||||
156 | MMOs.size(), HasPreInstrSymbol + HasPostInstrSymbol, | ||||||||
157 | HasHeapAllocMarker), | ||||||||
158 | alignof(ExtraInfo))) | ||||||||
159 | ExtraInfo(MMOs.size(), HasPreInstrSymbol, HasPostInstrSymbol, | ||||||||
160 | HasHeapAllocMarker); | ||||||||
161 | |||||||||
162 | // Copy the actual data into the trailing objects. | ||||||||
163 | std::copy(MMOs.begin(), MMOs.end(), | ||||||||
164 | Result->getTrailingObjects<MachineMemOperand *>()); | ||||||||
165 | |||||||||
166 | if (HasPreInstrSymbol) | ||||||||
167 | Result->getTrailingObjects<MCSymbol *>()[0] = PreInstrSymbol; | ||||||||
168 | if (HasPostInstrSymbol) | ||||||||
169 | Result->getTrailingObjects<MCSymbol *>()[HasPreInstrSymbol] = | ||||||||
170 | PostInstrSymbol; | ||||||||
171 | if (HasHeapAllocMarker) | ||||||||
172 | Result->getTrailingObjects<MDNode *>()[0] = HeapAllocMarker; | ||||||||
173 | |||||||||
174 | return Result; | ||||||||
175 | } | ||||||||
176 | |||||||||
177 | ArrayRef<MachineMemOperand *> getMMOs() const { | ||||||||
178 | return makeArrayRef(getTrailingObjects<MachineMemOperand *>(), NumMMOs); | ||||||||
179 | } | ||||||||
180 | |||||||||
181 | MCSymbol *getPreInstrSymbol() const { | ||||||||
182 | return HasPreInstrSymbol ? getTrailingObjects<MCSymbol *>()[0] : nullptr; | ||||||||
183 | } | ||||||||
184 | |||||||||
185 | MCSymbol *getPostInstrSymbol() const { | ||||||||
186 | return HasPostInstrSymbol | ||||||||
187 | ? getTrailingObjects<MCSymbol *>()[HasPreInstrSymbol] | ||||||||
188 | : nullptr; | ||||||||
189 | } | ||||||||
190 | |||||||||
191 | MDNode *getHeapAllocMarker() const { | ||||||||
192 | return HasHeapAllocMarker ? getTrailingObjects<MDNode *>()[0] : nullptr; | ||||||||
193 | } | ||||||||
194 | |||||||||
195 | private: | ||||||||
196 | friend TrailingObjects; | ||||||||
197 | |||||||||
198 | // Description of the extra info, used to interpret the actual optional | ||||||||
199 | // data appended. | ||||||||
200 | // | ||||||||
201 | // Note that this is not terribly space optimized. This leaves a great deal | ||||||||
202 | // of flexibility to fit more in here later. | ||||||||
203 | const int NumMMOs; | ||||||||
204 | const bool HasPreInstrSymbol; | ||||||||
205 | const bool HasPostInstrSymbol; | ||||||||
206 | const bool HasHeapAllocMarker; | ||||||||
207 | |||||||||
208 | // Implement the `TrailingObjects` internal API. | ||||||||
209 | size_t numTrailingObjects(OverloadToken<MachineMemOperand *>) const { | ||||||||
210 | return NumMMOs; | ||||||||
211 | } | ||||||||
212 | size_t numTrailingObjects(OverloadToken<MCSymbol *>) const { | ||||||||
213 | return HasPreInstrSymbol + HasPostInstrSymbol; | ||||||||
214 | } | ||||||||
215 | size_t numTrailingObjects(OverloadToken<MDNode *>) const { | ||||||||
216 | return HasHeapAllocMarker; | ||||||||
217 | } | ||||||||
218 | |||||||||
219 | // Just a boring constructor to allow us to initialize the sizes. Always use | ||||||||
220 | // the `create` routine above. | ||||||||
221 | ExtraInfo(int NumMMOs, bool HasPreInstrSymbol, bool HasPostInstrSymbol, | ||||||||
222 | bool HasHeapAllocMarker) | ||||||||
223 | : NumMMOs(NumMMOs), HasPreInstrSymbol(HasPreInstrSymbol), | ||||||||
224 | HasPostInstrSymbol(HasPostInstrSymbol), | ||||||||
225 | HasHeapAllocMarker(HasHeapAllocMarker) {} | ||||||||
226 | }; | ||||||||
227 | |||||||||
228 | /// Enumeration of the kinds of inline extra info available. It is important | ||||||||
229 | /// that the `MachineMemOperand` inline kind has a tag value of zero to make | ||||||||
230 | /// it accessible as an `ArrayRef`. | ||||||||
231 | enum ExtraInfoInlineKinds { | ||||||||
232 | EIIK_MMO = 0, | ||||||||
233 | EIIK_PreInstrSymbol, | ||||||||
234 | EIIK_PostInstrSymbol, | ||||||||
235 | EIIK_OutOfLine | ||||||||
236 | }; | ||||||||
237 | |||||||||
238 | // We store extra information about the instruction here. The common case is | ||||||||
239 | // expected to be nothing or a single pointer (typically a MMO or a symbol). | ||||||||
240 | // We work to optimize this common case by storing it inline here rather than | ||||||||
241 | // requiring a separate allocation, but we fall back to an allocation when | ||||||||
242 | // multiple pointers are needed. | ||||||||
243 | PointerSumType<ExtraInfoInlineKinds, | ||||||||
244 | PointerSumTypeMember<EIIK_MMO, MachineMemOperand *>, | ||||||||
245 | PointerSumTypeMember<EIIK_PreInstrSymbol, MCSymbol *>, | ||||||||
246 | PointerSumTypeMember<EIIK_PostInstrSymbol, MCSymbol *>, | ||||||||
247 | PointerSumTypeMember<EIIK_OutOfLine, ExtraInfo *>> | ||||||||
248 | Info; | ||||||||
249 | |||||||||
250 | DebugLoc debugLoc; // Source line information. | ||||||||
251 | |||||||||
252 | /// Unique instruction number. Used by DBG_INSTR_REFs to refer to the values | ||||||||
253 | /// defined by this instruction. | ||||||||
254 | unsigned DebugInstrNum; | ||||||||
255 | |||||||||
256 | // Intrusive list support | ||||||||
257 | friend struct ilist_traits<MachineInstr>; | ||||||||
258 | friend struct ilist_callback_traits<MachineBasicBlock>; | ||||||||
259 | void setParent(MachineBasicBlock *P) { Parent = P; } | ||||||||
260 | |||||||||
261 | /// This constructor creates a copy of the given | ||||||||
262 | /// MachineInstr in the given MachineFunction. | ||||||||
263 | MachineInstr(MachineFunction &, const MachineInstr &); | ||||||||
264 | |||||||||
265 | /// This constructor create a MachineInstr and add the implicit operands. | ||||||||
266 | /// It reserves space for number of operands specified by | ||||||||
267 | /// MCInstrDesc. An explicit DebugLoc is supplied. | ||||||||
268 | MachineInstr(MachineFunction &, const MCInstrDesc &tid, DebugLoc dl, | ||||||||
269 | bool NoImp = false); | ||||||||
270 | |||||||||
271 | // MachineInstrs are pool-allocated and owned by MachineFunction. | ||||||||
272 | friend class MachineFunction; | ||||||||
273 | |||||||||
274 | void | ||||||||
275 | dumprImpl(const MachineRegisterInfo &MRI, unsigned Depth, unsigned MaxDepth, | ||||||||
276 | SmallPtrSetImpl<const MachineInstr *> &AlreadySeenInstrs) const; | ||||||||
277 | |||||||||
278 | public: | ||||||||
279 | MachineInstr(const MachineInstr &) = delete; | ||||||||
280 | MachineInstr &operator=(const MachineInstr &) = delete; | ||||||||
281 | // Use MachineFunction::DeleteMachineInstr() instead. | ||||||||
282 | ~MachineInstr() = delete; | ||||||||
283 | |||||||||
284 | const MachineBasicBlock* getParent() const { return Parent; } | ||||||||
285 | MachineBasicBlock* getParent() { return Parent; } | ||||||||
286 | |||||||||
287 | /// Move the instruction before \p MovePos. | ||||||||
288 | void moveBefore(MachineInstr *MovePos); | ||||||||
289 | |||||||||
290 | /// Return the function that contains the basic block that this instruction | ||||||||
291 | /// belongs to. | ||||||||
292 | /// | ||||||||
293 | /// Note: this is undefined behaviour if the instruction does not have a | ||||||||
294 | /// parent. | ||||||||
295 | const MachineFunction *getMF() const; | ||||||||
296 | MachineFunction *getMF() { | ||||||||
297 | return const_cast<MachineFunction *>( | ||||||||
298 | static_cast<const MachineInstr *>(this)->getMF()); | ||||||||
299 | } | ||||||||
300 | |||||||||
301 | /// Return the asm printer flags bitvector. | ||||||||
302 | uint8_t getAsmPrinterFlags() const { return AsmPrinterFlags; } | ||||||||
303 | |||||||||
304 | /// Clear the AsmPrinter bitvector. | ||||||||
305 | void clearAsmPrinterFlags() { AsmPrinterFlags = 0; } | ||||||||
306 | |||||||||
307 | /// Return whether an AsmPrinter flag is set. | ||||||||
308 | bool getAsmPrinterFlag(CommentFlag Flag) const { | ||||||||
309 | return AsmPrinterFlags & Flag; | ||||||||
310 | } | ||||||||
311 | |||||||||
312 | /// Set a flag for the AsmPrinter. | ||||||||
313 | void setAsmPrinterFlag(uint8_t Flag) { | ||||||||
314 | AsmPrinterFlags |= Flag; | ||||||||
315 | } | ||||||||
316 | |||||||||
317 | /// Clear specific AsmPrinter flags. | ||||||||
318 | void clearAsmPrinterFlag(CommentFlag Flag) { | ||||||||
319 | AsmPrinterFlags &= ~Flag; | ||||||||
320 | } | ||||||||
321 | |||||||||
322 | /// Return the MI flags bitvector. | ||||||||
323 | uint16_t getFlags() const { | ||||||||
324 | return Flags; | ||||||||
325 | } | ||||||||
326 | |||||||||
327 | /// Return whether an MI flag is set. | ||||||||
328 | bool getFlag(MIFlag Flag) const { | ||||||||
329 | return Flags & Flag; | ||||||||
330 | } | ||||||||
331 | |||||||||
332 | /// Set a MI flag. | ||||||||
333 | void setFlag(MIFlag Flag) { | ||||||||
334 | Flags |= (uint16_t)Flag; | ||||||||
335 | } | ||||||||
336 | |||||||||
337 | void setFlags(unsigned flags) { | ||||||||
338 | // Filter out the automatically maintained flags. | ||||||||
339 | unsigned Mask = BundledPred | BundledSucc; | ||||||||
340 | Flags = (Flags & Mask) | (flags & ~Mask); | ||||||||
341 | } | ||||||||
342 | |||||||||
343 | /// clearFlag - Clear a MI flag. | ||||||||
344 | void clearFlag(MIFlag Flag) { | ||||||||
345 | Flags &= ~((uint16_t)Flag); | ||||||||
346 | } | ||||||||
347 | |||||||||
348 | /// Return true if MI is in a bundle (but not the first MI in a bundle). | ||||||||
349 | /// | ||||||||
350 | /// A bundle looks like this before it's finalized: | ||||||||
351 | /// ---------------- | ||||||||
352 | /// | MI | | ||||||||
353 | /// ---------------- | ||||||||
354 | /// | | ||||||||
355 | /// ---------------- | ||||||||
356 | /// | MI * | | ||||||||
357 | /// ---------------- | ||||||||
358 | /// | | ||||||||
359 | /// ---------------- | ||||||||
360 | /// | MI * | | ||||||||
361 | /// ---------------- | ||||||||
362 | /// In this case, the first MI starts a bundle but is not inside a bundle, the | ||||||||
363 | /// next 2 MIs are considered "inside" the bundle. | ||||||||
364 | /// | ||||||||
365 | /// After a bundle is finalized, it looks like this: | ||||||||
366 | /// ---------------- | ||||||||
367 | /// | Bundle | | ||||||||
368 | /// ---------------- | ||||||||
369 | /// | | ||||||||
370 | /// ---------------- | ||||||||
371 | /// | MI * | | ||||||||
372 | /// ---------------- | ||||||||
373 | /// | | ||||||||
374 | /// ---------------- | ||||||||
375 | /// | MI * | | ||||||||
376 | /// ---------------- | ||||||||
377 | /// | | ||||||||
378 | /// ---------------- | ||||||||
379 | /// | MI * | | ||||||||
380 | /// ---------------- | ||||||||
381 | /// The first instruction has the special opcode "BUNDLE". It's not "inside" | ||||||||
382 | /// a bundle, but the next three MIs are. | ||||||||
383 | bool isInsideBundle() const { | ||||||||
384 | return getFlag(BundledPred); | ||||||||
385 | } | ||||||||
386 | |||||||||
387 | /// Return true if this instruction part of a bundle. This is true | ||||||||
388 | /// if either itself or its following instruction is marked "InsideBundle". | ||||||||
389 | bool isBundled() const { | ||||||||
390 | return isBundledWithPred() || isBundledWithSucc(); | ||||||||
391 | } | ||||||||
392 | |||||||||
393 | /// Return true if this instruction is part of a bundle, and it is not the | ||||||||
394 | /// first instruction in the bundle. | ||||||||
395 | bool isBundledWithPred() const { return getFlag(BundledPred); } | ||||||||
396 | |||||||||
397 | /// Return true if this instruction is part of a bundle, and it is not the | ||||||||
398 | /// last instruction in the bundle. | ||||||||
399 | bool isBundledWithSucc() const { return getFlag(BundledSucc); } | ||||||||
400 | |||||||||
401 | /// Bundle this instruction with its predecessor. This can be an unbundled | ||||||||
402 | /// instruction, or it can be the first instruction in a bundle. | ||||||||
403 | void bundleWithPred(); | ||||||||
404 | |||||||||
405 | /// Bundle this instruction with its successor. This can be an unbundled | ||||||||
406 | /// instruction, or it can be the last instruction in a bundle. | ||||||||
407 | void bundleWithSucc(); | ||||||||
408 | |||||||||
409 | /// Break bundle above this instruction. | ||||||||
410 | void unbundleFromPred(); | ||||||||
411 | |||||||||
412 | /// Break bundle below this instruction. | ||||||||
413 | void unbundleFromSucc(); | ||||||||
414 | |||||||||
415 | /// Returns the debug location id of this MachineInstr. | ||||||||
416 | const DebugLoc &getDebugLoc() const { return debugLoc; } | ||||||||
417 | |||||||||
418 | /// Return the operand containing the offset to be used if this DBG_VALUE | ||||||||
419 | /// instruction is indirect; will be an invalid register if this value is | ||||||||
420 | /// not indirect, and an immediate with value 0 otherwise. | ||||||||
421 | const MachineOperand &getDebugOffset() const { | ||||||||
422 | assert(isDebugValue() && "not a DBG_VALUE")((isDebugValue() && "not a DBG_VALUE") ? static_cast< void> (0) : __assert_fail ("isDebugValue() && \"not a DBG_VALUE\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 422, __PRETTY_FUNCTION__)); | ||||||||
423 | return getOperand(1); | ||||||||
424 | } | ||||||||
425 | MachineOperand &getDebugOffset() { | ||||||||
426 | assert(isDebugValue() && "not a DBG_VALUE")((isDebugValue() && "not a DBG_VALUE") ? static_cast< void> (0) : __assert_fail ("isDebugValue() && \"not a DBG_VALUE\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 426, __PRETTY_FUNCTION__)); | ||||||||
427 | return getOperand(1); | ||||||||
428 | } | ||||||||
429 | |||||||||
430 | /// Return the operand for the debug variable referenced by | ||||||||
431 | /// this DBG_VALUE instruction. | ||||||||
432 | const MachineOperand &getDebugVariableOp() const; | ||||||||
433 | MachineOperand &getDebugVariableOp(); | ||||||||
434 | |||||||||
435 | /// Return the debug variable referenced by | ||||||||
436 | /// this DBG_VALUE instruction. | ||||||||
437 | const DILocalVariable *getDebugVariable() const; | ||||||||
438 | |||||||||
439 | /// Return the operand for the complex address expression referenced by | ||||||||
440 | /// this DBG_VALUE instruction. | ||||||||
441 | MachineOperand &getDebugExpressionOp(); | ||||||||
442 | |||||||||
443 | /// Return the complex address expression referenced by | ||||||||
444 | /// this DBG_VALUE instruction. | ||||||||
445 | const DIExpression *getDebugExpression() const; | ||||||||
446 | |||||||||
447 | /// Return the debug label referenced by | ||||||||
448 | /// this DBG_LABEL instruction. | ||||||||
449 | const DILabel *getDebugLabel() const; | ||||||||
450 | |||||||||
451 | /// Fetch the instruction number of this MachineInstr. If it does not have | ||||||||
452 | /// one already, a new and unique number will be assigned. | ||||||||
453 | unsigned getDebugInstrNum(); | ||||||||
454 | |||||||||
455 | /// Examine the instruction number of this MachineInstr. May be zero if | ||||||||
456 | /// it hasn't been assigned a number yet. | ||||||||
457 | unsigned peekDebugInstrNum() const { return DebugInstrNum; } | ||||||||
458 | |||||||||
459 | /// Set instruction number of this MachineInstr. Avoid using unless you're | ||||||||
460 | /// deserializing this information. | ||||||||
461 | void setDebugInstrNum(unsigned Num) { DebugInstrNum = Num; } | ||||||||
462 | |||||||||
463 | /// Emit an error referring to the source location of this instruction. | ||||||||
464 | /// This should only be used for inline assembly that is somehow | ||||||||
465 | /// impossible to compile. Other errors should have been handled much | ||||||||
466 | /// earlier. | ||||||||
467 | /// | ||||||||
468 | /// If this method returns, the caller should try to recover from the error. | ||||||||
469 | void emitError(StringRef Msg) const; | ||||||||
470 | |||||||||
471 | /// Returns the target instruction descriptor of this MachineInstr. | ||||||||
472 | const MCInstrDesc &getDesc() const { return *MCID; } | ||||||||
473 | |||||||||
474 | /// Returns the opcode of this MachineInstr. | ||||||||
475 | unsigned getOpcode() const { return MCID->Opcode; } | ||||||||
476 | |||||||||
477 | /// Retuns the total number of operands. | ||||||||
478 | unsigned getNumOperands() const { return NumOperands; } | ||||||||
479 | |||||||||
480 | /// Returns the total number of operands which are debug locations. | ||||||||
481 | unsigned getNumDebugOperands() const { | ||||||||
482 | return std::distance(debug_operands().begin(), debug_operands().end()); | ||||||||
483 | } | ||||||||
484 | |||||||||
485 | const MachineOperand& getOperand(unsigned i) const { | ||||||||
486 | assert(i < getNumOperands() && "getOperand() out of range!")((i < getNumOperands() && "getOperand() out of range!" ) ? static_cast<void> (0) : __assert_fail ("i < getNumOperands() && \"getOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 486, __PRETTY_FUNCTION__)); | ||||||||
487 | return Operands[i]; | ||||||||
488 | } | ||||||||
489 | MachineOperand& getOperand(unsigned i) { | ||||||||
490 | assert(i < getNumOperands() && "getOperand() out of range!")((i < getNumOperands() && "getOperand() out of range!" ) ? static_cast<void> (0) : __assert_fail ("i < getNumOperands() && \"getOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 490, __PRETTY_FUNCTION__)); | ||||||||
491 | return Operands[i]; | ||||||||
492 | } | ||||||||
493 | |||||||||
494 | MachineOperand &getDebugOperand(unsigned Index) { | ||||||||
495 | assert(Index < getNumDebugOperands() && "getDebugOperand() out of range!")((Index < getNumDebugOperands() && "getDebugOperand() out of range!" ) ? static_cast<void> (0) : __assert_fail ("Index < getNumDebugOperands() && \"getDebugOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 495, __PRETTY_FUNCTION__)); | ||||||||
496 | return *(debug_operands().begin() + Index); | ||||||||
497 | } | ||||||||
498 | const MachineOperand &getDebugOperand(unsigned Index) const { | ||||||||
499 | assert(Index < getNumDebugOperands() && "getDebugOperand() out of range!")((Index < getNumDebugOperands() && "getDebugOperand() out of range!" ) ? static_cast<void> (0) : __assert_fail ("Index < getNumDebugOperands() && \"getDebugOperand() out of range!\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 499, __PRETTY_FUNCTION__)); | ||||||||
500 | return *(debug_operands().begin() + Index); | ||||||||
501 | } | ||||||||
502 | |||||||||
503 | /// Returns a pointer to the operand corresponding to a debug use of Reg, or | ||||||||
504 | /// nullptr if Reg is not used in any debug operand. | ||||||||
505 | const MachineOperand *getDebugOperandForReg(Register Reg) const { | ||||||||
506 | const MachineOperand *RegOp = | ||||||||
507 | find_if(debug_operands(), [Reg](const MachineOperand &Op) { | ||||||||
508 | return Op.isReg() && Op.getReg() == Reg; | ||||||||
509 | }); | ||||||||
510 | return RegOp == adl_end(debug_operands()) ? nullptr : RegOp; | ||||||||
511 | } | ||||||||
512 | MachineOperand *getDebugOperandForReg(Register Reg) { | ||||||||
513 | MachineOperand *RegOp = | ||||||||
514 | find_if(debug_operands(), [Reg](const MachineOperand &Op) { | ||||||||
515 | return Op.isReg() && Op.getReg() == Reg; | ||||||||
516 | }); | ||||||||
517 | return RegOp == adl_end(debug_operands()) ? nullptr : RegOp; | ||||||||
518 | } | ||||||||
519 | |||||||||
520 | unsigned getDebugOperandIndex(const MachineOperand *Op) const { | ||||||||
521 | assert(Op >= adl_begin(debug_operands()) &&((Op >= adl_begin(debug_operands()) && Op <= adl_end (debug_operands()) && "Expected a debug operand.") ? static_cast <void> (0) : __assert_fail ("Op >= adl_begin(debug_operands()) && Op <= adl_end(debug_operands()) && \"Expected a debug operand.\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 522, __PRETTY_FUNCTION__)) | ||||||||
522 | Op <= adl_end(debug_operands()) && "Expected a debug operand.")((Op >= adl_begin(debug_operands()) && Op <= adl_end (debug_operands()) && "Expected a debug operand.") ? static_cast <void> (0) : __assert_fail ("Op >= adl_begin(debug_operands()) && Op <= adl_end(debug_operands()) && \"Expected a debug operand.\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 522, __PRETTY_FUNCTION__)); | ||||||||
523 | return std::distance(adl_begin(debug_operands()), Op); | ||||||||
524 | } | ||||||||
525 | |||||||||
526 | /// Returns the total number of definitions. | ||||||||
527 | unsigned getNumDefs() const { | ||||||||
528 | return getNumExplicitDefs() + MCID->getNumImplicitDefs(); | ||||||||
529 | } | ||||||||
530 | |||||||||
531 | /// Returns true if the instruction has implicit definition. | ||||||||
532 | bool hasImplicitDef() const { | ||||||||
533 | for (unsigned I = getNumExplicitOperands(), E = getNumOperands(); | ||||||||
534 | I != E; ++I) { | ||||||||
535 | const MachineOperand &MO = getOperand(I); | ||||||||
536 | if (MO.isDef() && MO.isImplicit()) | ||||||||
537 | return true; | ||||||||
538 | } | ||||||||
539 | return false; | ||||||||
540 | } | ||||||||
541 | |||||||||
542 | /// Returns the implicit operands number. | ||||||||
543 | unsigned getNumImplicitOperands() const { | ||||||||
544 | return getNumOperands() - getNumExplicitOperands(); | ||||||||
545 | } | ||||||||
546 | |||||||||
547 | /// Return true if operand \p OpIdx is a subregister index. | ||||||||
548 | bool isOperandSubregIdx(unsigned OpIdx) const { | ||||||||
549 | assert(getOperand(OpIdx).getType() == MachineOperand::MO_Immediate &&((getOperand(OpIdx).getType() == MachineOperand::MO_Immediate && "Expected MO_Immediate operand type.") ? static_cast <void> (0) : __assert_fail ("getOperand(OpIdx).getType() == MachineOperand::MO_Immediate && \"Expected MO_Immediate operand type.\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 550, __PRETTY_FUNCTION__)) | ||||||||
550 | "Expected MO_Immediate operand type.")((getOperand(OpIdx).getType() == MachineOperand::MO_Immediate && "Expected MO_Immediate operand type.") ? static_cast <void> (0) : __assert_fail ("getOperand(OpIdx).getType() == MachineOperand::MO_Immediate && \"Expected MO_Immediate operand type.\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 550, __PRETTY_FUNCTION__)); | ||||||||
551 | if (isExtractSubreg() && OpIdx == 2) | ||||||||
552 | return true; | ||||||||
553 | if (isInsertSubreg() && OpIdx == 3) | ||||||||
554 | return true; | ||||||||
555 | if (isRegSequence() && OpIdx > 1 && (OpIdx % 2) == 0) | ||||||||
556 | return true; | ||||||||
557 | if (isSubregToReg() && OpIdx == 3) | ||||||||
558 | return true; | ||||||||
559 | return false; | ||||||||
560 | } | ||||||||
561 | |||||||||
562 | /// Returns the number of non-implicit operands. | ||||||||
563 | unsigned getNumExplicitOperands() const; | ||||||||
564 | |||||||||
565 | /// Returns the number of non-implicit definitions. | ||||||||
566 | unsigned getNumExplicitDefs() const; | ||||||||
567 | |||||||||
568 | /// iterator/begin/end - Iterate over all operands of a machine instruction. | ||||||||
569 | using mop_iterator = MachineOperand *; | ||||||||
570 | using const_mop_iterator = const MachineOperand *; | ||||||||
571 | |||||||||
572 | mop_iterator operands_begin() { return Operands; } | ||||||||
573 | mop_iterator operands_end() { return Operands + NumOperands; } | ||||||||
574 | |||||||||
575 | const_mop_iterator operands_begin() const { return Operands; } | ||||||||
576 | const_mop_iterator operands_end() const { return Operands + NumOperands; } | ||||||||
577 | |||||||||
578 | iterator_range<mop_iterator> operands() { | ||||||||
579 | return make_range(operands_begin(), operands_end()); | ||||||||
580 | } | ||||||||
581 | iterator_range<const_mop_iterator> operands() const { | ||||||||
582 | return make_range(operands_begin(), operands_end()); | ||||||||
583 | } | ||||||||
584 | iterator_range<mop_iterator> explicit_operands() { | ||||||||
585 | return make_range(operands_begin(), | ||||||||
586 | operands_begin() + getNumExplicitOperands()); | ||||||||
587 | } | ||||||||
588 | iterator_range<const_mop_iterator> explicit_operands() const { | ||||||||
589 | return make_range(operands_begin(), | ||||||||
590 | operands_begin() + getNumExplicitOperands()); | ||||||||
591 | } | ||||||||
592 | iterator_range<mop_iterator> implicit_operands() { | ||||||||
593 | return make_range(explicit_operands().end(), operands_end()); | ||||||||
594 | } | ||||||||
595 | iterator_range<const_mop_iterator> implicit_operands() const { | ||||||||
596 | return make_range(explicit_operands().end(), operands_end()); | ||||||||
597 | } | ||||||||
598 | /// Returns a range over all operands that are used to determine the variable | ||||||||
599 | /// location for this DBG_VALUE instruction. | ||||||||
600 | iterator_range<mop_iterator> debug_operands() { | ||||||||
601 | assert(isDebugValue() && "Must be a debug value instruction.")((isDebugValue() && "Must be a debug value instruction." ) ? static_cast<void> (0) : __assert_fail ("isDebugValue() && \"Must be a debug value instruction.\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 601, __PRETTY_FUNCTION__)); | ||||||||
602 | return make_range(operands_begin(), operands_begin() + 1); | ||||||||
603 | } | ||||||||
604 | /// \copydoc debug_operands() | ||||||||
605 | iterator_range<const_mop_iterator> debug_operands() const { | ||||||||
606 | assert(isDebugValue() && "Must be a debug value instruction.")((isDebugValue() && "Must be a debug value instruction." ) ? static_cast<void> (0) : __assert_fail ("isDebugValue() && \"Must be a debug value instruction.\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 606, __PRETTY_FUNCTION__)); | ||||||||
607 | return make_range(operands_begin(), operands_begin() + 1); | ||||||||
608 | } | ||||||||
609 | /// Returns a range over all explicit operands that are register definitions. | ||||||||
610 | /// Implicit definition are not included! | ||||||||
611 | iterator_range<mop_iterator> defs() { | ||||||||
612 | return make_range(operands_begin(), | ||||||||
613 | operands_begin() + getNumExplicitDefs()); | ||||||||
614 | } | ||||||||
615 | /// \copydoc defs() | ||||||||
616 | iterator_range<const_mop_iterator> defs() const { | ||||||||
617 | return make_range(operands_begin(), | ||||||||
618 | operands_begin() + getNumExplicitDefs()); | ||||||||
619 | } | ||||||||
620 | /// Returns a range that includes all operands that are register uses. | ||||||||
621 | /// This may include unrelated operands which are not register uses. | ||||||||
622 | iterator_range<mop_iterator> uses() { | ||||||||
623 | return make_range(operands_begin() + getNumExplicitDefs(), operands_end()); | ||||||||
624 | } | ||||||||
625 | /// \copydoc uses() | ||||||||
626 | iterator_range<const_mop_iterator> uses() const { | ||||||||
627 | return make_range(operands_begin() + getNumExplicitDefs(), operands_end()); | ||||||||
628 | } | ||||||||
629 | iterator_range<mop_iterator> explicit_uses() { | ||||||||
630 | return make_range(operands_begin() + getNumExplicitDefs(), | ||||||||
631 | operands_begin() + getNumExplicitOperands()); | ||||||||
632 | } | ||||||||
633 | iterator_range<const_mop_iterator> explicit_uses() const { | ||||||||
634 | return make_range(operands_begin() + getNumExplicitDefs(), | ||||||||
635 | operands_begin() + getNumExplicitOperands()); | ||||||||
636 | } | ||||||||
637 | |||||||||
638 | /// Returns the number of the operand iterator \p I points to. | ||||||||
639 | unsigned getOperandNo(const_mop_iterator I) const { | ||||||||
640 | return I - operands_begin(); | ||||||||
641 | } | ||||||||
642 | |||||||||
643 | /// Access to memory operands of the instruction. If there are none, that does | ||||||||
644 | /// not imply anything about whether the function accesses memory. Instead, | ||||||||
645 | /// the caller must behave conservatively. | ||||||||
646 | ArrayRef<MachineMemOperand *> memoperands() const { | ||||||||
647 | if (!Info) | ||||||||
648 | return {}; | ||||||||
649 | |||||||||
650 | if (Info.is<EIIK_MMO>()) | ||||||||
651 | return makeArrayRef(Info.getAddrOfZeroTagPointer(), 1); | ||||||||
652 | |||||||||
653 | if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>()) | ||||||||
654 | return EI->getMMOs(); | ||||||||
655 | |||||||||
656 | return {}; | ||||||||
657 | } | ||||||||
658 | |||||||||
659 | /// Access to memory operands of the instruction. | ||||||||
660 | /// | ||||||||
661 | /// If `memoperands_begin() == memoperands_end()`, that does not imply | ||||||||
662 | /// anything about whether the function accesses memory. Instead, the caller | ||||||||
663 | /// must behave conservatively. | ||||||||
664 | mmo_iterator memoperands_begin() const { return memoperands().begin(); } | ||||||||
665 | |||||||||
666 | /// Access to memory operands of the instruction. | ||||||||
667 | /// | ||||||||
668 | /// If `memoperands_begin() == memoperands_end()`, that does not imply | ||||||||
669 | /// anything about whether the function accesses memory. Instead, the caller | ||||||||
670 | /// must behave conservatively. | ||||||||
671 | mmo_iterator memoperands_end() const { return memoperands().end(); } | ||||||||
672 | |||||||||
673 | /// Return true if we don't have any memory operands which described the | ||||||||
674 | /// memory access done by this instruction. If this is true, calling code | ||||||||
675 | /// must be conservative. | ||||||||
676 | bool memoperands_empty() const { return memoperands().empty(); } | ||||||||
677 | |||||||||
678 | /// Return true if this instruction has exactly one MachineMemOperand. | ||||||||
679 | bool hasOneMemOperand() const { return memoperands().size() == 1; } | ||||||||
680 | |||||||||
681 | /// Return the number of memory operands. | ||||||||
682 | unsigned getNumMemOperands() const { return memoperands().size(); } | ||||||||
683 | |||||||||
684 | /// Helper to extract a pre-instruction symbol if one has been added. | ||||||||
685 | MCSymbol *getPreInstrSymbol() const { | ||||||||
686 | if (!Info) | ||||||||
687 | return nullptr; | ||||||||
688 | if (MCSymbol *S = Info.get<EIIK_PreInstrSymbol>()) | ||||||||
689 | return S; | ||||||||
690 | if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>()) | ||||||||
691 | return EI->getPreInstrSymbol(); | ||||||||
692 | |||||||||
693 | return nullptr; | ||||||||
694 | } | ||||||||
695 | |||||||||
696 | /// Helper to extract a post-instruction symbol if one has been added. | ||||||||
697 | MCSymbol *getPostInstrSymbol() const { | ||||||||
698 | if (!Info) | ||||||||
699 | return nullptr; | ||||||||
700 | if (MCSymbol *S = Info.get<EIIK_PostInstrSymbol>()) | ||||||||
701 | return S; | ||||||||
702 | if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>()) | ||||||||
703 | return EI->getPostInstrSymbol(); | ||||||||
704 | |||||||||
705 | return nullptr; | ||||||||
706 | } | ||||||||
707 | |||||||||
708 | /// Helper to extract a heap alloc marker if one has been added. | ||||||||
709 | MDNode *getHeapAllocMarker() const { | ||||||||
710 | if (!Info) | ||||||||
711 | return nullptr; | ||||||||
712 | if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>()) | ||||||||
713 | return EI->getHeapAllocMarker(); | ||||||||
714 | |||||||||
715 | return nullptr; | ||||||||
716 | } | ||||||||
717 | |||||||||
718 | /// API for querying MachineInstr properties. They are the same as MCInstrDesc | ||||||||
719 | /// queries but they are bundle aware. | ||||||||
720 | |||||||||
721 | enum QueryType { | ||||||||
722 | IgnoreBundle, // Ignore bundles | ||||||||
723 | AnyInBundle, // Return true if any instruction in bundle has property | ||||||||
724 | AllInBundle // Return true if all instructions in bundle have property | ||||||||
725 | }; | ||||||||
726 | |||||||||
727 | /// Return true if the instruction (or in the case of a bundle, | ||||||||
728 | /// the instructions inside the bundle) has the specified property. | ||||||||
729 | /// The first argument is the property being queried. | ||||||||
730 | /// The second argument indicates whether the query should look inside | ||||||||
731 | /// instruction bundles. | ||||||||
732 | bool hasProperty(unsigned MCFlag, QueryType Type = AnyInBundle) const { | ||||||||
733 | assert(MCFlag < 64 &&((MCFlag < 64 && "MCFlag out of range for bit mask in getFlags/hasPropertyInBundle." ) ? static_cast<void> (0) : __assert_fail ("MCFlag < 64 && \"MCFlag out of range for bit mask in getFlags/hasPropertyInBundle.\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 734, __PRETTY_FUNCTION__)) | ||||||||
734 | "MCFlag out of range for bit mask in getFlags/hasPropertyInBundle.")((MCFlag < 64 && "MCFlag out of range for bit mask in getFlags/hasPropertyInBundle." ) ? static_cast<void> (0) : __assert_fail ("MCFlag < 64 && \"MCFlag out of range for bit mask in getFlags/hasPropertyInBundle.\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 734, __PRETTY_FUNCTION__)); | ||||||||
735 | // Inline the fast path for unbundled or bundle-internal instructions. | ||||||||
736 | if (Type
| ||||||||
737 | return getDesc().getFlags() & (1ULL << MCFlag); | ||||||||
738 | |||||||||
739 | // If this is the first instruction in a bundle, take the slow path. | ||||||||
740 | return hasPropertyInBundle(1ULL << MCFlag, Type); | ||||||||
741 | } | ||||||||
742 | |||||||||
743 | /// Return true if this is an instruction that should go through the usual | ||||||||
744 | /// legalization steps. | ||||||||
745 | bool isPreISelOpcode(QueryType Type = IgnoreBundle) const { | ||||||||
746 | return hasProperty(MCID::PreISelOpcode, Type); | ||||||||
747 | } | ||||||||
748 | |||||||||
749 | /// Return true if this instruction can have a variable number of operands. | ||||||||
750 | /// In this case, the variable operands will be after the normal | ||||||||
751 | /// operands but before the implicit definitions and uses (if any are | ||||||||
752 | /// present). | ||||||||
753 | bool isVariadic(QueryType Type = IgnoreBundle) const { | ||||||||
754 | return hasProperty(MCID::Variadic, Type); | ||||||||
755 | } | ||||||||
756 | |||||||||
757 | /// Set if this instruction has an optional definition, e.g. | ||||||||
758 | /// ARM instructions which can set condition code if 's' bit is set. | ||||||||
759 | bool hasOptionalDef(QueryType Type = IgnoreBundle) const { | ||||||||
760 | return hasProperty(MCID::HasOptionalDef, Type); | ||||||||
761 | } | ||||||||
762 | |||||||||
763 | /// Return true if this is a pseudo instruction that doesn't | ||||||||
764 | /// correspond to a real machine instruction. | ||||||||
765 | bool isPseudo(QueryType Type = IgnoreBundle) const { | ||||||||
766 | return hasProperty(MCID::Pseudo, Type); | ||||||||
767 | } | ||||||||
768 | |||||||||
769 | bool isReturn(QueryType Type = AnyInBundle) const { | ||||||||
770 | return hasProperty(MCID::Return, Type); | ||||||||
771 | } | ||||||||
772 | |||||||||
773 | /// Return true if this is an instruction that marks the end of an EH scope, | ||||||||
774 | /// i.e., a catchpad or a cleanuppad instruction. | ||||||||
775 | bool isEHScopeReturn(QueryType Type = AnyInBundle) const { | ||||||||
776 | return hasProperty(MCID::EHScopeReturn, Type); | ||||||||
777 | } | ||||||||
778 | |||||||||
779 | bool isCall(QueryType Type = AnyInBundle) const { | ||||||||
780 | return hasProperty(MCID::Call, Type); | ||||||||
781 | } | ||||||||
782 | |||||||||
783 | /// Return true if this is a call instruction that may have an associated | ||||||||
784 | /// call site entry in the debug info. | ||||||||
785 | bool isCandidateForCallSiteEntry(QueryType Type = IgnoreBundle) const; | ||||||||
786 | /// Return true if copying, moving, or erasing this instruction requires | ||||||||
787 | /// updating Call Site Info (see \ref copyCallSiteInfo, \ref moveCallSiteInfo, | ||||||||
788 | /// \ref eraseCallSiteInfo). | ||||||||
789 | bool shouldUpdateCallSiteInfo() const; | ||||||||
790 | |||||||||
791 | /// Returns true if the specified instruction stops control flow | ||||||||
792 | /// from executing the instruction immediately following it. Examples include | ||||||||
793 | /// unconditional branches and return instructions. | ||||||||
794 | bool isBarrier(QueryType Type = AnyInBundle) const { | ||||||||
795 | return hasProperty(MCID::Barrier, Type); | ||||||||
796 | } | ||||||||
797 | |||||||||
798 | /// Returns true if this instruction part of the terminator for a basic block. | ||||||||
799 | /// Typically this is things like return and branch instructions. | ||||||||
800 | /// | ||||||||
801 | /// Various passes use this to insert code into the bottom of a basic block, | ||||||||
802 | /// but before control flow occurs. | ||||||||
803 | bool isTerminator(QueryType Type = AnyInBundle) const { | ||||||||
804 | return hasProperty(MCID::Terminator, Type); | ||||||||
805 | } | ||||||||
806 | |||||||||
807 | /// Returns true if this is a conditional, unconditional, or indirect branch. | ||||||||
808 | /// Predicates below can be used to discriminate between | ||||||||
809 | /// these cases, and the TargetInstrInfo::analyzeBranch method can be used to | ||||||||
810 | /// get more information. | ||||||||
811 | bool isBranch(QueryType Type = AnyInBundle) const { | ||||||||
812 | return hasProperty(MCID::Branch, Type); | ||||||||
813 | } | ||||||||
814 | |||||||||
815 | /// Return true if this is an indirect branch, such as a | ||||||||
816 | /// branch through a register. | ||||||||
817 | bool isIndirectBranch(QueryType Type = AnyInBundle) const { | ||||||||
818 | return hasProperty(MCID::IndirectBranch, Type); | ||||||||
819 | } | ||||||||
820 | |||||||||
821 | /// Return true if this is a branch which may fall | ||||||||
822 | /// through to the next instruction or may transfer control flow to some other | ||||||||
823 | /// block. The TargetInstrInfo::analyzeBranch method can be used to get more | ||||||||
824 | /// information about this branch. | ||||||||
825 | bool isConditionalBranch(QueryType Type = AnyInBundle) const { | ||||||||
826 | return isBranch(Type) && !isBarrier(Type) && !isIndirectBranch(Type); | ||||||||
827 | } | ||||||||
828 | |||||||||
829 | /// Return true if this is a branch which always | ||||||||
830 | /// transfers control flow to some other block. The | ||||||||
831 | /// TargetInstrInfo::analyzeBranch method can be used to get more information | ||||||||
832 | /// about this branch. | ||||||||
833 | bool isUnconditionalBranch(QueryType Type = AnyInBundle) const { | ||||||||
834 | return isBranch(Type) && isBarrier(Type) && !isIndirectBranch(Type); | ||||||||
835 | } | ||||||||
836 | |||||||||
837 | /// Return true if this instruction has a predicate operand that | ||||||||
838 | /// controls execution. It may be set to 'always', or may be set to other | ||||||||
839 | /// values. There are various methods in TargetInstrInfo that can be used to | ||||||||
840 | /// control and modify the predicate in this instruction. | ||||||||
841 | bool isPredicable(QueryType Type = AllInBundle) const { | ||||||||
842 | // If it's a bundle than all bundled instructions must be predicable for this | ||||||||
843 | // to return true. | ||||||||
844 | return hasProperty(MCID::Predicable, Type); | ||||||||
845 | } | ||||||||
846 | |||||||||
847 | /// Return true if this instruction is a comparison. | ||||||||
848 | bool isCompare(QueryType Type = IgnoreBundle) const { | ||||||||
849 | return hasProperty(MCID::Compare, Type); | ||||||||
850 | } | ||||||||
851 | |||||||||
852 | /// Return true if this instruction is a move immediate | ||||||||
853 | /// (including conditional moves) instruction. | ||||||||
854 | bool isMoveImmediate(QueryType Type = IgnoreBundle) const { | ||||||||
855 | return hasProperty(MCID::MoveImm, Type); | ||||||||
856 | } | ||||||||
857 | |||||||||
858 | /// Return true if this instruction is a register move. | ||||||||
859 | /// (including moving values from subreg to reg) | ||||||||
860 | bool isMoveReg(QueryType Type = IgnoreBundle) const { | ||||||||
861 | return hasProperty(MCID::MoveReg, Type); | ||||||||
862 | } | ||||||||
863 | |||||||||
864 | /// Return true if this instruction is a bitcast instruction. | ||||||||
865 | bool isBitcast(QueryType Type = IgnoreBundle) const { | ||||||||
866 | return hasProperty(MCID::Bitcast, Type); | ||||||||
867 | } | ||||||||
868 | |||||||||
869 | /// Return true if this instruction is a select instruction. | ||||||||
870 | bool isSelect(QueryType Type = IgnoreBundle) const { | ||||||||
871 | return hasProperty(MCID::Select, Type); | ||||||||
872 | } | ||||||||
873 | |||||||||
874 | /// Return true if this instruction cannot be safely duplicated. | ||||||||
875 | /// For example, if the instruction has a unique labels attached | ||||||||
876 | /// to it, duplicating it would cause multiple definition errors. | ||||||||
877 | bool isNotDuplicable(QueryType Type = AnyInBundle) const { | ||||||||
878 | return hasProperty(MCID::NotDuplicable, Type); | ||||||||
879 | } | ||||||||
880 | |||||||||
881 | /// Return true if this instruction is convergent. | ||||||||
882 | /// Convergent instructions can not be made control-dependent on any | ||||||||
883 | /// additional values. | ||||||||
884 | bool isConvergent(QueryType Type = AnyInBundle) const { | ||||||||
885 | if (isInlineAsm()) { | ||||||||
886 | unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm(); | ||||||||
887 | if (ExtraInfo & InlineAsm::Extra_IsConvergent) | ||||||||
888 | return true; | ||||||||
889 | } | ||||||||
890 | return hasProperty(MCID::Convergent, Type); | ||||||||
891 | } | ||||||||
892 | |||||||||
893 | /// Returns true if the specified instruction has a delay slot | ||||||||
894 | /// which must be filled by the code generator. | ||||||||
895 | bool hasDelaySlot(QueryType Type = AnyInBundle) const { | ||||||||
896 | return hasProperty(MCID::DelaySlot, Type); | ||||||||
897 | } | ||||||||
898 | |||||||||
899 | /// Return true for instructions that can be folded as | ||||||||
900 | /// memory operands in other instructions. The most common use for this | ||||||||
901 | /// is instructions that are simple loads from memory that don't modify | ||||||||
902 | /// the loaded value in any way, but it can also be used for instructions | ||||||||
903 | /// that can be expressed as constant-pool loads, such as V_SETALLONES | ||||||||
904 | /// on x86, to allow them to be folded when it is beneficial. | ||||||||
905 | /// This should only be set on instructions that return a value in their | ||||||||
906 | /// only virtual register definition. | ||||||||
907 | bool canFoldAsLoad(QueryType Type = IgnoreBundle) const { | ||||||||
908 | return hasProperty(MCID::FoldableAsLoad, Type); | ||||||||
909 | } | ||||||||
910 | |||||||||
911 | /// Return true if this instruction behaves | ||||||||
912 | /// the same way as the generic REG_SEQUENCE instructions. | ||||||||
913 | /// E.g., on ARM, | ||||||||
914 | /// dX VMOVDRR rY, rZ | ||||||||
915 | /// is equivalent to | ||||||||
916 | /// dX = REG_SEQUENCE rY, ssub_0, rZ, ssub_1. | ||||||||
917 | /// | ||||||||
918 | /// Note that for the optimizers to be able to take advantage of | ||||||||
919 | /// this property, TargetInstrInfo::getRegSequenceLikeInputs has to be | ||||||||
920 | /// override accordingly. | ||||||||
921 | bool isRegSequenceLike(QueryType Type = IgnoreBundle) const { | ||||||||
922 | return hasProperty(MCID::RegSequence, Type); | ||||||||
923 | } | ||||||||
924 | |||||||||
925 | /// Return true if this instruction behaves | ||||||||
926 | /// the same way as the generic EXTRACT_SUBREG instructions. | ||||||||
927 | /// E.g., on ARM, | ||||||||
928 | /// rX, rY VMOVRRD dZ | ||||||||
929 | /// is equivalent to two EXTRACT_SUBREG: | ||||||||
930 | /// rX = EXTRACT_SUBREG dZ, ssub_0 | ||||||||
931 | /// rY = EXTRACT_SUBREG dZ, ssub_1 | ||||||||
932 | /// | ||||||||
933 | /// Note that for the optimizers to be able to take advantage of | ||||||||
934 | /// this property, TargetInstrInfo::getExtractSubregLikeInputs has to be | ||||||||
935 | /// override accordingly. | ||||||||
936 | bool isExtractSubregLike(QueryType Type = IgnoreBundle) const { | ||||||||
937 | return hasProperty(MCID::ExtractSubreg, Type); | ||||||||
938 | } | ||||||||
939 | |||||||||
940 | /// Return true if this instruction behaves | ||||||||
941 | /// the same way as the generic INSERT_SUBREG instructions. | ||||||||
942 | /// E.g., on ARM, | ||||||||
943 | /// dX = VSETLNi32 dY, rZ, Imm | ||||||||
944 | /// is equivalent to a INSERT_SUBREG: | ||||||||
945 | /// dX = INSERT_SUBREG dY, rZ, translateImmToSubIdx(Imm) | ||||||||
946 | /// | ||||||||
947 | /// Note that for the optimizers to be able to take advantage of | ||||||||
948 | /// this property, TargetInstrInfo::getInsertSubregLikeInputs has to be | ||||||||
949 | /// override accordingly. | ||||||||
950 | bool isInsertSubregLike(QueryType Type = IgnoreBundle) const { | ||||||||
951 | return hasProperty(MCID::InsertSubreg, Type); | ||||||||
952 | } | ||||||||
953 | |||||||||
954 | //===--------------------------------------------------------------------===// | ||||||||
955 | // Side Effect Analysis | ||||||||
956 | //===--------------------------------------------------------------------===// | ||||||||
957 | |||||||||
958 | /// Return true if this instruction could possibly read memory. | ||||||||
959 | /// Instructions with this flag set are not necessarily simple load | ||||||||
960 | /// instructions, they may load a value and modify it, for example. | ||||||||
961 | bool mayLoad(QueryType Type = AnyInBundle) const { | ||||||||
962 | if (isInlineAsm()) { | ||||||||
963 | unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm(); | ||||||||
964 | if (ExtraInfo & InlineAsm::Extra_MayLoad) | ||||||||
965 | return true; | ||||||||
966 | } | ||||||||
967 | return hasProperty(MCID::MayLoad, Type); | ||||||||
968 | } | ||||||||
969 | |||||||||
970 | /// Return true if this instruction could possibly modify memory. | ||||||||
971 | /// Instructions with this flag set are not necessarily simple store | ||||||||
972 | /// instructions, they may store a modified value based on their operands, or | ||||||||
973 | /// may not actually modify anything, for example. | ||||||||
974 | bool mayStore(QueryType Type = AnyInBundle) const { | ||||||||
975 | if (isInlineAsm()) { | ||||||||
976 | unsigned ExtraInfo = getOperand(InlineAsm::MIOp_ExtraInfo).getImm(); | ||||||||
977 | if (ExtraInfo & InlineAsm::Extra_MayStore) | ||||||||
978 | return true; | ||||||||
979 | } | ||||||||
980 | return hasProperty(MCID::MayStore, Type); | ||||||||
981 | } | ||||||||
982 | |||||||||
983 | /// Return true if this instruction could possibly read or modify memory. | ||||||||
984 | bool mayLoadOrStore(QueryType Type = AnyInBundle) const { | ||||||||
985 | return mayLoad(Type) || mayStore(Type); | ||||||||
986 | } | ||||||||
987 | |||||||||
988 | /// Return true if this instruction could possibly raise a floating-point | ||||||||
989 | /// exception. This is the case if the instruction is a floating-point | ||||||||
990 | /// instruction that can in principle raise an exception, as indicated | ||||||||
991 | /// by the MCID::MayRaiseFPException property, *and* at the same time, | ||||||||
992 | /// the instruction is used in a context where we expect floating-point | ||||||||
993 | /// exceptions are not disabled, as indicated by the NoFPExcept MI flag. | ||||||||
994 | bool mayRaiseFPException() const { | ||||||||
995 | return hasProperty(MCID::MayRaiseFPException) && | ||||||||
996 | !getFlag(MachineInstr::MIFlag::NoFPExcept); | ||||||||
997 | } | ||||||||
998 | |||||||||
999 | //===--------------------------------------------------------------------===// | ||||||||
1000 | // Flags that indicate whether an instruction can be modified by a method. | ||||||||
1001 | //===--------------------------------------------------------------------===// | ||||||||
1002 | |||||||||
1003 | /// Return true if this may be a 2- or 3-address | ||||||||
1004 | /// instruction (of the form "X = op Y, Z, ..."), which produces the same | ||||||||
1005 | /// result if Y and Z are exchanged. If this flag is set, then the | ||||||||
1006 | /// TargetInstrInfo::commuteInstruction method may be used to hack on the | ||||||||
1007 | /// instruction. | ||||||||
1008 | /// | ||||||||
1009 | /// Note that this flag may be set on instructions that are only commutable | ||||||||
1010 | /// sometimes. In these cases, the call to commuteInstruction will fail. | ||||||||
1011 | /// Also note that some instructions require non-trivial modification to | ||||||||
1012 | /// commute them. | ||||||||
1013 | bool isCommutable(QueryType Type = IgnoreBundle) const { | ||||||||
1014 | return hasProperty(MCID::Commutable, Type); | ||||||||
1015 | } | ||||||||
1016 | |||||||||
1017 | /// Return true if this is a 2-address instruction | ||||||||
1018 | /// which can be changed into a 3-address instruction if needed. Doing this | ||||||||
1019 | /// transformation can be profitable in the register allocator, because it | ||||||||
1020 | /// means that the instruction can use a 2-address form if possible, but | ||||||||
1021 | /// degrade into a less efficient form if the source and dest register cannot | ||||||||
1022 | /// be assigned to the same register. For example, this allows the x86 | ||||||||
1023 | /// backend to turn a "shl reg, 3" instruction into an LEA instruction, which | ||||||||
1024 | /// is the same speed as the shift but has bigger code size. | ||||||||
1025 | /// | ||||||||
1026 | /// If this returns true, then the target must implement the | ||||||||
1027 | /// TargetInstrInfo::convertToThreeAddress method for this instruction, which | ||||||||
1028 | /// is allowed to fail if the transformation isn't valid for this specific | ||||||||
1029 | /// instruction (e.g. shl reg, 4 on x86). | ||||||||
1030 | /// | ||||||||
1031 | bool isConvertibleTo3Addr(QueryType Type = IgnoreBundle) const { | ||||||||
1032 | return hasProperty(MCID::ConvertibleTo3Addr, Type); | ||||||||
1033 | } | ||||||||
1034 | |||||||||
1035 | /// Return true if this instruction requires | ||||||||
1036 | /// custom insertion support when the DAG scheduler is inserting it into a | ||||||||
1037 | /// machine basic block. If this is true for the instruction, it basically | ||||||||
1038 | /// means that it is a pseudo instruction used at SelectionDAG time that is | ||||||||
1039 | /// expanded out into magic code by the target when MachineInstrs are formed. | ||||||||
1040 | /// | ||||||||
1041 | /// If this is true, the TargetLoweringInfo::InsertAtEndOfBasicBlock method | ||||||||
1042 | /// is used to insert this into the MachineBasicBlock. | ||||||||
1043 | bool usesCustomInsertionHook(QueryType Type = IgnoreBundle) const { | ||||||||
1044 | return hasProperty(MCID::UsesCustomInserter, Type); | ||||||||
1045 | } | ||||||||
1046 | |||||||||
1047 | /// Return true if this instruction requires *adjustment* | ||||||||
1048 | /// after instruction selection by calling a target hook. For example, this | ||||||||
1049 | /// can be used to fill in ARM 's' optional operand depending on whether | ||||||||
1050 | /// the conditional flag register is used. | ||||||||
1051 | bool hasPostISelHook(QueryType Type = IgnoreBundle) const { | ||||||||
1052 | return hasProperty(MCID::HasPostISelHook, Type); | ||||||||
1053 | } | ||||||||
1054 | |||||||||
1055 | /// Returns true if this instruction is a candidate for remat. | ||||||||
1056 | /// This flag is deprecated, please don't use it anymore. If this | ||||||||
1057 | /// flag is set, the isReallyTriviallyReMaterializable() method is called to | ||||||||
1058 | /// verify the instruction is really rematable. | ||||||||
1059 | bool isRematerializable(QueryType Type = AllInBundle) const { | ||||||||
1060 | // It's only possible to re-mat a bundle if all bundled instructions are | ||||||||
1061 | // re-materializable. | ||||||||
1062 | return hasProperty(MCID::Rematerializable, Type); | ||||||||
1063 | } | ||||||||
1064 | |||||||||
1065 | /// Returns true if this instruction has the same cost (or less) than a move | ||||||||
1066 | /// instruction. This is useful during certain types of optimizations | ||||||||
1067 | /// (e.g., remat during two-address conversion or machine licm) | ||||||||
1068 | /// where we would like to remat or hoist the instruction, but not if it costs | ||||||||
1069 | /// more than moving the instruction into the appropriate register. Note, we | ||||||||
1070 | /// are not marking copies from and to the same register class with this flag. | ||||||||
1071 | bool isAsCheapAsAMove(QueryType Type = AllInBundle) const { | ||||||||
1072 | // Only returns true for a bundle if all bundled instructions are cheap. | ||||||||
1073 | return hasProperty(MCID::CheapAsAMove, Type); | ||||||||
1074 | } | ||||||||
1075 | |||||||||
1076 | /// Returns true if this instruction source operands | ||||||||
1077 | /// have special register allocation requirements that are not captured by the | ||||||||
1078 | /// operand register classes. e.g. ARM::STRD's two source registers must be an | ||||||||
1079 | /// even / odd pair, ARM::STM registers have to be in ascending order. | ||||||||
1080 | /// Post-register allocation passes should not attempt to change allocations | ||||||||
1081 | /// for sources of instructions with this flag. | ||||||||
1082 | bool hasExtraSrcRegAllocReq(QueryType Type = AnyInBundle) const { | ||||||||
1083 | return hasProperty(MCID::ExtraSrcRegAllocReq, Type); | ||||||||
1084 | } | ||||||||
1085 | |||||||||
1086 | /// Returns true if this instruction def operands | ||||||||
1087 | /// have special register allocation requirements that are not captured by the | ||||||||
1088 | /// operand register classes. e.g. ARM::LDRD's two def registers must be an | ||||||||
1089 | /// even / odd pair, ARM::LDM registers have to be in ascending order. | ||||||||
1090 | /// Post-register allocation passes should not attempt to change allocations | ||||||||
1091 | /// for definitions of instructions with this flag. | ||||||||
1092 | bool hasExtraDefRegAllocReq(QueryType Type = AnyInBundle) const { | ||||||||
1093 | return hasProperty(MCID::ExtraDefRegAllocReq, Type); | ||||||||
1094 | } | ||||||||
1095 | |||||||||
1096 | enum MICheckType { | ||||||||
1097 | CheckDefs, // Check all operands for equality | ||||||||
1098 | CheckKillDead, // Check all operands including kill / dead markers | ||||||||
1099 | IgnoreDefs, // Ignore all definitions | ||||||||
1100 | IgnoreVRegDefs // Ignore virtual register definitions | ||||||||
1101 | }; | ||||||||
1102 | |||||||||
1103 | /// Return true if this instruction is identical to \p Other. | ||||||||
1104 | /// Two instructions are identical if they have the same opcode and all their | ||||||||
1105 | /// operands are identical (with respect to MachineOperand::isIdenticalTo()). | ||||||||
1106 | /// Note that this means liveness related flags (dead, undef, kill) do not | ||||||||
1107 | /// affect the notion of identical. | ||||||||
1108 | bool isIdenticalTo(const MachineInstr &Other, | ||||||||
1109 | MICheckType Check = CheckDefs) const; | ||||||||
1110 | |||||||||
1111 | /// Unlink 'this' from the containing basic block, and return it without | ||||||||
1112 | /// deleting it. | ||||||||
1113 | /// | ||||||||
1114 | /// This function can not be used on bundled instructions, use | ||||||||
1115 | /// removeFromBundle() to remove individual instructions from a bundle. | ||||||||
1116 | MachineInstr *removeFromParent(); | ||||||||
1117 | |||||||||
1118 | /// Unlink this instruction from its basic block and return it without | ||||||||
1119 | /// deleting it. | ||||||||
1120 | /// | ||||||||
1121 | /// If the instruction is part of a bundle, the other instructions in the | ||||||||
1122 | /// bundle remain bundled. | ||||||||
1123 | MachineInstr *removeFromBundle(); | ||||||||
1124 | |||||||||
1125 | /// Unlink 'this' from the containing basic block and delete it. | ||||||||
1126 | /// | ||||||||
1127 | /// If this instruction is the header of a bundle, the whole bundle is erased. | ||||||||
1128 | /// This function can not be used for instructions inside a bundle, use | ||||||||
1129 | /// eraseFromBundle() to erase individual bundled instructions. | ||||||||
1130 | void eraseFromParent(); | ||||||||
1131 | |||||||||
1132 | /// Unlink 'this' from the containing basic block and delete it. | ||||||||
1133 | /// | ||||||||
1134 | /// For all definitions mark their uses in DBG_VALUE nodes | ||||||||
1135 | /// as undefined. Otherwise like eraseFromParent(). | ||||||||
1136 | void eraseFromParentAndMarkDBGValuesForRemoval(); | ||||||||
1137 | |||||||||
1138 | /// Unlink 'this' form its basic block and delete it. | ||||||||
1139 | /// | ||||||||
1140 | /// If the instruction is part of a bundle, the other instructions in the | ||||||||
1141 | /// bundle remain bundled. | ||||||||
1142 | void eraseFromBundle(); | ||||||||
1143 | |||||||||
1144 | bool isEHLabel() const { return getOpcode() == TargetOpcode::EH_LABEL; } | ||||||||
1145 | bool isGCLabel() const { return getOpcode() == TargetOpcode::GC_LABEL; } | ||||||||
1146 | bool isAnnotationLabel() const { | ||||||||
1147 | return getOpcode() == TargetOpcode::ANNOTATION_LABEL; | ||||||||
1148 | } | ||||||||
1149 | |||||||||
1150 | /// Returns true if the MachineInstr represents a label. | ||||||||
1151 | bool isLabel() const { | ||||||||
1152 | return isEHLabel() || isGCLabel() || isAnnotationLabel(); | ||||||||
1153 | } | ||||||||
1154 | |||||||||
1155 | bool isCFIInstruction() const { | ||||||||
1156 | return getOpcode() == TargetOpcode::CFI_INSTRUCTION; | ||||||||
1157 | } | ||||||||
1158 | |||||||||
1159 | bool isPseudoProbe() const { | ||||||||
1160 | return getOpcode() == TargetOpcode::PSEUDO_PROBE; | ||||||||
1161 | } | ||||||||
1162 | |||||||||
1163 | // True if the instruction represents a position in the function. | ||||||||
1164 | bool isPosition() const { return isLabel() || isCFIInstruction(); } | ||||||||
1165 | |||||||||
1166 | bool isDebugValue() const { return getOpcode() == TargetOpcode::DBG_VALUE; } | ||||||||
1167 | bool isDebugLabel() const { return getOpcode() == TargetOpcode::DBG_LABEL; } | ||||||||
1168 | bool isDebugRef() const { return getOpcode() == TargetOpcode::DBG_INSTR_REF; } | ||||||||
1169 | bool isDebugInstr() const { | ||||||||
1170 | return isDebugValue() || isDebugLabel() || isDebugRef(); | ||||||||
1171 | } | ||||||||
1172 | bool isDebugOrPseudoInstr() const { | ||||||||
1173 | return isDebugInstr() || isPseudoProbe(); | ||||||||
1174 | } | ||||||||
1175 | |||||||||
1176 | bool isDebugOffsetImm() const { return getDebugOffset().isImm(); } | ||||||||
1177 | |||||||||
1178 | /// A DBG_VALUE is indirect iff the location operand is a register and | ||||||||
1179 | /// the offset operand is an immediate. | ||||||||
1180 | bool isIndirectDebugValue() const { | ||||||||
1181 | return isDebugValue() && getDebugOperand(0).isReg() && isDebugOffsetImm(); | ||||||||
1182 | } | ||||||||
1183 | |||||||||
1184 | /// A DBG_VALUE is an entry value iff its debug expression contains the | ||||||||
1185 | /// DW_OP_LLVM_entry_value operation. | ||||||||
1186 | bool isDebugEntryValue() const; | ||||||||
1187 | |||||||||
1188 | /// Return true if the instruction is a debug value which describes a part of | ||||||||
1189 | /// a variable as unavailable. | ||||||||
1190 | bool isUndefDebugValue() const { | ||||||||
1191 | return isDebugValue() && getDebugOperand(0).isReg() && | ||||||||
1192 | !getDebugOperand(0).getReg().isValid(); | ||||||||
1193 | } | ||||||||
1194 | |||||||||
1195 | bool isPHI() const { | ||||||||
1196 | return getOpcode() == TargetOpcode::PHI || | ||||||||
1197 | getOpcode() == TargetOpcode::G_PHI; | ||||||||
1198 | } | ||||||||
1199 | bool isKill() const { return getOpcode() == TargetOpcode::KILL; } | ||||||||
1200 | bool isImplicitDef() const { return getOpcode()==TargetOpcode::IMPLICIT_DEF; } | ||||||||
1201 | bool isInlineAsm() const { | ||||||||
1202 | return getOpcode() == TargetOpcode::INLINEASM || | ||||||||
1203 | getOpcode() == TargetOpcode::INLINEASM_BR; | ||||||||
1204 | } | ||||||||
1205 | |||||||||
1206 | /// FIXME: Seems like a layering violation that the AsmDialect, which is X86 | ||||||||
1207 | /// specific, be attached to a generic MachineInstr. | ||||||||
1208 | bool isMSInlineAsm() const { | ||||||||
1209 | return isInlineAsm() && getInlineAsmDialect() == InlineAsm::AD_Intel; | ||||||||
1210 | } | ||||||||
1211 | |||||||||
1212 | bool isStackAligningInlineAsm() const; | ||||||||
1213 | InlineAsm::AsmDialect getInlineAsmDialect() const; | ||||||||
1214 | |||||||||
1215 | bool isInsertSubreg() const { | ||||||||
1216 | return getOpcode() == TargetOpcode::INSERT_SUBREG; | ||||||||
1217 | } | ||||||||
1218 | |||||||||
1219 | bool isSubregToReg() const { | ||||||||
1220 | return getOpcode() == TargetOpcode::SUBREG_TO_REG; | ||||||||
1221 | } | ||||||||
1222 | |||||||||
1223 | bool isRegSequence() const { | ||||||||
1224 | return getOpcode() == TargetOpcode::REG_SEQUENCE; | ||||||||
1225 | } | ||||||||
1226 | |||||||||
1227 | bool isBundle() const { | ||||||||
1228 | return getOpcode() == TargetOpcode::BUNDLE; | ||||||||
1229 | } | ||||||||
1230 | |||||||||
1231 | bool isCopy() const { | ||||||||
1232 | return getOpcode() == TargetOpcode::COPY; | ||||||||
1233 | } | ||||||||
1234 | |||||||||
1235 | bool isFullCopy() const { | ||||||||
1236 | return isCopy() && !getOperand(0).getSubReg() && !getOperand(1).getSubReg(); | ||||||||
1237 | } | ||||||||
1238 | |||||||||
1239 | bool isExtractSubreg() const { | ||||||||
1240 | return getOpcode() == TargetOpcode::EXTRACT_SUBREG; | ||||||||
1241 | } | ||||||||
1242 | |||||||||
1243 | /// Return true if the instruction behaves like a copy. | ||||||||
1244 | /// This does not include native copy instructions. | ||||||||
1245 | bool isCopyLike() const { | ||||||||
1246 | return isCopy() || isSubregToReg(); | ||||||||
1247 | } | ||||||||
1248 | |||||||||
1249 | /// Return true is the instruction is an identity copy. | ||||||||
1250 | bool isIdentityCopy() const { | ||||||||
1251 | return isCopy() && getOperand(0).getReg() == getOperand(1).getReg() && | ||||||||
1252 | getOperand(0).getSubReg() == getOperand(1).getSubReg(); | ||||||||
1253 | } | ||||||||
1254 | |||||||||
1255 | /// Return true if this instruction doesn't produce any output in the form of | ||||||||
1256 | /// executable instructions. | ||||||||
1257 | bool isMetaInstruction() const { | ||||||||
1258 | switch (getOpcode()) { | ||||||||
1259 | default: | ||||||||
1260 | return false; | ||||||||
1261 | case TargetOpcode::IMPLICIT_DEF: | ||||||||
1262 | case TargetOpcode::KILL: | ||||||||
1263 | case TargetOpcode::CFI_INSTRUCTION: | ||||||||
1264 | case TargetOpcode::EH_LABEL: | ||||||||
1265 | case TargetOpcode::GC_LABEL: | ||||||||
1266 | case TargetOpcode::DBG_VALUE: | ||||||||
1267 | case TargetOpcode::DBG_INSTR_REF: | ||||||||
1268 | case TargetOpcode::DBG_LABEL: | ||||||||
1269 | case TargetOpcode::LIFETIME_START: | ||||||||
1270 | case TargetOpcode::LIFETIME_END: | ||||||||
1271 | case TargetOpcode::PSEUDO_PROBE: | ||||||||
1272 | return true; | ||||||||
1273 | } | ||||||||
1274 | } | ||||||||
1275 | |||||||||
1276 | /// Return true if this is a transient instruction that is either very likely | ||||||||
1277 | /// to be eliminated during register allocation (such as copy-like | ||||||||
1278 | /// instructions), or if this instruction doesn't have an execution-time cost. | ||||||||
1279 | bool isTransient() const { | ||||||||
1280 | switch (getOpcode()) { | ||||||||
1281 | default: | ||||||||
1282 | return isMetaInstruction(); | ||||||||
1283 | // Copy-like instructions are usually eliminated during register allocation. | ||||||||
1284 | case TargetOpcode::PHI: | ||||||||
1285 | case TargetOpcode::G_PHI: | ||||||||
1286 | case TargetOpcode::COPY: | ||||||||
1287 | case TargetOpcode::INSERT_SUBREG: | ||||||||
1288 | case TargetOpcode::SUBREG_TO_REG: | ||||||||
1289 | case TargetOpcode::REG_SEQUENCE: | ||||||||
1290 | return true; | ||||||||
1291 | } | ||||||||
1292 | } | ||||||||
1293 | |||||||||
1294 | /// Return the number of instructions inside the MI bundle, excluding the | ||||||||
1295 | /// bundle header. | ||||||||
1296 | /// | ||||||||
1297 | /// This is the number of instructions that MachineBasicBlock::iterator | ||||||||
1298 | /// skips, 0 for unbundled instructions. | ||||||||
1299 | unsigned getBundleSize() const; | ||||||||
1300 | |||||||||
1301 | /// Return true if the MachineInstr reads the specified register. | ||||||||
1302 | /// If TargetRegisterInfo is passed, then it also checks if there | ||||||||
1303 | /// is a read of a super-register. | ||||||||
1304 | /// This does not count partial redefines of virtual registers as reads: | ||||||||
1305 | /// %reg1024:6 = OP. | ||||||||
1306 | bool readsRegister(Register Reg, | ||||||||
1307 | const TargetRegisterInfo *TRI = nullptr) const { | ||||||||
1308 | return findRegisterUseOperandIdx(Reg, false, TRI) != -1; | ||||||||
1309 | } | ||||||||
1310 | |||||||||
1311 | /// Return true if the MachineInstr reads the specified virtual register. | ||||||||
1312 | /// Take into account that a partial define is a | ||||||||
1313 | /// read-modify-write operation. | ||||||||
1314 | bool readsVirtualRegister(Register Reg) const { | ||||||||
1315 | return readsWritesVirtualRegister(Reg).first; | ||||||||
1316 | } | ||||||||
1317 | |||||||||
1318 | /// Return a pair of bools (reads, writes) indicating if this instruction | ||||||||
1319 | /// reads or writes Reg. This also considers partial defines. | ||||||||
1320 | /// If Ops is not null, all operand indices for Reg are added. | ||||||||
1321 | std::pair<bool,bool> readsWritesVirtualRegister(Register Reg, | ||||||||
1322 | SmallVectorImpl<unsigned> *Ops = nullptr) const; | ||||||||
1323 | |||||||||
1324 | /// Return true if the MachineInstr kills the specified register. | ||||||||
1325 | /// If TargetRegisterInfo is passed, then it also checks if there is | ||||||||
1326 | /// a kill of a super-register. | ||||||||
1327 | bool killsRegister(Register Reg, | ||||||||
1328 | const TargetRegisterInfo *TRI = nullptr) const { | ||||||||
1329 | return findRegisterUseOperandIdx(Reg, true, TRI) != -1; | ||||||||
1330 | } | ||||||||
1331 | |||||||||
1332 | /// Return true if the MachineInstr fully defines the specified register. | ||||||||
1333 | /// If TargetRegisterInfo is passed, then it also checks | ||||||||
1334 | /// if there is a def of a super-register. | ||||||||
1335 | /// NOTE: It's ignoring subreg indices on virtual registers. | ||||||||
1336 | bool definesRegister(Register Reg, | ||||||||
1337 | const TargetRegisterInfo *TRI = nullptr) const { | ||||||||
1338 | return findRegisterDefOperandIdx(Reg, false, false, TRI) != -1; | ||||||||
1339 | } | ||||||||
1340 | |||||||||
1341 | /// Return true if the MachineInstr modifies (fully define or partially | ||||||||
1342 | /// define) the specified register. | ||||||||
1343 | /// NOTE: It's ignoring subreg indices on virtual registers. | ||||||||
1344 | bool modifiesRegister(Register Reg, | ||||||||
1345 | const TargetRegisterInfo *TRI = nullptr) const { | ||||||||
1346 | return findRegisterDefOperandIdx(Reg, false, true, TRI) != -1; | ||||||||
1347 | } | ||||||||
1348 | |||||||||
1349 | /// Returns true if the register is dead in this machine instruction. | ||||||||
1350 | /// If TargetRegisterInfo is passed, then it also checks | ||||||||
1351 | /// if there is a dead def of a super-register. | ||||||||
1352 | bool registerDefIsDead(Register Reg, | ||||||||
1353 | const TargetRegisterInfo *TRI = nullptr) const { | ||||||||
1354 | return findRegisterDefOperandIdx(Reg, true, false, TRI) != -1; | ||||||||
1355 | } | ||||||||
1356 | |||||||||
1357 | /// Returns true if the MachineInstr has an implicit-use operand of exactly | ||||||||
1358 | /// the given register (not considering sub/super-registers). | ||||||||
1359 | bool hasRegisterImplicitUseOperand(Register Reg) const; | ||||||||
1360 | |||||||||
1361 | /// Returns the operand index that is a use of the specific register or -1 | ||||||||
1362 | /// if it is not found. It further tightens the search criteria to a use | ||||||||
1363 | /// that kills the register if isKill is true. | ||||||||
1364 | int findRegisterUseOperandIdx(Register Reg, bool isKill = false, | ||||||||
1365 | const TargetRegisterInfo *TRI = nullptr) const; | ||||||||
1366 | |||||||||
1367 | /// Wrapper for findRegisterUseOperandIdx, it returns | ||||||||
1368 | /// a pointer to the MachineOperand rather than an index. | ||||||||
1369 | MachineOperand *findRegisterUseOperand(Register Reg, bool isKill = false, | ||||||||
1370 | const TargetRegisterInfo *TRI = nullptr) { | ||||||||
1371 | int Idx = findRegisterUseOperandIdx(Reg, isKill, TRI); | ||||||||
1372 | return (Idx == -1) ? nullptr : &getOperand(Idx); | ||||||||
1373 | } | ||||||||
1374 | |||||||||
1375 | const MachineOperand *findRegisterUseOperand( | ||||||||
1376 | Register Reg, bool isKill = false, | ||||||||
1377 | const TargetRegisterInfo *TRI = nullptr) const { | ||||||||
1378 | return const_cast<MachineInstr *>(this)-> | ||||||||
1379 | findRegisterUseOperand(Reg, isKill, TRI); | ||||||||
1380 | } | ||||||||
1381 | |||||||||
1382 | /// Returns the operand index that is a def of the specified register or | ||||||||
1383 | /// -1 if it is not found. If isDead is true, defs that are not dead are | ||||||||
1384 | /// skipped. If Overlap is true, then it also looks for defs that merely | ||||||||
1385 | /// overlap the specified register. If TargetRegisterInfo is non-null, | ||||||||
1386 | /// then it also checks if there is a def of a super-register. | ||||||||
1387 | /// This may also return a register mask operand when Overlap is true. | ||||||||
1388 | int findRegisterDefOperandIdx(Register Reg, | ||||||||
1389 | bool isDead = false, bool Overlap = false, | ||||||||
1390 | const TargetRegisterInfo *TRI = nullptr) const; | ||||||||
1391 | |||||||||
1392 | /// Wrapper for findRegisterDefOperandIdx, it returns | ||||||||
1393 | /// a pointer to the MachineOperand rather than an index. | ||||||||
1394 | MachineOperand * | ||||||||
1395 | findRegisterDefOperand(Register Reg, bool isDead = false, | ||||||||
1396 | bool Overlap = false, | ||||||||
1397 | const TargetRegisterInfo *TRI = nullptr) { | ||||||||
1398 | int Idx = findRegisterDefOperandIdx(Reg, isDead, Overlap, TRI); | ||||||||
1399 | return (Idx == -1) ? nullptr : &getOperand(Idx); | ||||||||
1400 | } | ||||||||
1401 | |||||||||
1402 | const MachineOperand * | ||||||||
1403 | findRegisterDefOperand(Register Reg, bool isDead = false, | ||||||||
1404 | bool Overlap = false, | ||||||||
1405 | const TargetRegisterInfo *TRI = nullptr) const { | ||||||||
1406 | return const_cast<MachineInstr *>(this)->findRegisterDefOperand( | ||||||||
1407 | Reg, isDead, Overlap, TRI); | ||||||||
1408 | } | ||||||||
1409 | |||||||||
1410 | /// Find the index of the first operand in the | ||||||||
1411 | /// operand list that is used to represent the predicate. It returns -1 if | ||||||||
1412 | /// none is found. | ||||||||
1413 | int findFirstPredOperandIdx() const; | ||||||||
1414 | |||||||||
1415 | /// Find the index of the flag word operand that | ||||||||
1416 | /// corresponds to operand OpIdx on an inline asm instruction. Returns -1 if | ||||||||
1417 | /// getOperand(OpIdx) does not belong to an inline asm operand group. | ||||||||
1418 | /// | ||||||||
1419 | /// If GroupNo is not NULL, it will receive the number of the operand group | ||||||||
1420 | /// containing OpIdx. | ||||||||
1421 | /// | ||||||||
1422 | /// The flag operand is an immediate that can be decoded with methods like | ||||||||
1423 | /// InlineAsm::hasRegClassConstraint(). | ||||||||
1424 | int findInlineAsmFlagIdx(unsigned OpIdx, unsigned *GroupNo = nullptr) const; | ||||||||
1425 | |||||||||
1426 | /// Compute the static register class constraint for operand OpIdx. | ||||||||
1427 | /// For normal instructions, this is derived from the MCInstrDesc. | ||||||||
1428 | /// For inline assembly it is derived from the flag words. | ||||||||
1429 | /// | ||||||||
1430 | /// Returns NULL if the static register class constraint cannot be | ||||||||
1431 | /// determined. | ||||||||
1432 | const TargetRegisterClass* | ||||||||
1433 | getRegClassConstraint(unsigned OpIdx, | ||||||||
1434 | const TargetInstrInfo *TII, | ||||||||
1435 | const TargetRegisterInfo *TRI) const; | ||||||||
1436 | |||||||||
1437 | /// Applies the constraints (def/use) implied by this MI on \p Reg to | ||||||||
1438 | /// the given \p CurRC. | ||||||||
1439 | /// If \p ExploreBundle is set and MI is part of a bundle, all the | ||||||||
1440 | /// instructions inside the bundle will be taken into account. In other words, | ||||||||
1441 | /// this method accumulates all the constraints of the operand of this MI and | ||||||||
1442 | /// the related bundle if MI is a bundle or inside a bundle. | ||||||||
1443 | /// | ||||||||
1444 | /// Returns the register class that satisfies both \p CurRC and the | ||||||||
1445 | /// constraints set by MI. Returns NULL if such a register class does not | ||||||||
1446 | /// exist. | ||||||||
1447 | /// | ||||||||
1448 | /// \pre CurRC must not be NULL. | ||||||||
1449 | const TargetRegisterClass *getRegClassConstraintEffectForVReg( | ||||||||
1450 | Register Reg, const TargetRegisterClass *CurRC, | ||||||||
1451 | const TargetInstrInfo *TII, const TargetRegisterInfo *TRI, | ||||||||
1452 | bool ExploreBundle = false) const; | ||||||||
1453 | |||||||||
1454 | /// Applies the constraints (def/use) implied by the \p OpIdx operand | ||||||||
1455 | /// to the given \p CurRC. | ||||||||
1456 | /// | ||||||||
1457 | /// Returns the register class that satisfies both \p CurRC and the | ||||||||
1458 | /// constraints set by \p OpIdx MI. Returns NULL if such a register class | ||||||||
1459 | /// does not exist. | ||||||||
1460 | /// | ||||||||
1461 | /// \pre CurRC must not be NULL. | ||||||||
1462 | /// \pre The operand at \p OpIdx must be a register. | ||||||||
1463 | const TargetRegisterClass * | ||||||||
1464 | getRegClassConstraintEffect(unsigned OpIdx, const TargetRegisterClass *CurRC, | ||||||||
1465 | const TargetInstrInfo *TII, | ||||||||
1466 | const TargetRegisterInfo *TRI) const; | ||||||||
1467 | |||||||||
1468 | /// Add a tie between the register operands at DefIdx and UseIdx. | ||||||||
1469 | /// The tie will cause the register allocator to ensure that the two | ||||||||
1470 | /// operands are assigned the same physical register. | ||||||||
1471 | /// | ||||||||
1472 | /// Tied operands are managed automatically for explicit operands in the | ||||||||
1473 | /// MCInstrDesc. This method is for exceptional cases like inline asm. | ||||||||
1474 | void tieOperands(unsigned DefIdx, unsigned UseIdx); | ||||||||
1475 | |||||||||
1476 | /// Given the index of a tied register operand, find the | ||||||||
1477 | /// operand it is tied to. Defs are tied to uses and vice versa. Returns the | ||||||||
1478 | /// index of the tied operand which must exist. | ||||||||
1479 | unsigned findTiedOperandIdx(unsigned OpIdx) const; | ||||||||
1480 | |||||||||
1481 | /// Given the index of a register def operand, | ||||||||
1482 | /// check if the register def is tied to a source operand, due to either | ||||||||
1483 | /// two-address elimination or inline assembly constraints. Returns the | ||||||||
1484 | /// first tied use operand index by reference if UseOpIdx is not null. | ||||||||
1485 | bool isRegTiedToUseOperand(unsigned DefOpIdx, | ||||||||
1486 | unsigned *UseOpIdx = nullptr) const { | ||||||||
1487 | const MachineOperand &MO = getOperand(DefOpIdx); | ||||||||
1488 | if (!MO.isReg() || !MO.isDef() || !MO.isTied()) | ||||||||
1489 | return false; | ||||||||
1490 | if (UseOpIdx) | ||||||||
1491 | *UseOpIdx = findTiedOperandIdx(DefOpIdx); | ||||||||
1492 | return true; | ||||||||
1493 | } | ||||||||
1494 | |||||||||
1495 | /// Return true if the use operand of the specified index is tied to a def | ||||||||
1496 | /// operand. It also returns the def operand index by reference if DefOpIdx | ||||||||
1497 | /// is not null. | ||||||||
1498 | bool isRegTiedToDefOperand(unsigned UseOpIdx, | ||||||||
1499 | unsigned *DefOpIdx = nullptr) const { | ||||||||
1500 | const MachineOperand &MO = getOperand(UseOpIdx); | ||||||||
1501 | if (!MO.isReg() || !MO.isUse() || !MO.isTied()) | ||||||||
1502 | return false; | ||||||||
1503 | if (DefOpIdx) | ||||||||
1504 | *DefOpIdx = findTiedOperandIdx(UseOpIdx); | ||||||||
1505 | return true; | ||||||||
1506 | } | ||||||||
1507 | |||||||||
1508 | /// Clears kill flags on all operands. | ||||||||
1509 | void clearKillInfo(); | ||||||||
1510 | |||||||||
1511 | /// Replace all occurrences of FromReg with ToReg:SubIdx, | ||||||||
1512 | /// properly composing subreg indices where necessary. | ||||||||
1513 | void substituteRegister(Register FromReg, Register ToReg, unsigned SubIdx, | ||||||||
1514 | const TargetRegisterInfo &RegInfo); | ||||||||
1515 | |||||||||
1516 | /// We have determined MI kills a register. Look for the | ||||||||
1517 | /// operand that uses it and mark it as IsKill. If AddIfNotFound is true, | ||||||||
1518 | /// add a implicit operand if it's not found. Returns true if the operand | ||||||||
1519 | /// exists / is added. | ||||||||
1520 | bool addRegisterKilled(Register IncomingReg, | ||||||||
1521 | const TargetRegisterInfo *RegInfo, | ||||||||
1522 | bool AddIfNotFound = false); | ||||||||
1523 | |||||||||
1524 | /// Clear all kill flags affecting Reg. If RegInfo is provided, this includes | ||||||||
1525 | /// all aliasing registers. | ||||||||
1526 | void clearRegisterKills(Register Reg, const TargetRegisterInfo *RegInfo); | ||||||||
1527 | |||||||||
1528 | /// We have determined MI defined a register without a use. | ||||||||
1529 | /// Look for the operand that defines it and mark it as IsDead. If | ||||||||
1530 | /// AddIfNotFound is true, add a implicit operand if it's not found. Returns | ||||||||
1531 | /// true if the operand exists / is added. | ||||||||
1532 | bool addRegisterDead(Register Reg, const TargetRegisterInfo *RegInfo, | ||||||||
1533 | bool AddIfNotFound = false); | ||||||||
1534 | |||||||||
1535 | /// Clear all dead flags on operands defining register @p Reg. | ||||||||
1536 | void clearRegisterDeads(Register Reg); | ||||||||
1537 | |||||||||
1538 | /// Mark all subregister defs of register @p Reg with the undef flag. | ||||||||
1539 | /// This function is used when we determined to have a subregister def in an | ||||||||
1540 | /// otherwise undefined super register. | ||||||||
1541 | void setRegisterDefReadUndef(Register Reg, bool IsUndef = true); | ||||||||
1542 | |||||||||
1543 | /// We have determined MI defines a register. Make sure there is an operand | ||||||||
1544 | /// defining Reg. | ||||||||
1545 | void addRegisterDefined(Register Reg, | ||||||||
1546 | const TargetRegisterInfo *RegInfo = nullptr); | ||||||||
1547 | |||||||||
1548 | /// Mark every physreg used by this instruction as | ||||||||
1549 | /// dead except those in the UsedRegs list. | ||||||||
1550 | /// | ||||||||
1551 | /// On instructions with register mask operands, also add implicit-def | ||||||||
1552 | /// operands for all registers in UsedRegs. | ||||||||
1553 | void setPhysRegsDeadExcept(ArrayRef<Register> UsedRegs, | ||||||||
1554 | const TargetRegisterInfo &TRI); | ||||||||
1555 | |||||||||
1556 | /// Return true if it is safe to move this instruction. If | ||||||||
1557 | /// SawStore is set to true, it means that there is a store (or call) between | ||||||||
1558 | /// the instruction's location and its intended destination. | ||||||||
1559 | bool isSafeToMove(AAResults *AA, bool &SawStore) const; | ||||||||
1560 | |||||||||
1561 | /// Returns true if this instruction's memory access aliases the memory | ||||||||
1562 | /// access of Other. | ||||||||
1563 | // | ||||||||
1564 | /// Assumes any physical registers used to compute addresses | ||||||||
1565 | /// have the same value for both instructions. Returns false if neither | ||||||||
1566 | /// instruction writes to memory. | ||||||||
1567 | /// | ||||||||
1568 | /// @param AA Optional alias analysis, used to compare memory operands. | ||||||||
1569 | /// @param Other MachineInstr to check aliasing against. | ||||||||
1570 | /// @param UseTBAA Whether to pass TBAA information to alias analysis. | ||||||||
1571 | bool mayAlias(AAResults *AA, const MachineInstr &Other, bool UseTBAA) const; | ||||||||
1572 | |||||||||
1573 | /// Return true if this instruction may have an ordered | ||||||||
1574 | /// or volatile memory reference, or if the information describing the memory | ||||||||
1575 | /// reference is not available. Return false if it is known to have no | ||||||||
1576 | /// ordered or volatile memory references. | ||||||||
1577 | bool hasOrderedMemoryRef() const; | ||||||||
1578 | |||||||||
1579 | /// Return true if this load instruction never traps and points to a memory | ||||||||
1580 | /// location whose value doesn't change during the execution of this function. | ||||||||
1581 | /// | ||||||||
1582 | /// Examples include loading a value from the constant pool or from the | ||||||||
1583 | /// argument area of a function (if it does not change). If the instruction | ||||||||
1584 | /// does multiple loads, this returns true only if all of the loads are | ||||||||
1585 | /// dereferenceable and invariant. | ||||||||
1586 | bool isDereferenceableInvariantLoad(AAResults *AA) const; | ||||||||
1587 | |||||||||
1588 | /// If the specified instruction is a PHI that always merges together the | ||||||||
1589 | /// same virtual register, return the register, otherwise return 0. | ||||||||
1590 | unsigned isConstantValuePHI() const; | ||||||||
1591 | |||||||||
1592 | /// Return true if this instruction has side effects that are not modeled | ||||||||
1593 | /// by mayLoad / mayStore, etc. | ||||||||
1594 | /// For all instructions, the property is encoded in MCInstrDesc::Flags | ||||||||
1595 | /// (see MCInstrDesc::hasUnmodeledSideEffects(). The only exception is | ||||||||
1596 | /// INLINEASM instruction, in which case the side effect property is encoded | ||||||||
1597 | /// in one of its operands (see InlineAsm::Extra_HasSideEffect). | ||||||||
1598 | /// | ||||||||
1599 | bool hasUnmodeledSideEffects() const; | ||||||||
1600 | |||||||||
1601 | /// Returns true if it is illegal to fold a load across this instruction. | ||||||||
1602 | bool isLoadFoldBarrier() const; | ||||||||
1603 | |||||||||
1604 | /// Return true if all the defs of this instruction are dead. | ||||||||
1605 | bool allDefsAreDead() const; | ||||||||
1606 | |||||||||
1607 | /// Return a valid size if the instruction is a spill instruction. | ||||||||
1608 | Optional<unsigned> getSpillSize(const TargetInstrInfo *TII) const; | ||||||||
1609 | |||||||||
1610 | /// Return a valid size if the instruction is a folded spill instruction. | ||||||||
1611 | Optional<unsigned> getFoldedSpillSize(const TargetInstrInfo *TII) const; | ||||||||
1612 | |||||||||
1613 | /// Return a valid size if the instruction is a restore instruction. | ||||||||
1614 | Optional<unsigned> getRestoreSize(const TargetInstrInfo *TII) const; | ||||||||
1615 | |||||||||
1616 | /// Return a valid size if the instruction is a folded restore instruction. | ||||||||
1617 | Optional<unsigned> | ||||||||
1618 | getFoldedRestoreSize(const TargetInstrInfo *TII) const; | ||||||||
1619 | |||||||||
1620 | /// Copy implicit register operands from specified | ||||||||
1621 | /// instruction to this instruction. | ||||||||
1622 | void copyImplicitOps(MachineFunction &MF, const MachineInstr &MI); | ||||||||
1623 | |||||||||
1624 | /// Debugging support | ||||||||
1625 | /// @{ | ||||||||
1626 | /// Determine the generic type to be printed (if needed) on uses and defs. | ||||||||
1627 | LLT getTypeToPrint(unsigned OpIdx, SmallBitVector &PrintedTypes, | ||||||||
1628 | const MachineRegisterInfo &MRI) const; | ||||||||
1629 | |||||||||
1630 | /// Return true when an instruction has tied register that can't be determined | ||||||||
1631 | /// by the instruction's descriptor. This is useful for MIR printing, to | ||||||||
1632 | /// determine whether we need to print the ties or not. | ||||||||
1633 | bool hasComplexRegisterTies() const; | ||||||||
1634 | |||||||||
1635 | /// Print this MI to \p OS. | ||||||||
1636 | /// Don't print information that can be inferred from other instructions if | ||||||||
1637 | /// \p IsStandalone is false. It is usually true when only a fragment of the | ||||||||
1638 | /// function is printed. | ||||||||
1639 | /// Only print the defs and the opcode if \p SkipOpers is true. | ||||||||
1640 | /// Otherwise, also print operands if \p SkipDebugLoc is true. | ||||||||
1641 | /// Otherwise, also print the debug loc, with a terminating newline. | ||||||||
1642 | /// \p TII is used to print the opcode name. If it's not present, but the | ||||||||
1643 | /// MI is in a function, the opcode will be printed using the function's TII. | ||||||||
1644 | void print(raw_ostream &OS, bool IsStandalone = true, bool SkipOpers = false, | ||||||||
1645 | bool SkipDebugLoc = false, bool AddNewLine = true, | ||||||||
1646 | const TargetInstrInfo *TII = nullptr) const; | ||||||||
1647 | void print(raw_ostream &OS, ModuleSlotTracker &MST, bool IsStandalone = true, | ||||||||
1648 | bool SkipOpers = false, bool SkipDebugLoc = false, | ||||||||
1649 | bool AddNewLine = true, | ||||||||
1650 | const TargetInstrInfo *TII = nullptr) const; | ||||||||
1651 | void dump() const; | ||||||||
1652 | /// Print on dbgs() the current instruction and the instructions defining its | ||||||||
1653 | /// operands and so on until we reach \p MaxDepth. | ||||||||
1654 | void dumpr(const MachineRegisterInfo &MRI, | ||||||||
1655 | unsigned MaxDepth = UINT_MAX(2147483647 *2U +1U)) const; | ||||||||
1656 | /// @} | ||||||||
1657 | |||||||||
1658 | //===--------------------------------------------------------------------===// | ||||||||
1659 | // Accessors used to build up machine instructions. | ||||||||
1660 | |||||||||
1661 | /// Add the specified operand to the instruction. If it is an implicit | ||||||||
1662 | /// operand, it is added to the end of the operand list. If it is an | ||||||||
1663 | /// explicit operand it is added at the end of the explicit operand list | ||||||||
1664 | /// (before the first implicit operand). | ||||||||
1665 | /// | ||||||||
1666 | /// MF must be the machine function that was used to allocate this | ||||||||
1667 | /// instruction. | ||||||||
1668 | /// | ||||||||
1669 | /// MachineInstrBuilder provides a more convenient interface for creating | ||||||||
1670 | /// instructions and adding operands. | ||||||||
1671 | void addOperand(MachineFunction &MF, const MachineOperand &Op); | ||||||||
1672 | |||||||||
1673 | /// Add an operand without providing an MF reference. This only works for | ||||||||
1674 | /// instructions that are inserted in a basic block. | ||||||||
1675 | /// | ||||||||
1676 | /// MachineInstrBuilder and the two-argument addOperand(MF, MO) should be | ||||||||
1677 | /// preferred. | ||||||||
1678 | void addOperand(const MachineOperand &Op); | ||||||||
1679 | |||||||||
1680 | /// Replace the instruction descriptor (thus opcode) of | ||||||||
1681 | /// the current instruction with a new one. | ||||||||
1682 | void setDesc(const MCInstrDesc &tid) { MCID = &tid; } | ||||||||
1683 | |||||||||
1684 | /// Replace current source information with new such. | ||||||||
1685 | /// Avoid using this, the constructor argument is preferable. | ||||||||
1686 | void setDebugLoc(DebugLoc dl) { | ||||||||
1687 | debugLoc = std::move(dl); | ||||||||
1688 | assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor")((debugLoc.hasTrivialDestructor() && "Expected trivial destructor" ) ? static_cast<void> (0) : __assert_fail ("debugLoc.hasTrivialDestructor() && \"Expected trivial destructor\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 1688, __PRETTY_FUNCTION__)); | ||||||||
1689 | } | ||||||||
1690 | |||||||||
1691 | /// Erase an operand from an instruction, leaving it with one | ||||||||
1692 | /// fewer operand than it started with. | ||||||||
1693 | void RemoveOperand(unsigned OpNo); | ||||||||
1694 | |||||||||
1695 | /// Clear this MachineInstr's memory reference descriptor list. This resets | ||||||||
1696 | /// the memrefs to their most conservative state. This should be used only | ||||||||
1697 | /// as a last resort since it greatly pessimizes our knowledge of the memory | ||||||||
1698 | /// access performed by the instruction. | ||||||||
1699 | void dropMemRefs(MachineFunction &MF); | ||||||||
1700 | |||||||||
1701 | /// Assign this MachineInstr's memory reference descriptor list. | ||||||||
1702 | /// | ||||||||
1703 | /// Unlike other methods, this *will* allocate them into a new array | ||||||||
1704 | /// associated with the provided `MachineFunction`. | ||||||||
1705 | void setMemRefs(MachineFunction &MF, ArrayRef<MachineMemOperand *> MemRefs); | ||||||||
1706 | |||||||||
1707 | /// Add a MachineMemOperand to the machine instruction. | ||||||||
1708 | /// This function should be used only occasionally. The setMemRefs function | ||||||||
1709 | /// is the primary method for setting up a MachineInstr's MemRefs list. | ||||||||
1710 | void addMemOperand(MachineFunction &MF, MachineMemOperand *MO); | ||||||||
1711 | |||||||||
1712 | /// Clone another MachineInstr's memory reference descriptor list and replace | ||||||||
1713 | /// ours with it. | ||||||||
1714 | /// | ||||||||
1715 | /// Note that `*this` may be the incoming MI! | ||||||||
1716 | /// | ||||||||
1717 | /// Prefer this API whenever possible as it can avoid allocations in common | ||||||||
1718 | /// cases. | ||||||||
1719 | void cloneMemRefs(MachineFunction &MF, const MachineInstr &MI); | ||||||||
1720 | |||||||||
1721 | /// Clone the merge of multiple MachineInstrs' memory reference descriptors | ||||||||
1722 | /// list and replace ours with it. | ||||||||
1723 | /// | ||||||||
1724 | /// Note that `*this` may be one of the incoming MIs! | ||||||||
1725 | /// | ||||||||
1726 | /// Prefer this API whenever possible as it can avoid allocations in common | ||||||||
1727 | /// cases. | ||||||||
1728 | void cloneMergedMemRefs(MachineFunction &MF, | ||||||||
1729 | ArrayRef<const MachineInstr *> MIs); | ||||||||
1730 | |||||||||
1731 | /// Set a symbol that will be emitted just prior to the instruction itself. | ||||||||
1732 | /// | ||||||||
1733 | /// Setting this to a null pointer will remove any such symbol. | ||||||||
1734 | /// | ||||||||
1735 | /// FIXME: This is not fully implemented yet. | ||||||||
1736 | void setPreInstrSymbol(MachineFunction &MF, MCSymbol *Symbol); | ||||||||
1737 | |||||||||
1738 | /// Set a symbol that will be emitted just after the instruction itself. | ||||||||
1739 | /// | ||||||||
1740 | /// Setting this to a null pointer will remove any such symbol. | ||||||||
1741 | /// | ||||||||
1742 | /// FIXME: This is not fully implemented yet. | ||||||||
1743 | void setPostInstrSymbol(MachineFunction &MF, MCSymbol *Symbol); | ||||||||
1744 | |||||||||
1745 | /// Clone another MachineInstr's pre- and post- instruction symbols and | ||||||||
1746 | /// replace ours with it. | ||||||||
1747 | void cloneInstrSymbols(MachineFunction &MF, const MachineInstr &MI); | ||||||||
1748 | |||||||||
1749 | /// Set a marker on instructions that denotes where we should create and emit | ||||||||
1750 | /// heap alloc site labels. This waits until after instruction selection and | ||||||||
1751 | /// optimizations to create the label, so it should still work if the | ||||||||
1752 | /// instruction is removed or duplicated. | ||||||||
1753 | void setHeapAllocMarker(MachineFunction &MF, MDNode *MD); | ||||||||
1754 | |||||||||
1755 | /// Return the MIFlags which represent both MachineInstrs. This | ||||||||
1756 | /// should be used when merging two MachineInstrs into one. This routine does | ||||||||
1757 | /// not modify the MIFlags of this MachineInstr. | ||||||||
1758 | uint16_t mergeFlagsWith(const MachineInstr& Other) const; | ||||||||
1759 | |||||||||
1760 | static uint16_t copyFlagsFromInstruction(const Instruction &I); | ||||||||
1761 | |||||||||
1762 | /// Copy all flags to MachineInst MIFlags | ||||||||
1763 | void copyIRFlags(const Instruction &I); | ||||||||
1764 | |||||||||
1765 | /// Break any tie involving OpIdx. | ||||||||
1766 | void untieRegOperand(unsigned OpIdx) { | ||||||||
1767 | MachineOperand &MO = getOperand(OpIdx); | ||||||||
1768 | if (MO.isReg() && MO.isTied()) { | ||||||||
1769 | getOperand(findTiedOperandIdx(OpIdx)).TiedTo = 0; | ||||||||
1770 | MO.TiedTo = 0; | ||||||||
1771 | } | ||||||||
1772 | } | ||||||||
1773 | |||||||||
1774 | /// Add all implicit def and use operands to this instruction. | ||||||||
1775 | void addImplicitDefUseOperands(MachineFunction &MF); | ||||||||
1776 | |||||||||
1777 | /// Scan instructions immediately following MI and collect any matching | ||||||||
1778 | /// DBG_VALUEs. | ||||||||
1779 | void collectDebugValues(SmallVectorImpl<MachineInstr *> &DbgValues); | ||||||||
1780 | |||||||||
1781 | /// Find all DBG_VALUEs that point to the register def in this instruction | ||||||||
1782 | /// and point them to \p Reg instead. | ||||||||
1783 | void changeDebugValuesDefReg(Register Reg); | ||||||||
1784 | |||||||||
1785 | /// Returns the Intrinsic::ID for this instruction. | ||||||||
1786 | /// \pre Must have an intrinsic ID operand. | ||||||||
1787 | unsigned getIntrinsicID() const { | ||||||||
1788 | return getOperand(getNumExplicitDefs()).getIntrinsicID(); | ||||||||
1789 | } | ||||||||
1790 | |||||||||
1791 | /// Sets all register debug operands in this debug value instruction to be | ||||||||
1792 | /// undef. | ||||||||
1793 | void setDebugValueUndef() { | ||||||||
1794 | assert(isDebugValue() && "Must be a debug value instruction.")((isDebugValue() && "Must be a debug value instruction." ) ? static_cast<void> (0) : __assert_fail ("isDebugValue() && \"Must be a debug value instruction.\"" , "/build/llvm-toolchain-snapshot-13~++20210216111115+df22133a8a40/llvm/include/llvm/CodeGen/MachineInstr.h" , 1794, __PRETTY_FUNCTION__)); | ||||||||
1795 | for (MachineOperand &MO : debug_operands()) { | ||||||||
1796 | if (MO.isReg()) { | ||||||||
1797 | MO.setReg(0); | ||||||||
1798 | MO.setSubReg(0); | ||||||||
1799 | } | ||||||||
1800 | } | ||||||||
1801 | } | ||||||||
1802 | |||||||||
1803 | private: | ||||||||
1804 | /// If this instruction is embedded into a MachineFunction, return the | ||||||||
1805 | /// MachineRegisterInfo object for the current function, otherwise | ||||||||
1806 | /// return null. | ||||||||
1807 | MachineRegisterInfo *getRegInfo(); | ||||||||
1808 | |||||||||
1809 | /// Unlink all of the register operands in this instruction from their | ||||||||
1810 | /// respective use lists. This requires that the operands already be on their | ||||||||
1811 | /// use lists. | ||||||||
1812 | void RemoveRegOperandsFromUseLists(MachineRegisterInfo&); | ||||||||
1813 | |||||||||
1814 | /// Add all of the register operands in this instruction from their | ||||||||
1815 | /// respective use lists. This requires that the operands not be on their | ||||||||
1816 | /// use lists yet. | ||||||||
1817 | void AddRegOperandsToUseLists(MachineRegisterInfo&); | ||||||||
1818 | |||||||||
1819 | /// Slow path for hasProperty when we're dealing with a bundle. | ||||||||
1820 | bool hasPropertyInBundle(uint64_t Mask, QueryType Type) const; | ||||||||
1821 | |||||||||
1822 | /// Implements the logic of getRegClassConstraintEffectForVReg for the | ||||||||
1823 | /// this MI and the given operand index \p OpIdx. | ||||||||
1824 | /// If the related operand does not constrained Reg, this returns CurRC. | ||||||||
1825 | const TargetRegisterClass *getRegClassConstraintEffectForVRegImpl( | ||||||||
1826 | unsigned OpIdx, Register Reg, const TargetRegisterClass *CurRC, | ||||||||
1827 | const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const; | ||||||||
1828 | |||||||||
1829 | /// Stores extra instruction information inline or allocates as ExtraInfo | ||||||||
1830 | /// based on the number of pointers. | ||||||||
1831 | void setExtraInfo(MachineFunction &MF, ArrayRef<MachineMemOperand *> MMOs, | ||||||||
1832 | MCSymbol *PreInstrSymbol, MCSymbol *PostInstrSymbol, | ||||||||
1833 | MDNode *HeapAllocMarker); | ||||||||
1834 | }; | ||||||||
1835 | |||||||||
1836 | /// Special DenseMapInfo traits to compare MachineInstr* by *value* of the | ||||||||
1837 | /// instruction rather than by pointer value. | ||||||||
1838 | /// The hashing and equality testing functions ignore definitions so this is | ||||||||
1839 | /// useful for CSE, etc. | ||||||||
1840 | struct MachineInstrExpressionTrait : DenseMapInfo<MachineInstr*> { | ||||||||
1841 | static inline MachineInstr *getEmptyKey() { | ||||||||
1842 | return nullptr; | ||||||||
1843 | } | ||||||||
1844 | |||||||||
1845 | static inline MachineInstr *getTombstoneKey() { | ||||||||
1846 | return reinterpret_cast<MachineInstr*>(-1); | ||||||||
1847 | } | ||||||||
1848 | |||||||||
1849 | static unsigned getHashValue(const MachineInstr* const &MI); | ||||||||
1850 | |||||||||
1851 | static bool isEqual(const MachineInstr* const &LHS, | ||||||||
1852 | const MachineInstr* const &RHS) { | ||||||||
1853 | if (RHS == getEmptyKey() || RHS == getTombstoneKey() || | ||||||||
1854 | LHS == getEmptyKey() || LHS == getTombstoneKey()) | ||||||||
1855 | return LHS == RHS; | ||||||||
1856 | return LHS->isIdenticalTo(*RHS, MachineInstr::IgnoreVRegDefs); | ||||||||
1857 | } | ||||||||
1858 | }; | ||||||||
1859 | |||||||||
1860 | //===----------------------------------------------------------------------===// | ||||||||
1861 | // Debugging Support | ||||||||
1862 | |||||||||
1863 | inline raw_ostream& operator<<(raw_ostream &OS, const MachineInstr &MI) { | ||||||||
1864 | MI.print(OS); | ||||||||
1865 | return OS; | ||||||||
1866 | } | ||||||||
1867 | |||||||||
1868 | } // end namespace llvm | ||||||||
1869 | |||||||||
1870 | #endif // LLVM_CODEGEN_MACHINEINSTR_H |