Bug Summary

File:llvm/include/llvm/CodeGen/MachineInstrBuilder.h
Warning:line 216, column 5
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name HexagonOptAddrMode.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/lib/Target/Hexagon -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/lib/Target/Hexagon -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-12-09-002921-48462-1 -x c++ /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp

/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp

1//===- HexagonOptAddrMode.cpp ---------------------------------------------===//
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// This implements a Hexagon-specific pass to optimize addressing mode for
9// load/store instructions.
10//===----------------------------------------------------------------------===//
11
12#include "HexagonInstrInfo.h"
13#include "HexagonSubtarget.h"
14#include "MCTargetDesc/HexagonBaseInfo.h"
15#include "RDFGraph.h"
16#include "RDFLiveness.h"
17#include "RDFRegisters.h"
18#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/DenseSet.h"
20#include "llvm/ADT/StringRef.h"
21#include "llvm/CodeGen/MachineBasicBlock.h"
22#include "llvm/CodeGen/MachineDominanceFrontier.h"
23#include "llvm/CodeGen/MachineDominators.h"
24#include "llvm/CodeGen/MachineFunction.h"
25#include "llvm/CodeGen/MachineFunctionPass.h"
26#include "llvm/CodeGen/MachineInstr.h"
27#include "llvm/CodeGen/MachineInstrBuilder.h"
28#include "llvm/CodeGen/MachineOperand.h"
29#include "llvm/CodeGen/MachineRegisterInfo.h"
30#include "llvm/CodeGen/TargetSubtargetInfo.h"
31#include "llvm/MC/MCInstrDesc.h"
32#include "llvm/Pass.h"
33#include "llvm/Support/CommandLine.h"
34#include "llvm/Support/Debug.h"
35#include "llvm/Support/ErrorHandling.h"
36#include "llvm/Support/raw_ostream.h"
37#include <cassert>
38#include <cstdint>
39
40#define DEBUG_TYPE"opt-addr-mode" "opt-addr-mode"
41
42using namespace llvm;
43using namespace rdf;
44
45static cl::opt<int> CodeGrowthLimit("hexagon-amode-growth-limit",
46 cl::Hidden, cl::init(0), cl::desc("Code growth limit for address mode "
47 "optimization"));
48
49namespace llvm {
50
51 FunctionPass *createHexagonOptAddrMode();
52 void initializeHexagonOptAddrModePass(PassRegistry&);
53
54} // end namespace llvm
55
56namespace {
57
58class HexagonOptAddrMode : public MachineFunctionPass {
59public:
60 static char ID;
61
62 HexagonOptAddrMode() : MachineFunctionPass(ID) {}
63
64 StringRef getPassName() const override {
65 return "Optimize addressing mode of load/store";
66 }
67
68 void getAnalysisUsage(AnalysisUsage &AU) const override {
69 MachineFunctionPass::getAnalysisUsage(AU);
70 AU.addRequired<MachineDominatorTree>();
71 AU.addRequired<MachineDominanceFrontier>();
72 AU.setPreservesAll();
73 }
74
75 bool runOnMachineFunction(MachineFunction &MF) override;
76
77private:
78 using MISetType = DenseSet<MachineInstr *>;
79 using InstrEvalMap = DenseMap<MachineInstr *, bool>;
80
81 MachineRegisterInfo *MRI = nullptr;
82 const HexagonInstrInfo *HII = nullptr;
83 const HexagonRegisterInfo *HRI = nullptr;
84 MachineDominatorTree *MDT = nullptr;
85 DataFlowGraph *DFG = nullptr;
86 DataFlowGraph::DefStackMap DefM;
87 Liveness *LV = nullptr;
88 MISetType Deleted;
89
90 bool processBlock(NodeAddr<BlockNode *> BA);
91 bool xformUseMI(MachineInstr *TfrMI, MachineInstr *UseMI,
92 NodeAddr<UseNode *> UseN, unsigned UseMOnum);
93 bool processAddUses(NodeAddr<StmtNode *> AddSN, MachineInstr *AddMI,
94 const NodeList &UNodeList);
95 bool updateAddUses(MachineInstr *AddMI, MachineInstr *UseMI);
96 bool analyzeUses(unsigned DefR, const NodeList &UNodeList,
97 InstrEvalMap &InstrEvalResult, short &SizeInc);
98 bool hasRepForm(MachineInstr &MI, unsigned TfrDefR);
99 bool canRemoveAddasl(NodeAddr<StmtNode *> AddAslSN, MachineInstr &MI,
100 const NodeList &UNodeList);
101 bool isSafeToExtLR(NodeAddr<StmtNode *> SN, MachineInstr *MI,
102 unsigned LRExtReg, const NodeList &UNodeList);
103 void getAllRealUses(NodeAddr<StmtNode *> SN, NodeList &UNodeList);
104 bool allValidCandidates(NodeAddr<StmtNode *> SA, NodeList &UNodeList);
105 short getBaseWithLongOffset(const MachineInstr &MI) const;
106 bool changeStore(MachineInstr *OldMI, MachineOperand ImmOp,
107 unsigned ImmOpNum);
108 bool changeLoad(MachineInstr *OldMI, MachineOperand ImmOp, unsigned ImmOpNum);
109 bool changeAddAsl(NodeAddr<UseNode *> AddAslUN, MachineInstr *AddAslMI,
110 const MachineOperand &ImmOp, unsigned ImmOpNum);
111 bool isValidOffset(MachineInstr *MI, int Offset);
112};
113
114} // end anonymous namespace
115
116char HexagonOptAddrMode::ID = 0;
117
118INITIALIZE_PASS_BEGIN(HexagonOptAddrMode, "amode-opt",static void *initializeHexagonOptAddrModePassOnce(PassRegistry
&Registry) {
119 "Optimize addressing mode", false, false)static void *initializeHexagonOptAddrModePassOnce(PassRegistry
&Registry) {
120INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)initializeMachineDominatorTreePass(Registry);
121INITIALIZE_PASS_DEPENDENCY(MachineDominanceFrontier)initializeMachineDominanceFrontierPass(Registry);
122INITIALIZE_PASS_END(HexagonOptAddrMode, "amode-opt", "Optimize addressing mode",PassInfo *PI = new PassInfo( "Optimize addressing mode", "amode-opt"
, &HexagonOptAddrMode::ID, PassInfo::NormalCtor_t(callDefaultCtor
<HexagonOptAddrMode>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeHexagonOptAddrModePassFlag
; void llvm::initializeHexagonOptAddrModePass(PassRegistry &
Registry) { llvm::call_once(InitializeHexagonOptAddrModePassFlag
, initializeHexagonOptAddrModePassOnce, std::ref(Registry)); }
123 false, false)PassInfo *PI = new PassInfo( "Optimize addressing mode", "amode-opt"
, &HexagonOptAddrMode::ID, PassInfo::NormalCtor_t(callDefaultCtor
<HexagonOptAddrMode>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeHexagonOptAddrModePassFlag
; void llvm::initializeHexagonOptAddrModePass(PassRegistry &
Registry) { llvm::call_once(InitializeHexagonOptAddrModePassFlag
, initializeHexagonOptAddrModePassOnce, std::ref(Registry)); }
124
125bool HexagonOptAddrMode::hasRepForm(MachineInstr &MI, unsigned TfrDefR) {
126 const MCInstrDesc &MID = MI.getDesc();
127
128 if ((!MID.mayStore() && !MID.mayLoad()) || HII->isPredicated(MI))
129 return false;
130
131 if (MID.mayStore()) {
132 MachineOperand StOp = MI.getOperand(MI.getNumOperands() - 1);
133 if (StOp.isReg() && StOp.getReg() == TfrDefR)
134 return false;
135 }
136
137 if (HII->getAddrMode(MI) == HexagonII::BaseRegOffset)
138 // Tranform to Absolute plus register offset.
139 return (HII->changeAddrMode_rr_ur(MI) >= 0);
140 else if (HII->getAddrMode(MI) == HexagonII::BaseImmOffset)
141 // Tranform to absolute addressing mode.
142 return (HII->changeAddrMode_io_abs(MI) >= 0);
143
144 return false;
145}
146
147// Check if addasl instruction can be removed. This is possible only
148// if it's feeding to only load/store instructions with base + register
149// offset as these instruction can be tranformed to use 'absolute plus
150// shifted register offset'.
151// ex:
152// Rs = ##foo
153// Rx = addasl(Rs, Rt, #2)
154// Rd = memw(Rx + #28)
155// Above three instructions can be replaced with Rd = memw(Rt<<#2 + ##foo+28)
156
157bool HexagonOptAddrMode::canRemoveAddasl(NodeAddr<StmtNode *> AddAslSN,
158 MachineInstr &MI,
159 const NodeList &UNodeList) {
160 // check offset size in addasl. if 'offset > 3' return false
161 const MachineOperand &OffsetOp = MI.getOperand(3);
162 if (!OffsetOp.isImm() || OffsetOp.getImm() > 3)
163 return false;
164
165 Register OffsetReg = MI.getOperand(2).getReg();
166 RegisterRef OffsetRR;
167 NodeId OffsetRegRD = 0;
168 for (NodeAddr<UseNode *> UA : AddAslSN.Addr->members_if(DFG->IsUse, *DFG)) {
169 RegisterRef RR = UA.Addr->getRegRef(*DFG);
170 if (OffsetReg == RR.Reg) {
171 OffsetRR = RR;
172 OffsetRegRD = UA.Addr->getReachingDef();
173 }
174 }
175
176 for (auto I = UNodeList.rbegin(), E = UNodeList.rend(); I != E; ++I) {
177 NodeAddr<UseNode *> UA = *I;
178 NodeAddr<InstrNode *> IA = UA.Addr->getOwner(*DFG);
179 if (UA.Addr->getFlags() & NodeAttrs::PhiRef)
180 return false;
181 NodeAddr<RefNode*> AA = LV->getNearestAliasedRef(OffsetRR, IA);
182 if ((DFG->IsDef(AA) && AA.Id != OffsetRegRD) ||
183 AA.Addr->getReachingDef() != OffsetRegRD)
184 return false;
185
186 MachineInstr &UseMI = *NodeAddr<StmtNode *>(IA).Addr->getCode();
187 NodeAddr<DefNode *> OffsetRegDN = DFG->addr<DefNode *>(OffsetRegRD);
188 // Reaching Def to an offset register can't be a phi.
189 if ((OffsetRegDN.Addr->getFlags() & NodeAttrs::PhiRef) &&
190 MI.getParent() != UseMI.getParent())
191 return false;
192
193 const MCInstrDesc &UseMID = UseMI.getDesc();
194 if ((!UseMID.mayLoad() && !UseMID.mayStore()) ||
195 HII->getAddrMode(UseMI) != HexagonII::BaseImmOffset ||
196 getBaseWithLongOffset(UseMI) < 0)
197 return false;
198
199 // Addasl output can't be a store value.
200 if (UseMID.mayStore() && UseMI.getOperand(2).isReg() &&
201 UseMI.getOperand(2).getReg() == MI.getOperand(0).getReg())
202 return false;
203
204 for (auto &Mo : UseMI.operands())
205 if (Mo.isFI())
206 return false;
207 }
208 return true;
209}
210
211bool HexagonOptAddrMode::allValidCandidates(NodeAddr<StmtNode *> SA,
212 NodeList &UNodeList) {
213 for (auto I = UNodeList.rbegin(), E = UNodeList.rend(); I != E; ++I) {
214 NodeAddr<UseNode *> UN = *I;
215 RegisterRef UR = UN.Addr->getRegRef(*DFG);
216 NodeSet Visited, Defs;
217 const auto &P = LV->getAllReachingDefsRec(UR, UN, Visited, Defs);
218 if (!P.second) {
219 LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Unable to collect all reaching defs for use ***\n"
<< PrintNode<UseNode*>(UN, *DFG) << '\n' <<
"The program's complexity may exceed the limits.\n"; }; } } while
(false)
220 dbgs() << "*** Unable to collect all reaching defs for use ***\n"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Unable to collect all reaching defs for use ***\n"
<< PrintNode<UseNode*>(UN, *DFG) << '\n' <<
"The program's complexity may exceed the limits.\n"; }; } } while
(false)
221 << PrintNode<UseNode*>(UN, *DFG) << '\n'do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Unable to collect all reaching defs for use ***\n"
<< PrintNode<UseNode*>(UN, *DFG) << '\n' <<
"The program's complexity may exceed the limits.\n"; }; } } while
(false)
222 << "The program's complexity may exceed the limits.\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Unable to collect all reaching defs for use ***\n"
<< PrintNode<UseNode*>(UN, *DFG) << '\n' <<
"The program's complexity may exceed the limits.\n"; }; } } while
(false)
223 })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Unable to collect all reaching defs for use ***\n"
<< PrintNode<UseNode*>(UN, *DFG) << '\n' <<
"The program's complexity may exceed the limits.\n"; }; } } while
(false)
;
224 return false;
225 }
226 const auto &ReachingDefs = P.first;
227 if (ReachingDefs.size() > 1) {
228 LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Multiple Reaching Defs found!!! ***\n"
; for (auto DI : ReachingDefs) { NodeAddr<UseNode *> DA
= DFG->addr<UseNode *>(DI); NodeAddr<StmtNode *>
TempIA = DA.Addr->getOwner(*DFG); dbgs() << "\t\t[Reaching Def]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; } }; } } while (false)
229 dbgs() << "*** Multiple Reaching Defs found!!! ***\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Multiple Reaching Defs found!!! ***\n"
; for (auto DI : ReachingDefs) { NodeAddr<UseNode *> DA
= DFG->addr<UseNode *>(DI); NodeAddr<StmtNode *>
TempIA = DA.Addr->getOwner(*DFG); dbgs() << "\t\t[Reaching Def]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; } }; } } while (false)
230 for (auto DI : ReachingDefs) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Multiple Reaching Defs found!!! ***\n"
; for (auto DI : ReachingDefs) { NodeAddr<UseNode *> DA
= DFG->addr<UseNode *>(DI); NodeAddr<StmtNode *>
TempIA = DA.Addr->getOwner(*DFG); dbgs() << "\t\t[Reaching Def]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; } }; } } while (false)
231 NodeAddr<UseNode *> DA = DFG->addr<UseNode *>(DI);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Multiple Reaching Defs found!!! ***\n"
; for (auto DI : ReachingDefs) { NodeAddr<UseNode *> DA
= DFG->addr<UseNode *>(DI); NodeAddr<StmtNode *>
TempIA = DA.Addr->getOwner(*DFG); dbgs() << "\t\t[Reaching Def]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; } }; } } while (false)
232 NodeAddr<StmtNode *> TempIA = DA.Addr->getOwner(*DFG);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Multiple Reaching Defs found!!! ***\n"
; for (auto DI : ReachingDefs) { NodeAddr<UseNode *> DA
= DFG->addr<UseNode *>(DI); NodeAddr<StmtNode *>
TempIA = DA.Addr->getOwner(*DFG); dbgs() << "\t\t[Reaching Def]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; } }; } } while (false)
233 dbgs() << "\t\t[Reaching Def]: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Multiple Reaching Defs found!!! ***\n"
; for (auto DI : ReachingDefs) { NodeAddr<UseNode *> DA
= DFG->addr<UseNode *>(DI); NodeAddr<StmtNode *>
TempIA = DA.Addr->getOwner(*DFG); dbgs() << "\t\t[Reaching Def]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; } }; } } while (false)
234 << Print<NodeAddr<InstrNode *>>(TempIA, *DFG) << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Multiple Reaching Defs found!!! ***\n"
; for (auto DI : ReachingDefs) { NodeAddr<UseNode *> DA
= DFG->addr<UseNode *>(DI); NodeAddr<StmtNode *>
TempIA = DA.Addr->getOwner(*DFG); dbgs() << "\t\t[Reaching Def]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; } }; } } while (false)
235 }do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Multiple Reaching Defs found!!! ***\n"
; for (auto DI : ReachingDefs) { NodeAddr<UseNode *> DA
= DFG->addr<UseNode *>(DI); NodeAddr<StmtNode *>
TempIA = DA.Addr->getOwner(*DFG); dbgs() << "\t\t[Reaching Def]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; } }; } } while (false)
236 })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { dbgs() << "*** Multiple Reaching Defs found!!! ***\n"
; for (auto DI : ReachingDefs) { NodeAddr<UseNode *> DA
= DFG->addr<UseNode *>(DI); NodeAddr<StmtNode *>
TempIA = DA.Addr->getOwner(*DFG); dbgs() << "\t\t[Reaching Def]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; } }; } } while (false)
;
237 return false;
238 }
239 }
240 return true;
241}
242
243void HexagonOptAddrMode::getAllRealUses(NodeAddr<StmtNode *> SA,
244 NodeList &UNodeList) {
245 for (NodeAddr<DefNode *> DA : SA.Addr->members_if(DFG->IsDef, *DFG)) {
246 LLVM_DEBUG(dbgs() << "\t\t[DefNode]: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t\t[DefNode]: " <<
Print<NodeAddr<DefNode *>>(DA, *DFG) << "\n"
; } } while (false)
247 << Print<NodeAddr<DefNode *>>(DA, *DFG) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t\t[DefNode]: " <<
Print<NodeAddr<DefNode *>>(DA, *DFG) << "\n"
; } } while (false)
;
248 RegisterRef DR = DFG->getPRI().normalize(DA.Addr->getRegRef(*DFG));
249
250 auto UseSet = LV->getAllReachedUses(DR, DA);
251
252 for (auto UI : UseSet) {
253 NodeAddr<UseNode *> UA = DFG->addr<UseNode *>(UI);
254 LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { NodeAddr<StmtNode *> TempIA = UA
.Addr->getOwner(*DFG); dbgs() << "\t\t\t[Reached Use]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; }; } } while (false)
255 NodeAddr<StmtNode *> TempIA = UA.Addr->getOwner(*DFG);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { NodeAddr<StmtNode *> TempIA = UA
.Addr->getOwner(*DFG); dbgs() << "\t\t\t[Reached Use]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; }; } } while (false)
256 dbgs() << "\t\t\t[Reached Use]: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { NodeAddr<StmtNode *> TempIA = UA
.Addr->getOwner(*DFG); dbgs() << "\t\t\t[Reached Use]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; }; } } while (false)
257 << Print<NodeAddr<InstrNode *>>(TempIA, *DFG) << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { NodeAddr<StmtNode *> TempIA = UA
.Addr->getOwner(*DFG); dbgs() << "\t\t\t[Reached Use]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; }; } } while (false)
258 })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { { NodeAddr<StmtNode *> TempIA = UA
.Addr->getOwner(*DFG); dbgs() << "\t\t\t[Reached Use]: "
<< Print<NodeAddr<InstrNode *>>(TempIA, *DFG
) << "\n"; }; } } while (false)
;
259
260 if (UA.Addr->getFlags() & NodeAttrs::PhiRef) {
261 NodeAddr<PhiNode *> PA = UA.Addr->getOwner(*DFG);
262 NodeId id = PA.Id;
263 const Liveness::RefMap &phiUse = LV->getRealUses(id);
264 LLVM_DEBUG(dbgs() << "\t\t\t\tphi real Uses"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t\t\t\tphi real Uses" <<
Print<Liveness::RefMap>(phiUse, *DFG) << "\n"; }
} while (false)
265 << Print<Liveness::RefMap>(phiUse, *DFG) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t\t\t\tphi real Uses" <<
Print<Liveness::RefMap>(phiUse, *DFG) << "\n"; }
} while (false)
;
266 if (!phiUse.empty()) {
267 for (auto I : phiUse) {
268 if (!DFG->getPRI().alias(RegisterRef(I.first), DR))
269 continue;
270 auto phiUseSet = I.second;
271 for (auto phiUI : phiUseSet) {
272 NodeAddr<UseNode *> phiUA = DFG->addr<UseNode *>(phiUI.first);
273 UNodeList.push_back(phiUA);
274 }
275 }
276 }
277 } else
278 UNodeList.push_back(UA);
279 }
280 }
281}
282
283bool HexagonOptAddrMode::isSafeToExtLR(NodeAddr<StmtNode *> SN,
284 MachineInstr *MI, unsigned LRExtReg,
285 const NodeList &UNodeList) {
286 RegisterRef LRExtRR;
287 NodeId LRExtRegRD = 0;
288 // Iterate through all the UseNodes in SN and find the reaching def
289 // for the LRExtReg.
290 for (NodeAddr<UseNode *> UA : SN.Addr->members_if(DFG->IsUse, *DFG)) {
291 RegisterRef RR = UA.Addr->getRegRef(*DFG);
292 if (LRExtReg == RR.Reg) {
293 LRExtRR = RR;
294 LRExtRegRD = UA.Addr->getReachingDef();
295 }
296 }
297
298 for (auto I = UNodeList.rbegin(), E = UNodeList.rend(); I != E; ++I) {
299 NodeAddr<UseNode *> UA = *I;
300 NodeAddr<InstrNode *> IA = UA.Addr->getOwner(*DFG);
301 // The reaching def of LRExtRR at load/store node should be same as the
302 // one reaching at the SN.
303 if (UA.Addr->getFlags() & NodeAttrs::PhiRef)
304 return false;
305 NodeAddr<RefNode*> AA = LV->getNearestAliasedRef(LRExtRR, IA);
306 if ((DFG->IsDef(AA) && AA.Id != LRExtRegRD) ||
307 AA.Addr->getReachingDef() != LRExtRegRD) {
308 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "isSafeToExtLR: Returning false; another reaching def\n"
; } } while (false)
309 dbgs() << "isSafeToExtLR: Returning false; another reaching def\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "isSafeToExtLR: Returning false; another reaching def\n"
; } } while (false)
;
310 return false;
311 }
312
313 MachineInstr *UseMI = NodeAddr<StmtNode *>(IA).Addr->getCode();
314 NodeAddr<DefNode *> LRExtRegDN = DFG->addr<DefNode *>(LRExtRegRD);
315 // Reaching Def to LRExtReg can't be a phi.
316 if ((LRExtRegDN.Addr->getFlags() & NodeAttrs::PhiRef) &&
317 MI->getParent() != UseMI->getParent())
318 return false;
319 }
320 return true;
321}
322
323bool HexagonOptAddrMode::isValidOffset(MachineInstr *MI, int Offset) {
324 unsigned AlignMask = 0;
325 switch (HII->getMemAccessSize(*MI)) {
326 case HexagonII::MemAccessSize::DoubleWordAccess:
327 AlignMask = 0x7;
328 break;
329 case HexagonII::MemAccessSize::WordAccess:
330 AlignMask = 0x3;
331 break;
332 case HexagonII::MemAccessSize::HalfWordAccess:
333 AlignMask = 0x1;
334 break;
335 case HexagonII::MemAccessSize::ByteAccess:
336 AlignMask = 0x0;
337 break;
338 default:
339 return false;
340 }
341
342 if ((AlignMask & Offset) != 0)
343 return false;
344 return HII->isValidOffset(MI->getOpcode(), Offset, HRI, false);
345}
346
347bool HexagonOptAddrMode::processAddUses(NodeAddr<StmtNode *> AddSN,
348 MachineInstr *AddMI,
349 const NodeList &UNodeList) {
350
351 Register AddDefR = AddMI->getOperand(0).getReg();
352 for (auto I = UNodeList.rbegin(), E = UNodeList.rend(); I != E; ++I) {
353 NodeAddr<UseNode *> UN = *I;
354 NodeAddr<StmtNode *> SN = UN.Addr->getOwner(*DFG);
355 MachineInstr *MI = SN.Addr->getCode();
356 const MCInstrDesc &MID = MI->getDesc();
357 if ((!MID.mayLoad() && !MID.mayStore()) ||
358 HII->getAddrMode(*MI) != HexagonII::BaseImmOffset ||
359 HII->isHVXVec(*MI))
360 return false;
361
362 MachineOperand BaseOp = MID.mayLoad() ? MI->getOperand(1)
363 : MI->getOperand(0);
364
365 if (!BaseOp.isReg() || BaseOp.getReg() != AddDefR)
366 return false;
367
368 MachineOperand OffsetOp = MID.mayLoad() ? MI->getOperand(2)
369 : MI->getOperand(1);
370 if (!OffsetOp.isImm())
371 return false;
372
373 int64_t newOffset = OffsetOp.getImm() + AddMI->getOperand(2).getImm();
374 if (!isValidOffset(MI, newOffset))
375 return false;
376
377 // Since we'll be extending the live range of Rt in the following example,
378 // make sure that is safe. another definition of Rt doesn't exist between 'add'
379 // and load/store instruction.
380 //
381 // Ex: Rx= add(Rt,#10)
382 // memw(Rx+#0) = Rs
383 // will be replaced with => memw(Rt+#10) = Rs
384 Register BaseReg = AddMI->getOperand(1).getReg();
385 if (!isSafeToExtLR(AddSN, AddMI, BaseReg, UNodeList))
386 return false;
387 }
388
389 // Update all the uses of 'add' with the appropriate base and offset
390 // values.
391 bool Changed = false;
392 for (auto I = UNodeList.rbegin(), E = UNodeList.rend(); I != E; ++I) {
393 NodeAddr<UseNode *> UseN = *I;
394 assert(!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) &&((!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) &&
"Found a PhiRef node as a real reached use!!") ? static_cast
<void> (0) : __assert_fail ("!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) && \"Found a PhiRef node as a real reached use!!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 395, __PRETTY_FUNCTION__))
395 "Found a PhiRef node as a real reached use!!")((!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) &&
"Found a PhiRef node as a real reached use!!") ? static_cast
<void> (0) : __assert_fail ("!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) && \"Found a PhiRef node as a real reached use!!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 395, __PRETTY_FUNCTION__))
;
396
397 NodeAddr<StmtNode *> OwnerN = UseN.Addr->getOwner(*DFG);
398 MachineInstr *UseMI = OwnerN.Addr->getCode();
399 LLVM_DEBUG(dbgs() << "\t\t[MI <BB#" << UseMI->getParent()->getNumber()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t\t[MI <BB#" <<
UseMI->getParent()->getNumber() << ">]: " <<
*UseMI << "\n"; } } while (false)
400 << ">]: " << *UseMI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t\t[MI <BB#" <<
UseMI->getParent()->getNumber() << ">]: " <<
*UseMI << "\n"; } } while (false)
;
401 Changed |= updateAddUses(AddMI, UseMI);
402 }
403
404 if (Changed)
405 Deleted.insert(AddMI);
406
407 return Changed;
408}
409
410bool HexagonOptAddrMode::updateAddUses(MachineInstr *AddMI,
411 MachineInstr *UseMI) {
412 const MachineOperand ImmOp = AddMI->getOperand(2);
413 const MachineOperand AddRegOp = AddMI->getOperand(1);
414 Register newReg = AddRegOp.getReg();
415 const MCInstrDesc &MID = UseMI->getDesc();
416
417 MachineOperand &BaseOp = MID.mayLoad() ? UseMI->getOperand(1)
418 : UseMI->getOperand(0);
419 MachineOperand &OffsetOp = MID.mayLoad() ? UseMI->getOperand(2)
420 : UseMI->getOperand(1);
421 BaseOp.setReg(newReg);
422 BaseOp.setIsUndef(AddRegOp.isUndef());
423 BaseOp.setImplicit(AddRegOp.isImplicit());
424 OffsetOp.setImm(ImmOp.getImm() + OffsetOp.getImm());
425 MRI->clearKillFlags(newReg);
426
427 return true;
428}
429
430bool HexagonOptAddrMode::analyzeUses(unsigned tfrDefR,
431 const NodeList &UNodeList,
432 InstrEvalMap &InstrEvalResult,
433 short &SizeInc) {
434 bool KeepTfr = false;
435 bool HasRepInstr = false;
436 InstrEvalResult.clear();
437
438 for (auto I = UNodeList.rbegin(), E = UNodeList.rend(); I != E; ++I) {
439 bool CanBeReplaced = false;
440 NodeAddr<UseNode *> UN = *I;
441 NodeAddr<StmtNode *> SN = UN.Addr->getOwner(*DFG);
442 MachineInstr &MI = *SN.Addr->getCode();
443 const MCInstrDesc &MID = MI.getDesc();
444 if ((MID.mayLoad() || MID.mayStore())) {
445 if (!hasRepForm(MI, tfrDefR)) {
446 KeepTfr = true;
447 continue;
448 }
449 SizeInc++;
450 CanBeReplaced = true;
451 } else if (MI.getOpcode() == Hexagon::S2_addasl_rrri) {
452 NodeList AddaslUseList;
453
454 LLVM_DEBUG(dbgs() << "\nGetting ReachedUses for === " << MI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\nGetting ReachedUses for === "
<< MI << "\n"; } } while (false)
;
455 getAllRealUses(SN, AddaslUseList);
456 // Process phi nodes.
457 if (allValidCandidates(SN, AddaslUseList) &&
458 canRemoveAddasl(SN, MI, AddaslUseList)) {
459 SizeInc += AddaslUseList.size();
460 SizeInc -= 1; // Reduce size by 1 as addasl itself can be removed.
461 CanBeReplaced = true;
462 } else
463 SizeInc++;
464 } else
465 // Currently, only load/store and addasl are handled.
466 // Some other instructions to consider -
467 // A2_add -> A2_addi
468 // M4_mpyrr_addr -> M4_mpyrr_addi
469 KeepTfr = true;
470
471 InstrEvalResult[&MI] = CanBeReplaced;
472 HasRepInstr |= CanBeReplaced;
473 }
474
475 // Reduce total size by 2 if original tfr can be deleted.
476 if (!KeepTfr)
477 SizeInc -= 2;
478
479 return HasRepInstr;
480}
481
482bool HexagonOptAddrMode::changeLoad(MachineInstr *OldMI, MachineOperand ImmOp,
483 unsigned ImmOpNum) {
484 bool Changed = false;
485 MachineBasicBlock *BB = OldMI->getParent();
486 auto UsePos = MachineBasicBlock::iterator(OldMI);
487 MachineBasicBlock::instr_iterator InsertPt = UsePos.getInstrIterator();
488 ++InsertPt;
489 unsigned OpStart;
490 unsigned OpEnd = OldMI->getNumOperands();
491 MachineInstrBuilder MIB;
492
493 if (ImmOpNum == 1) {
494 if (HII->getAddrMode(*OldMI) == HexagonII::BaseRegOffset) {
495 short NewOpCode = HII->changeAddrMode_rr_ur(*OldMI);
496 assert(NewOpCode >= 0 && "Invalid New opcode\n")((NewOpCode >= 0 && "Invalid New opcode\n") ? static_cast
<void> (0) : __assert_fail ("NewOpCode >= 0 && \"Invalid New opcode\\n\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 496, __PRETTY_FUNCTION__))
;
497 MIB = BuildMI(*BB, InsertPt, OldMI->getDebugLoc(), HII->get(NewOpCode));
498 MIB.add(OldMI->getOperand(0));
499 MIB.add(OldMI->getOperand(2));
500 MIB.add(OldMI->getOperand(3));
501 MIB.add(ImmOp);
502 OpStart = 4;
503 Changed = true;
504 } else if (HII->getAddrMode(*OldMI) == HexagonII::BaseImmOffset &&
505 OldMI->getOperand(2).isImm()) {
506 short NewOpCode = HII->changeAddrMode_io_abs(*OldMI);
507 assert(NewOpCode >= 0 && "Invalid New opcode\n")((NewOpCode >= 0 && "Invalid New opcode\n") ? static_cast
<void> (0) : __assert_fail ("NewOpCode >= 0 && \"Invalid New opcode\\n\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 507, __PRETTY_FUNCTION__))
;
508 MIB = BuildMI(*BB, InsertPt, OldMI->getDebugLoc(), HII->get(NewOpCode))
509 .add(OldMI->getOperand(0));
510 const GlobalValue *GV = ImmOp.getGlobal();
511 int64_t Offset = ImmOp.getOffset() + OldMI->getOperand(2).getImm();
512
513 MIB.addGlobalAddress(GV, Offset, ImmOp.getTargetFlags());
514 OpStart = 3;
515 Changed = true;
516 } else
517 Changed = false;
518
519 LLVM_DEBUG(dbgs() << "[Changing]: " << *OldMI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[Changing]: " << *
OldMI << "\n"; } } while (false)
;
520 LLVM_DEBUG(dbgs() << "[TO]: " << *MIB << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[TO]: " << *MIB <<
"\n"; } } while (false)
;
521 } else if (ImmOpNum == 2) {
522 if (OldMI->getOperand(3).isImm() && OldMI->getOperand(3).getImm() == 0) {
523 short NewOpCode = HII->changeAddrMode_rr_io(*OldMI);
524 assert(NewOpCode >= 0 && "Invalid New opcode\n")((NewOpCode >= 0 && "Invalid New opcode\n") ? static_cast
<void> (0) : __assert_fail ("NewOpCode >= 0 && \"Invalid New opcode\\n\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 524, __PRETTY_FUNCTION__))
;
525 MIB = BuildMI(*BB, InsertPt, OldMI->getDebugLoc(), HII->get(NewOpCode));
526 MIB.add(OldMI->getOperand(0));
527 MIB.add(OldMI->getOperand(1));
528 MIB.add(ImmOp);
529 OpStart = 4;
530 Changed = true;
531 LLVM_DEBUG(dbgs() << "[Changing]: " << *OldMI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[Changing]: " << *
OldMI << "\n"; } } while (false)
;
532 LLVM_DEBUG(dbgs() << "[TO]: " << *MIB << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[TO]: " << *MIB <<
"\n"; } } while (false)
;
533 }
534 }
535
536 if (Changed)
537 for (unsigned i = OpStart; i < OpEnd; ++i)
538 MIB.add(OldMI->getOperand(i));
539
540 return Changed;
541}
542
543bool HexagonOptAddrMode::changeStore(MachineInstr *OldMI, MachineOperand ImmOp,
544 unsigned ImmOpNum) {
545 bool Changed = false;
546 unsigned OpStart = 0;
547 unsigned OpEnd = OldMI->getNumOperands();
548 MachineBasicBlock *BB = OldMI->getParent();
549 auto UsePos = MachineBasicBlock::iterator(OldMI);
550 MachineBasicBlock::instr_iterator InsertPt = UsePos.getInstrIterator();
551 ++InsertPt;
552 MachineInstrBuilder MIB;
6
Calling defaulted default constructor for 'MachineInstrBuilder'
8
Returning from default constructor for 'MachineInstrBuilder'
553 if (ImmOpNum == 0) {
9
Assuming 'ImmOpNum' is equal to 0
10
Taking true branch
554 if (HII->getAddrMode(*OldMI) == HexagonII::BaseRegOffset) {
11
Assuming the condition is false
12
Taking false branch
555 short NewOpCode = HII->changeAddrMode_rr_ur(*OldMI);
556 assert(NewOpCode >= 0 && "Invalid New opcode\n")((NewOpCode >= 0 && "Invalid New opcode\n") ? static_cast
<void> (0) : __assert_fail ("NewOpCode >= 0 && \"Invalid New opcode\\n\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 556, __PRETTY_FUNCTION__))
;
557 MIB = BuildMI(*BB, InsertPt, OldMI->getDebugLoc(), HII->get(NewOpCode));
558 MIB.add(OldMI->getOperand(1));
559 MIB.add(OldMI->getOperand(2));
560 MIB.add(ImmOp);
561 MIB.add(OldMI->getOperand(3));
562 OpStart = 4;
563 } else if (HII->getAddrMode(*OldMI) == HexagonII::BaseImmOffset) {
13
Assuming the condition is false
14
Taking false branch
564 short NewOpCode = HII->changeAddrMode_io_abs(*OldMI);
565 assert(NewOpCode >= 0 && "Invalid New opcode\n")((NewOpCode >= 0 && "Invalid New opcode\n") ? static_cast
<void> (0) : __assert_fail ("NewOpCode >= 0 && \"Invalid New opcode\\n\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 565, __PRETTY_FUNCTION__))
;
566 MIB = BuildMI(*BB, InsertPt, OldMI->getDebugLoc(), HII->get(NewOpCode));
567 const GlobalValue *GV = ImmOp.getGlobal();
568 int64_t Offset = ImmOp.getOffset() + OldMI->getOperand(1).getImm();
569 MIB.addGlobalAddress(GV, Offset, ImmOp.getTargetFlags());
570 MIB.add(OldMI->getOperand(2));
571 OpStart = 3;
572 }
573 Changed = true;
574 LLVM_DEBUG(dbgs() << "[Changing]: " << *OldMI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[Changing]: " << *
OldMI << "\n"; } } while (false)
;
15
Assuming 'DebugFlag' is false
16
Loop condition is false. Exiting loop
575 LLVM_DEBUG
16.1
'DebugFlag' is false
16.1
'DebugFlag' is false
(dbgs() << "[TO]: " << *MIB << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[TO]: " << *MIB <<
"\n"; } } while (false)
;
17
Loop condition is false. Exiting loop
576 } else if (ImmOpNum == 1 && OldMI->getOperand(2).getImm() == 0) {
577 short NewOpCode = HII->changeAddrMode_rr_io(*OldMI);
578 assert(NewOpCode >= 0 && "Invalid New opcode\n")((NewOpCode >= 0 && "Invalid New opcode\n") ? static_cast
<void> (0) : __assert_fail ("NewOpCode >= 0 && \"Invalid New opcode\\n\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 578, __PRETTY_FUNCTION__))
;
579 MIB = BuildMI(*BB, InsertPt, OldMI->getDebugLoc(), HII->get(NewOpCode));
580 MIB.add(OldMI->getOperand(0));
581 MIB.add(ImmOp);
582 OpStart = 3;
583 Changed = true;
584 LLVM_DEBUG(dbgs() << "[Changing]: " << *OldMI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[Changing]: " << *
OldMI << "\n"; } } while (false)
;
585 LLVM_DEBUG(dbgs() << "[TO]: " << *MIB << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[TO]: " << *MIB <<
"\n"; } } while (false)
;
586 }
587 if (Changed
17.1
'Changed' is true
17.1
'Changed' is true
)
18
Taking true branch
588 for (unsigned i = OpStart; i < OpEnd; ++i)
19
Assuming 'i' is < 'OpEnd'
20
Loop condition is true. Entering loop body
589 MIB.add(OldMI->getOperand(i));
21
Calling 'MachineInstrBuilder::add'
590
591 return Changed;
592}
593
594short HexagonOptAddrMode::getBaseWithLongOffset(const MachineInstr &MI) const {
595 if (HII->getAddrMode(MI) == HexagonII::BaseImmOffset) {
596 short TempOpCode = HII->changeAddrMode_io_rr(MI);
597 return HII->changeAddrMode_rr_ur(TempOpCode);
598 }
599 return HII->changeAddrMode_rr_ur(MI);
600}
601
602bool HexagonOptAddrMode::changeAddAsl(NodeAddr<UseNode *> AddAslUN,
603 MachineInstr *AddAslMI,
604 const MachineOperand &ImmOp,
605 unsigned ImmOpNum) {
606 NodeAddr<StmtNode *> SA = AddAslUN.Addr->getOwner(*DFG);
607
608 LLVM_DEBUG(dbgs() << "Processing addasl :" << *AddAslMI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "Processing addasl :" <<
*AddAslMI << "\n"; } } while (false)
;
609
610 NodeList UNodeList;
611 getAllRealUses(SA, UNodeList);
612
613 for (auto I = UNodeList.rbegin(), E = UNodeList.rend(); I != E; ++I) {
614 NodeAddr<UseNode *> UseUN = *I;
615 assert(!(UseUN.Addr->getFlags() & NodeAttrs::PhiRef) &&((!(UseUN.Addr->getFlags() & NodeAttrs::PhiRef) &&
"Can't transform this 'AddAsl' instruction!") ? static_cast<
void> (0) : __assert_fail ("!(UseUN.Addr->getFlags() & NodeAttrs::PhiRef) && \"Can't transform this 'AddAsl' instruction!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 616, __PRETTY_FUNCTION__))
616 "Can't transform this 'AddAsl' instruction!")((!(UseUN.Addr->getFlags() & NodeAttrs::PhiRef) &&
"Can't transform this 'AddAsl' instruction!") ? static_cast<
void> (0) : __assert_fail ("!(UseUN.Addr->getFlags() & NodeAttrs::PhiRef) && \"Can't transform this 'AddAsl' instruction!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 616, __PRETTY_FUNCTION__))
;
617
618 NodeAddr<StmtNode *> UseIA = UseUN.Addr->getOwner(*DFG);
619 LLVM_DEBUG(dbgs() << "[InstrNode]: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[InstrNode]: " <<
Print<NodeAddr<InstrNode *>>(UseIA, *DFG) <<
"\n"; } } while (false)
620 << Print<NodeAddr<InstrNode *>>(UseIA, *DFG) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[InstrNode]: " <<
Print<NodeAddr<InstrNode *>>(UseIA, *DFG) <<
"\n"; } } while (false)
;
621 MachineInstr *UseMI = UseIA.Addr->getCode();
622 LLVM_DEBUG(dbgs() << "[MI <" << printMBBReference(*UseMI->getParent())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[MI <" << printMBBReference
(*UseMI->getParent()) << ">]: " << *UseMI <<
"\n"; } } while (false)
623 << ">]: " << *UseMI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[MI <" << printMBBReference
(*UseMI->getParent()) << ">]: " << *UseMI <<
"\n"; } } while (false)
;
624 const MCInstrDesc &UseMID = UseMI->getDesc();
625 assert(HII->getAddrMode(*UseMI) == HexagonII::BaseImmOffset)((HII->getAddrMode(*UseMI) == HexagonII::BaseImmOffset) ? static_cast
<void> (0) : __assert_fail ("HII->getAddrMode(*UseMI) == HexagonII::BaseImmOffset"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 625, __PRETTY_FUNCTION__))
;
626
627 auto UsePos = MachineBasicBlock::iterator(UseMI);
628 MachineBasicBlock::instr_iterator InsertPt = UsePos.getInstrIterator();
629 short NewOpCode = getBaseWithLongOffset(*UseMI);
630 assert(NewOpCode >= 0 && "Invalid New opcode\n")((NewOpCode >= 0 && "Invalid New opcode\n") ? static_cast
<void> (0) : __assert_fail ("NewOpCode >= 0 && \"Invalid New opcode\\n\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 630, __PRETTY_FUNCTION__))
;
631
632 unsigned OpStart;
633 unsigned OpEnd = UseMI->getNumOperands();
634
635 MachineBasicBlock *BB = UseMI->getParent();
636 MachineInstrBuilder MIB =
637 BuildMI(*BB, InsertPt, UseMI->getDebugLoc(), HII->get(NewOpCode));
638 // change mem(Rs + # ) -> mem(Rt << # + ##)
639 if (UseMID.mayLoad()) {
640 MIB.add(UseMI->getOperand(0));
641 MIB.add(AddAslMI->getOperand(2));
642 MIB.add(AddAslMI->getOperand(3));
643 const GlobalValue *GV = ImmOp.getGlobal();
644 MIB.addGlobalAddress(GV, UseMI->getOperand(2).getImm()+ImmOp.getOffset(),
645 ImmOp.getTargetFlags());
646 OpStart = 3;
647 } else if (UseMID.mayStore()) {
648 MIB.add(AddAslMI->getOperand(2));
649 MIB.add(AddAslMI->getOperand(3));
650 const GlobalValue *GV = ImmOp.getGlobal();
651 MIB.addGlobalAddress(GV, UseMI->getOperand(1).getImm()+ImmOp.getOffset(),
652 ImmOp.getTargetFlags());
653 MIB.add(UseMI->getOperand(2));
654 OpStart = 3;
655 } else
656 llvm_unreachable("Unhandled instruction")::llvm::llvm_unreachable_internal("Unhandled instruction", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 656)
;
657
658 for (unsigned i = OpStart; i < OpEnd; ++i)
659 MIB.add(UseMI->getOperand(i));
660
661 Deleted.insert(UseMI);
662 }
663
664 return true;
665}
666
667bool HexagonOptAddrMode::xformUseMI(MachineInstr *TfrMI, MachineInstr *UseMI,
668 NodeAddr<UseNode *> UseN,
669 unsigned UseMOnum) {
670 const MachineOperand ImmOp = TfrMI->getOperand(1);
671 const MCInstrDesc &MID = UseMI->getDesc();
672 unsigned Changed = false;
673 if (MID.mayLoad())
1
Assuming the condition is false
2
Taking false branch
674 Changed = changeLoad(UseMI, ImmOp, UseMOnum);
675 else if (MID.mayStore())
3
Assuming the condition is true
4
Taking true branch
676 Changed = changeStore(UseMI, ImmOp, UseMOnum);
5
Calling 'HexagonOptAddrMode::changeStore'
677 else if (UseMI->getOpcode() == Hexagon::S2_addasl_rrri)
678 Changed = changeAddAsl(UseN, UseMI, ImmOp, UseMOnum);
679
680 if (Changed)
681 Deleted.insert(UseMI);
682
683 return Changed;
684}
685
686bool HexagonOptAddrMode::processBlock(NodeAddr<BlockNode *> BA) {
687 bool Changed = false;
688
689 for (auto IA : BA.Addr->members(*DFG)) {
690 if (!DFG->IsCode<NodeAttrs::Stmt>(IA))
691 continue;
692
693 NodeAddr<StmtNode *> SA = IA;
694 MachineInstr *MI = SA.Addr->getCode();
695 if ((MI->getOpcode() != Hexagon::A2_tfrsi ||
696 !MI->getOperand(1).isGlobal()) &&
697 (MI->getOpcode() != Hexagon::A2_addi ||
698 !MI->getOperand(2).isImm() || HII->isConstExtended(*MI)))
699 continue;
700
701 LLVM_DEBUG(dbgs() << "[Analyzing " << HII->getName(MI->getOpcode())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[Analyzing " << HII
->getName(MI->getOpcode()) << "]: " << *MI <<
"\n\t[InstrNode]: " << Print<NodeAddr<InstrNode *
>>(IA, *DFG) << '\n'; } } while (false)
702 << "]: " << *MI << "\n\t[InstrNode]: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[Analyzing " << HII
->getName(MI->getOpcode()) << "]: " << *MI <<
"\n\t[InstrNode]: " << Print<NodeAddr<InstrNode *
>>(IA, *DFG) << '\n'; } } while (false)
703 << Print<NodeAddr<InstrNode *>>(IA, *DFG) << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "[Analyzing " << HII
->getName(MI->getOpcode()) << "]: " << *MI <<
"\n\t[InstrNode]: " << Print<NodeAddr<InstrNode *
>>(IA, *DFG) << '\n'; } } while (false)
;
704
705 NodeList UNodeList;
706 getAllRealUses(SA, UNodeList);
707
708 if (!allValidCandidates(SA, UNodeList))
709 continue;
710
711 // Analyze all uses of 'add'. If the output of 'add' is used as an address
712 // in the base+immediate addressing mode load/store instructions, see if
713 // they can be updated to use the immediate value as an offet. Thus,
714 // providing us the opportunity to eliminate 'add'.
715 // Ex: Rx= add(Rt,#12)
716 // memw(Rx+#0) = Rs
717 // This can be replaced with memw(Rt+#12) = Rs
718 //
719 // This transformation is only performed if all uses can be updated and
720 // the offset isn't required to be constant extended.
721 if (MI->getOpcode() == Hexagon::A2_addi) {
722 Changed |= processAddUses(SA, MI, UNodeList);
723 continue;
724 }
725
726 short SizeInc = 0;
727 Register DefR = MI->getOperand(0).getReg();
728 InstrEvalMap InstrEvalResult;
729
730 // Analyze all uses and calculate increase in size. Perform the optimization
731 // only if there is no increase in size.
732 if (!analyzeUses(DefR, UNodeList, InstrEvalResult, SizeInc))
733 continue;
734 if (SizeInc > CodeGrowthLimit)
735 continue;
736
737 bool KeepTfr = false;
738
739 LLVM_DEBUG(dbgs() << "\t[Total reached uses] : " << UNodeList.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t[Total reached uses] : "
<< UNodeList.size() << "\n"; } } while (false)
740 << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t[Total reached uses] : "
<< UNodeList.size() << "\n"; } } while (false)
;
741 LLVM_DEBUG(dbgs() << "\t[Processing Reached Uses] ===\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t[Processing Reached Uses] ===\n"
; } } while (false)
;
742 for (auto I = UNodeList.rbegin(), E = UNodeList.rend(); I != E; ++I) {
743 NodeAddr<UseNode *> UseN = *I;
744 assert(!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) &&((!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) &&
"Found a PhiRef node as a real reached use!!") ? static_cast
<void> (0) : __assert_fail ("!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) && \"Found a PhiRef node as a real reached use!!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 745, __PRETTY_FUNCTION__))
745 "Found a PhiRef node as a real reached use!!")((!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) &&
"Found a PhiRef node as a real reached use!!") ? static_cast
<void> (0) : __assert_fail ("!(UseN.Addr->getFlags() & NodeAttrs::PhiRef) && \"Found a PhiRef node as a real reached use!!\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Target/Hexagon/HexagonOptAddrMode.cpp"
, 745, __PRETTY_FUNCTION__))
;
746
747 NodeAddr<StmtNode *> OwnerN = UseN.Addr->getOwner(*DFG);
748 MachineInstr *UseMI = OwnerN.Addr->getCode();
749 LLVM_DEBUG(dbgs() << "\t\t[MI <" << printMBBReference(*UseMI->getParent())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t\t[MI <" << printMBBReference
(*UseMI->getParent()) << ">]: " << *UseMI <<
"\n"; } } while (false)
750 << ">]: " << *UseMI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "\t\t[MI <" << printMBBReference
(*UseMI->getParent()) << ">]: " << *UseMI <<
"\n"; } } while (false)
;
751
752 int UseMOnum = -1;
753 unsigned NumOperands = UseMI->getNumOperands();
754 for (unsigned j = 0; j < NumOperands - 1; ++j) {
755 const MachineOperand &op = UseMI->getOperand(j);
756 if (op.isReg() && op.isUse() && DefR == op.getReg())
757 UseMOnum = j;
758 }
759 // It is possible that the register will not be found in any operand.
760 // This could happen, for example, when DefR = R4, but the used
761 // register is D2.
762
763 // Change UseMI if replacement is possible. If any replacement failed,
764 // or wasn't attempted, make sure to keep the TFR.
765 bool Xformed = false;
766 if (UseMOnum >= 0 && InstrEvalResult[UseMI])
767 Xformed = xformUseMI(MI, UseMI, UseN, UseMOnum);
768 Changed |= Xformed;
769 KeepTfr |= !Xformed;
770 }
771 if (!KeepTfr)
772 Deleted.insert(MI);
773 }
774 return Changed;
775}
776
777bool HexagonOptAddrMode::runOnMachineFunction(MachineFunction &MF) {
778 if (skipFunction(MF.getFunction()))
779 return false;
780
781 bool Changed = false;
782 auto &HST = MF.getSubtarget<HexagonSubtarget>();
783 MRI = &MF.getRegInfo();
784 HII = HST.getInstrInfo();
785 HRI = HST.getRegisterInfo();
786 const auto &MDF = getAnalysis<MachineDominanceFrontier>();
787 MDT = &getAnalysis<MachineDominatorTree>();
788 const TargetOperandInfo TOI(*HII);
789
790 DataFlowGraph G(MF, *HII, *HRI, *MDT, MDF, TOI);
791 // Need to keep dead phis because we can propagate uses of registers into
792 // nodes dominated by those would-be phis.
793 G.build(BuildOptions::KeepDeadPhis);
794 DFG = &G;
795
796 Liveness L(*MRI, *DFG);
797 L.computePhiInfo();
798 LV = &L;
799
800 Deleted.clear();
801 NodeAddr<FuncNode *> FA = DFG->getFunc();
802 LLVM_DEBUG(dbgs() << "==== [RefMap#]=====:\n "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "==== [RefMap#]=====:\n "
<< Print<NodeAddr<FuncNode *>>(FA, *DFG) <<
"\n"; } } while (false)
803 << Print<NodeAddr<FuncNode *>>(FA, *DFG) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("opt-addr-mode")) { dbgs() << "==== [RefMap#]=====:\n "
<< Print<NodeAddr<FuncNode *>>(FA, *DFG) <<
"\n"; } } while (false)
;
804
805 for (NodeAddr<BlockNode *> BA : FA.Addr->members(*DFG))
806 Changed |= processBlock(BA);
807
808 for (auto MI : Deleted)
809 MI->eraseFromParent();
810
811 if (Changed) {
812 G.build();
813 L.computeLiveIns();
814 L.resetLiveIns();
815 L.resetKills();
816 }
817
818 return Changed;
819}
820
821//===----------------------------------------------------------------------===//
822// Public Constructor Functions
823//===----------------------------------------------------------------------===//
824
825FunctionPass *llvm::createHexagonOptAddrMode() {
826 return new HexagonOptAddrMode();
827}

/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h

1//===- CodeGen/MachineInstrBuilder.h - Simplify creation of MIs --*- 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 exposes a function named BuildMI, which is useful for dramatically
10// simplifying how MachineInstr's are created. It allows use of code like this:
11//
12// M = BuildMI(MBB, MI, DL, TII.get(X86::ADD8rr), Dst)
13// .addReg(argVal1)
14// .addReg(argVal2);
15//
16//===----------------------------------------------------------------------===//
17
18#ifndef LLVM_CODEGEN_MACHINEINSTRBUILDER_H
19#define LLVM_CODEGEN_MACHINEINSTRBUILDER_H
20
21#include "llvm/ADT/ArrayRef.h"
22#include "llvm/CodeGen/GlobalISel/Utils.h"
23#include "llvm/CodeGen/MachineBasicBlock.h"
24#include "llvm/CodeGen/MachineFunction.h"
25#include "llvm/CodeGen/MachineInstr.h"
26#include "llvm/CodeGen/MachineInstrBundle.h"
27#include "llvm/CodeGen/MachineOperand.h"
28#include "llvm/CodeGen/TargetRegisterInfo.h"
29#include "llvm/IR/InstrTypes.h"
30#include "llvm/IR/Intrinsics.h"
31#include "llvm/Support/ErrorHandling.h"
32#include <cassert>
33#include <cstdint>
34#include <utility>
35
36namespace llvm {
37
38class MCInstrDesc;
39class MDNode;
40
41namespace RegState {
42
43 enum {
44 Define = 0x2,
45 Implicit = 0x4,
46 Kill = 0x8,
47 Dead = 0x10,
48 Undef = 0x20,
49 EarlyClobber = 0x40,
50 Debug = 0x80,
51 InternalRead = 0x100,
52 Renamable = 0x200,
53 DefineNoRead = Define | Undef,
54 ImplicitDefine = Implicit | Define,
55 ImplicitKill = Implicit | Kill
56 };
57
58} // end namespace RegState
59
60class MachineInstrBuilder {
61 MachineFunction *MF = nullptr;
62 MachineInstr *MI = nullptr;
7
Null pointer value stored to 'MIB.MI'
63
64public:
65 MachineInstrBuilder() = default;
66
67 /// Create a MachineInstrBuilder for manipulating an existing instruction.
68 /// F must be the machine function that was used to allocate I.
69 MachineInstrBuilder(MachineFunction &F, MachineInstr *I) : MF(&F), MI(I) {}
70 MachineInstrBuilder(MachineFunction &F, MachineBasicBlock::iterator I)
71 : MF(&F), MI(&*I) {}
72
73 /// Allow automatic conversion to the machine instruction we are working on.
74 operator MachineInstr*() const { return MI; }
75 MachineInstr *operator->() const { return MI; }
76 operator MachineBasicBlock::iterator() const { return MI; }
77
78 /// If conversion operators fail, use this method to get the MachineInstr
79 /// explicitly.
80 MachineInstr *getInstr() const { return MI; }
81
82 /// Get the register for the operand index.
83 /// The operand at the index should be a register (asserted by
84 /// MachineOperand).
85 Register getReg(unsigned Idx) const { return MI->getOperand(Idx).getReg(); }
86
87 /// Add a new virtual register operand.
88 const MachineInstrBuilder &addReg(Register RegNo, unsigned flags = 0,
89 unsigned SubReg = 0) const {
90 assert((flags & 0x1) == 0 &&(((flags & 0x1) == 0 && "Passing in 'true' to addReg is forbidden! Use enums instead."
) ? static_cast<void> (0) : __assert_fail ("(flags & 0x1) == 0 && \"Passing in 'true' to addReg is forbidden! Use enums instead.\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 91, __PRETTY_FUNCTION__))
91 "Passing in 'true' to addReg is forbidden! Use enums instead.")(((flags & 0x1) == 0 && "Passing in 'true' to addReg is forbidden! Use enums instead."
) ? static_cast<void> (0) : __assert_fail ("(flags & 0x1) == 0 && \"Passing in 'true' to addReg is forbidden! Use enums instead.\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 91, __PRETTY_FUNCTION__))
;
92 MI->addOperand(*MF, MachineOperand::CreateReg(RegNo,
93 flags & RegState::Define,
94 flags & RegState::Implicit,
95 flags & RegState::Kill,
96 flags & RegState::Dead,
97 flags & RegState::Undef,
98 flags & RegState::EarlyClobber,
99 SubReg,
100 flags & RegState::Debug,
101 flags & RegState::InternalRead,
102 flags & RegState::Renamable));
103 return *this;
104 }
105
106 /// Add a virtual register definition operand.
107 const MachineInstrBuilder &addDef(Register RegNo, unsigned Flags = 0,
108 unsigned SubReg = 0) const {
109 return addReg(RegNo, Flags | RegState::Define, SubReg);
110 }
111
112 /// Add a virtual register use operand. It is an error for Flags to contain
113 /// `RegState::Define` when calling this function.
114 const MachineInstrBuilder &addUse(Register RegNo, unsigned Flags = 0,
115 unsigned SubReg = 0) const {
116 assert(!(Flags & RegState::Define) &&((!(Flags & RegState::Define) && "Misleading addUse defines register, use addReg instead."
) ? static_cast<void> (0) : __assert_fail ("!(Flags & RegState::Define) && \"Misleading addUse defines register, use addReg instead.\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 117, __PRETTY_FUNCTION__))
117 "Misleading addUse defines register, use addReg instead.")((!(Flags & RegState::Define) && "Misleading addUse defines register, use addReg instead."
) ? static_cast<void> (0) : __assert_fail ("!(Flags & RegState::Define) && \"Misleading addUse defines register, use addReg instead.\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 117, __PRETTY_FUNCTION__))
;
118 return addReg(RegNo, Flags, SubReg);
119 }
120
121 /// Add a new immediate operand.
122 const MachineInstrBuilder &addImm(int64_t Val) const {
123 MI->addOperand(*MF, MachineOperand::CreateImm(Val));
124 return *this;
125 }
126
127 const MachineInstrBuilder &addCImm(const ConstantInt *Val) const {
128 MI->addOperand(*MF, MachineOperand::CreateCImm(Val));
129 return *this;
130 }
131
132 const MachineInstrBuilder &addFPImm(const ConstantFP *Val) const {
133 MI->addOperand(*MF, MachineOperand::CreateFPImm(Val));
134 return *this;
135 }
136
137 const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB,
138 unsigned TargetFlags = 0) const {
139 MI->addOperand(*MF, MachineOperand::CreateMBB(MBB, TargetFlags));
140 return *this;
141 }
142
143 const MachineInstrBuilder &addFrameIndex(int Idx) const {
144 MI->addOperand(*MF, MachineOperand::CreateFI(Idx));
145 return *this;
146 }
147
148 const MachineInstrBuilder &
149 addConstantPoolIndex(unsigned Idx, int Offset = 0,
150 unsigned TargetFlags = 0) const {
151 MI->addOperand(*MF, MachineOperand::CreateCPI(Idx, Offset, TargetFlags));
152 return *this;
153 }
154
155 const MachineInstrBuilder &addTargetIndex(unsigned Idx, int64_t Offset = 0,
156 unsigned TargetFlags = 0) const {
157 MI->addOperand(*MF, MachineOperand::CreateTargetIndex(Idx, Offset,
158 TargetFlags));
159 return *this;
160 }
161
162 const MachineInstrBuilder &addJumpTableIndex(unsigned Idx,
163 unsigned TargetFlags = 0) const {
164 MI->addOperand(*MF, MachineOperand::CreateJTI(Idx, TargetFlags));
165 return *this;
166 }
167
168 const MachineInstrBuilder &addGlobalAddress(const GlobalValue *GV,
169 int64_t Offset = 0,
170 unsigned TargetFlags = 0) const {
171 MI->addOperand(*MF, MachineOperand::CreateGA(GV, Offset, TargetFlags));
172 return *this;
173 }
174
175 const MachineInstrBuilder &addExternalSymbol(const char *FnName,
176 unsigned TargetFlags = 0) const {
177 MI->addOperand(*MF, MachineOperand::CreateES(FnName, TargetFlags));
178 return *this;
179 }
180
181 const MachineInstrBuilder &addBlockAddress(const BlockAddress *BA,
182 int64_t Offset = 0,
183 unsigned TargetFlags = 0) const {
184 MI->addOperand(*MF, MachineOperand::CreateBA(BA, Offset, TargetFlags));
185 return *this;
186 }
187
188 const MachineInstrBuilder &addRegMask(const uint32_t *Mask) const {
189 MI->addOperand(*MF, MachineOperand::CreateRegMask(Mask));
190 return *this;
191 }
192
193 const MachineInstrBuilder &addMemOperand(MachineMemOperand *MMO) const {
194 MI->addMemOperand(*MF, MMO);
195 return *this;
196 }
197
198 const MachineInstrBuilder &
199 setMemRefs(ArrayRef<MachineMemOperand *> MMOs) const {
200 MI->setMemRefs(*MF, MMOs);
201 return *this;
202 }
203
204 const MachineInstrBuilder &cloneMemRefs(const MachineInstr &OtherMI) const {
205 MI->cloneMemRefs(*MF, OtherMI);
206 return *this;
207 }
208
209 const MachineInstrBuilder &
210 cloneMergedMemRefs(ArrayRef<const MachineInstr *> OtherMIs) const {
211 MI->cloneMergedMemRefs(*MF, OtherMIs);
212 return *this;
213 }
214
215 const MachineInstrBuilder &add(const MachineOperand &MO) const {
216 MI->addOperand(*MF, MO);
22
Called C++ object pointer is null
217 return *this;
218 }
219
220 const MachineInstrBuilder &add(ArrayRef<MachineOperand> MOs) const {
221 for (const MachineOperand &MO : MOs) {
222 MI->addOperand(*MF, MO);
223 }
224 return *this;
225 }
226
227 const MachineInstrBuilder &addMetadata(const MDNode *MD) const {
228 MI->addOperand(*MF, MachineOperand::CreateMetadata(MD));
229 assert((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable())(((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable
()) : true) && "first MDNode argument of a DBG_VALUE not a variable"
) ? static_cast<void> (0) : __assert_fail ("(MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable()) : true) && \"first MDNode argument of a DBG_VALUE not a variable\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 231, __PRETTY_FUNCTION__))
230 : true) &&(((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable
()) : true) && "first MDNode argument of a DBG_VALUE not a variable"
) ? static_cast<void> (0) : __assert_fail ("(MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable()) : true) && \"first MDNode argument of a DBG_VALUE not a variable\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 231, __PRETTY_FUNCTION__))
231 "first MDNode argument of a DBG_VALUE not a variable")(((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable
()) : true) && "first MDNode argument of a DBG_VALUE not a variable"
) ? static_cast<void> (0) : __assert_fail ("(MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable()) : true) && \"first MDNode argument of a DBG_VALUE not a variable\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 231, __PRETTY_FUNCTION__))
;
232 assert((MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel())(((MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel
()) : true) && "first MDNode argument of a DBG_LABEL not a label"
) ? static_cast<void> (0) : __assert_fail ("(MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel()) : true) && \"first MDNode argument of a DBG_LABEL not a label\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 234, __PRETTY_FUNCTION__))
233 : true) &&(((MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel
()) : true) && "first MDNode argument of a DBG_LABEL not a label"
) ? static_cast<void> (0) : __assert_fail ("(MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel()) : true) && \"first MDNode argument of a DBG_LABEL not a label\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 234, __PRETTY_FUNCTION__))
234 "first MDNode argument of a DBG_LABEL not a label")(((MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel
()) : true) && "first MDNode argument of a DBG_LABEL not a label"
) ? static_cast<void> (0) : __assert_fail ("(MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel()) : true) && \"first MDNode argument of a DBG_LABEL not a label\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 234, __PRETTY_FUNCTION__))
;
235 return *this;
236 }
237
238 const MachineInstrBuilder &addCFIIndex(unsigned CFIIndex) const {
239 MI->addOperand(*MF, MachineOperand::CreateCFIIndex(CFIIndex));
240 return *this;
241 }
242
243 const MachineInstrBuilder &addIntrinsicID(Intrinsic::ID ID) const {
244 MI->addOperand(*MF, MachineOperand::CreateIntrinsicID(ID));
245 return *this;
246 }
247
248 const MachineInstrBuilder &addPredicate(CmpInst::Predicate Pred) const {
249 MI->addOperand(*MF, MachineOperand::CreatePredicate(Pred));
250 return *this;
251 }
252
253 const MachineInstrBuilder &addShuffleMask(const Constant *Val) const {
254 MI->addOperand(*MF, MachineOperand::CreateShuffleMask(Val));
255 return *this;
256 }
257
258 const MachineInstrBuilder &addSym(MCSymbol *Sym,
259 unsigned char TargetFlags = 0) const {
260 MI->addOperand(*MF, MachineOperand::CreateMCSymbol(Sym, TargetFlags));
261 return *this;
262 }
263
264 const MachineInstrBuilder &setMIFlags(unsigned Flags) const {
265 MI->setFlags(Flags);
266 return *this;
267 }
268
269 const MachineInstrBuilder &setMIFlag(MachineInstr::MIFlag Flag) const {
270 MI->setFlag(Flag);
271 return *this;
272 }
273
274 // Add a displacement from an existing MachineOperand with an added offset.
275 const MachineInstrBuilder &addDisp(const MachineOperand &Disp, int64_t off,
276 unsigned char TargetFlags = 0) const {
277 // If caller specifies new TargetFlags then use it, otherwise the
278 // default behavior is to copy the target flags from the existing
279 // MachineOperand. This means if the caller wants to clear the
280 // target flags it needs to do so explicitly.
281 if (0 == TargetFlags)
282 TargetFlags = Disp.getTargetFlags();
283
284 switch (Disp.getType()) {
285 default:
286 llvm_unreachable("Unhandled operand type in addDisp()")::llvm::llvm_unreachable_internal("Unhandled operand type in addDisp()"
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 286)
;
287 case MachineOperand::MO_Immediate:
288 return addImm(Disp.getImm() + off);
289 case MachineOperand::MO_ConstantPoolIndex:
290 return addConstantPoolIndex(Disp.getIndex(), Disp.getOffset() + off,
291 TargetFlags);
292 case MachineOperand::MO_GlobalAddress:
293 return addGlobalAddress(Disp.getGlobal(), Disp.getOffset() + off,
294 TargetFlags);
295 case MachineOperand::MO_BlockAddress:
296 return addBlockAddress(Disp.getBlockAddress(), Disp.getOffset() + off,
297 TargetFlags);
298 }
299 }
300
301 /// Copy all the implicit operands from OtherMI onto this one.
302 const MachineInstrBuilder &
303 copyImplicitOps(const MachineInstr &OtherMI) const {
304 MI->copyImplicitOps(*MF, OtherMI);
305 return *this;
306 }
307
308 bool constrainAllUses(const TargetInstrInfo &TII,
309 const TargetRegisterInfo &TRI,
310 const RegisterBankInfo &RBI) const {
311 return constrainSelectedInstRegOperands(*MI, TII, TRI, RBI);
312 }
313};
314
315/// Builder interface. Specify how to create the initial instruction itself.
316inline MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
317 const MCInstrDesc &MCID) {
318 return MachineInstrBuilder(MF, MF.CreateMachineInstr(MCID, DL));
319}
320
321/// This version of the builder sets up the first operand as a
322/// destination virtual register.
323inline MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
324 const MCInstrDesc &MCID, Register DestReg) {
325 return MachineInstrBuilder(MF, MF.CreateMachineInstr(MCID, DL))
326 .addReg(DestReg, RegState::Define);
327}
328
329/// This version of the builder inserts the newly-built instruction before
330/// the given position in the given MachineBasicBlock, and sets up the first
331/// operand as a destination virtual register.
332inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
333 MachineBasicBlock::iterator I,
334 const DebugLoc &DL, const MCInstrDesc &MCID,
335 Register DestReg) {
336 MachineFunction &MF = *BB.getParent();
337 MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
338 BB.insert(I, MI);
339 return MachineInstrBuilder(MF, MI).addReg(DestReg, RegState::Define);
340}
341
342/// This version of the builder inserts the newly-built instruction before
343/// the given position in the given MachineBasicBlock, and sets up the first
344/// operand as a destination virtual register.
345///
346/// If \c I is inside a bundle, then the newly inserted \a MachineInstr is
347/// added to the same bundle.
348inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
349 MachineBasicBlock::instr_iterator I,
350 const DebugLoc &DL, const MCInstrDesc &MCID,
351 Register DestReg) {
352 MachineFunction &MF = *BB.getParent();
353 MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
354 BB.insert(I, MI);
355 return MachineInstrBuilder(MF, MI).addReg(DestReg, RegState::Define);
356}
357
358inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr &I,
359 const DebugLoc &DL, const MCInstrDesc &MCID,
360 Register DestReg) {
361 // Calling the overload for instr_iterator is always correct. However, the
362 // definition is not available in headers, so inline the check.
363 if (I.isInsideBundle())
364 return BuildMI(BB, MachineBasicBlock::instr_iterator(I), DL, MCID, DestReg);
365 return BuildMI(BB, MachineBasicBlock::iterator(I), DL, MCID, DestReg);
366}
367
368inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr *I,
369 const DebugLoc &DL, const MCInstrDesc &MCID,
370 Register DestReg) {
371 return BuildMI(BB, *I, DL, MCID, DestReg);
372}
373
374/// This version of the builder inserts the newly-built instruction before the
375/// given position in the given MachineBasicBlock, and does NOT take a
376/// destination register.
377inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
378 MachineBasicBlock::iterator I,
379 const DebugLoc &DL,
380 const MCInstrDesc &MCID) {
381 MachineFunction &MF = *BB.getParent();
382 MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
383 BB.insert(I, MI);
384 return MachineInstrBuilder(MF, MI);
385}
386
387inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
388 MachineBasicBlock::instr_iterator I,
389 const DebugLoc &DL,
390 const MCInstrDesc &MCID) {
391 MachineFunction &MF = *BB.getParent();
392 MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
393 BB.insert(I, MI);
394 return MachineInstrBuilder(MF, MI);
395}
396
397inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr &I,
398 const DebugLoc &DL,
399 const MCInstrDesc &MCID) {
400 // Calling the overload for instr_iterator is always correct. However, the
401 // definition is not available in headers, so inline the check.
402 if (I.isInsideBundle())
403 return BuildMI(BB, MachineBasicBlock::instr_iterator(I), DL, MCID);
404 return BuildMI(BB, MachineBasicBlock::iterator(I), DL, MCID);
405}
406
407inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr *I,
408 const DebugLoc &DL,
409 const MCInstrDesc &MCID) {
410 return BuildMI(BB, *I, DL, MCID);
411}
412
413/// This version of the builder inserts the newly-built instruction at the end
414/// of the given MachineBasicBlock, and does NOT take a destination register.
415inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, const DebugLoc &DL,
416 const MCInstrDesc &MCID) {
417 return BuildMI(*BB, BB->end(), DL, MCID);
418}
419
420/// This version of the builder inserts the newly-built instruction at the
421/// end of the given MachineBasicBlock, and sets up the first operand as a
422/// destination virtual register.
423inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, const DebugLoc &DL,
424 const MCInstrDesc &MCID, Register DestReg) {
425 return BuildMI(*BB, BB->end(), DL, MCID, DestReg);
426}
427
428/// This version of the builder builds a DBG_VALUE intrinsic
429/// for either a value in a register or a register-indirect
430/// address. The convention is that a DBG_VALUE is indirect iff the
431/// second operand is an immediate.
432MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
433 const MCInstrDesc &MCID, bool IsIndirect,
434 Register Reg, const MDNode *Variable,
435 const MDNode *Expr);
436
437/// This version of the builder builds a DBG_VALUE intrinsic
438/// for a MachineOperand.
439MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
440 const MCInstrDesc &MCID, bool IsIndirect,
441 MachineOperand &MO, const MDNode *Variable,
442 const MDNode *Expr);
443
444/// This version of the builder builds a DBG_VALUE intrinsic
445/// for either a value in a register or a register-indirect
446/// address and inserts it at position I.
447MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
448 MachineBasicBlock::iterator I, const DebugLoc &DL,
449 const MCInstrDesc &MCID, bool IsIndirect,
450 Register Reg, const MDNode *Variable,
451 const MDNode *Expr);
452
453/// This version of the builder builds a DBG_VALUE intrinsic
454/// for a machine operand and inserts it at position I.
455MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
456 MachineBasicBlock::iterator I, const DebugLoc &DL,
457 const MCInstrDesc &MCID, bool IsIndirect,
458 MachineOperand &MO, const MDNode *Variable,
459 const MDNode *Expr);
460
461/// Clone a DBG_VALUE whose value has been spilled to FrameIndex.
462MachineInstr *buildDbgValueForSpill(MachineBasicBlock &BB,
463 MachineBasicBlock::iterator I,
464 const MachineInstr &Orig, int FrameIndex);
465
466/// Update a DBG_VALUE whose value has been spilled to FrameIndex. Useful when
467/// modifying an instruction in place while iterating over a basic block.
468void updateDbgValueForSpill(MachineInstr &Orig, int FrameIndex);
469
470inline unsigned getDefRegState(bool B) {
471 return B ? RegState::Define : 0;
472}
473inline unsigned getImplRegState(bool B) {
474 return B ? RegState::Implicit : 0;
475}
476inline unsigned getKillRegState(bool B) {
477 return B ? RegState::Kill : 0;
478}
479inline unsigned getDeadRegState(bool B) {
480 return B ? RegState::Dead : 0;
481}
482inline unsigned getUndefRegState(bool B) {
483 return B ? RegState::Undef : 0;
484}
485inline unsigned getInternalReadRegState(bool B) {
486 return B ? RegState::InternalRead : 0;
487}
488inline unsigned getDebugRegState(bool B) {
489 return B ? RegState::Debug : 0;
490}
491inline unsigned getRenamableRegState(bool B) {
492 return B ? RegState::Renamable : 0;
493}
494
495/// Get all register state flags from machine operand \p RegOp.
496inline unsigned getRegState(const MachineOperand &RegOp) {
497 assert(RegOp.isReg() && "Not a register operand")((RegOp.isReg() && "Not a register operand") ? static_cast
<void> (0) : __assert_fail ("RegOp.isReg() && \"Not a register operand\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 497, __PRETTY_FUNCTION__))
;
498 return getDefRegState(RegOp.isDef()) | getImplRegState(RegOp.isImplicit()) |
499 getKillRegState(RegOp.isKill()) | getDeadRegState(RegOp.isDead()) |
500 getUndefRegState(RegOp.isUndef()) |
501 getInternalReadRegState(RegOp.isInternalRead()) |
502 getDebugRegState(RegOp.isDebug()) |
503 getRenamableRegState(Register::isPhysicalRegister(RegOp.getReg()) &&
504 RegOp.isRenamable());
505}
506
507/// Helper class for constructing bundles of MachineInstrs.
508///
509/// MIBundleBuilder can create a bundle from scratch by inserting new
510/// MachineInstrs one at a time, or it can create a bundle from a sequence of
511/// existing MachineInstrs in a basic block.
512class MIBundleBuilder {
513 MachineBasicBlock &MBB;
514 MachineBasicBlock::instr_iterator Begin;
515 MachineBasicBlock::instr_iterator End;
516
517public:
518 /// Create an MIBundleBuilder that inserts instructions into a new bundle in
519 /// BB above the bundle or instruction at Pos.
520 MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator Pos)
521 : MBB(BB), Begin(Pos.getInstrIterator()), End(Begin) {}
522
523 /// Create a bundle from the sequence of instructions between B and E.
524 MIBundleBuilder(MachineBasicBlock &BB, MachineBasicBlock::iterator B,
525 MachineBasicBlock::iterator E)
526 : MBB(BB), Begin(B.getInstrIterator()), End(E.getInstrIterator()) {
527 assert(B != E && "No instructions to bundle")((B != E && "No instructions to bundle") ? static_cast
<void> (0) : __assert_fail ("B != E && \"No instructions to bundle\""
, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include/llvm/CodeGen/MachineInstrBuilder.h"
, 527, __PRETTY_FUNCTION__))
;
528 ++B;
529 while (B != E) {
530 MachineInstr &MI = *B;
531 ++B;
532 MI.bundleWithPred();
533 }
534 }
535
536 /// Create an MIBundleBuilder representing an existing instruction or bundle
537 /// that has MI as its head.
538 explicit MIBundleBuilder(MachineInstr *MI)
539 : MBB(*MI->getParent()), Begin(MI),
540 End(getBundleEnd(MI->getIterator())) {}
541
542 /// Return a reference to the basic block containing this bundle.
543 MachineBasicBlock &getMBB() const { return MBB; }
544
545 /// Return true if no instructions have been inserted in this bundle yet.
546 /// Empty bundles aren't representable in a MachineBasicBlock.
547 bool empty() const { return Begin == End; }
548
549 /// Return an iterator to the first bundled instruction.
550 MachineBasicBlock::instr_iterator begin() const { return Begin; }
551
552 /// Return an iterator beyond the last bundled instruction.
553 MachineBasicBlock::instr_iterator end() const { return End; }
554
555 /// Insert MI into this bundle before I which must point to an instruction in
556 /// the bundle, or end().
557 MIBundleBuilder &insert(MachineBasicBlock::instr_iterator I,
558 MachineInstr *MI) {
559 MBB.insert(I, MI);
560 if (I == Begin) {
561 if (!empty())
562 MI->bundleWithSucc();
563 Begin = MI->getIterator();
564 return *this;
565 }
566 if (I == End) {
567 MI->bundleWithPred();
568 return *this;
569 }
570 // MI was inserted in the middle of the bundle, so its neighbors' flags are
571 // already fine. Update MI's bundle flags manually.
572 MI->setFlag(MachineInstr::BundledPred);
573 MI->setFlag(MachineInstr::BundledSucc);
574 return *this;
575 }
576
577 /// Insert MI into MBB by prepending it to the instructions in the bundle.
578 /// MI will become the first instruction in the bundle.
579 MIBundleBuilder &prepend(MachineInstr *MI) {
580 return insert(begin(), MI);
581 }
582
583 /// Insert MI into MBB by appending it to the instructions in the bundle.
584 /// MI will become the last instruction in the bundle.
585 MIBundleBuilder &append(MachineInstr *MI) {
586 return insert(end(), MI);
587 }
588};
589
590} // end namespace llvm
591
592#endif // LLVM_CODEGEN_MACHINEINSTRBUILDER_H