44#define DEBUG_TYPE "opt-addr-mode"
63 StringRef getPassName()
const override {
64 return "Optimize addressing mode of load/store";
67 void getAnalysisUsage(AnalysisUsage &AU)
const override {
70 AU.
addRequired<MachineDominanceFrontierWrapperPass>();
77 using MISetType = DenseSet<MachineInstr *>;
78 using InstrEvalMap = DenseMap<MachineInstr *, bool>;
79 DenseSet<MachineInstr *> ProcessedAddiInsts;
81 MachineRegisterInfo *MRI =
nullptr;
82 const TargetRegisterInfo *TRI =
nullptr;
83 const HexagonInstrInfo *HII =
nullptr;
84 const HexagonRegisterInfo *HRI =
nullptr;
85 MachineDominatorTree *MDT =
nullptr;
86 DataFlowGraph *DFG =
nullptr;
87 Liveness *LV =
nullptr;
91 bool xformUseMI(MachineInstr *TfrMI, MachineInstr *
UseMI,
92 NodeAddr<UseNode *> UseN,
unsigned UseMOnum);
93 bool processAddBases(NodeAddr<StmtNode *> AddSN, MachineInstr *AddMI);
94 bool usedInLoadStore(NodeAddr<StmtNode *> CurrentInstSN, int64_t NewOffset);
95 bool findFirstReachedInst(
97 std::vector<std::pair<NodeAddr<StmtNode *>, NodeAddr<UseNode *>>>
99 NodeAddr<StmtNode *> &UseSN);
100 bool updateAddBases(MachineInstr *CurrentMI, MachineInstr *FirstReachedMI,
102 bool processAddUses(NodeAddr<StmtNode *> AddSN, MachineInstr *AddMI,
104 bool updateAddUses(MachineInstr *AddMI, MachineInstr *
UseMI);
105 bool analyzeUses(
unsigned DefR,
const NodeList &UNodeList,
106 InstrEvalMap &InstrEvalResult,
short &SizeInc);
107 bool hasRepForm(MachineInstr &
MI,
unsigned TfrDefR);
108 bool canRemoveAddasl(NodeAddr<StmtNode *> AddAslSN, MachineInstr &
MI,
110 bool isSafeToExtLR(NodeAddr<StmtNode *> SN, MachineInstr *
MI,
113 bool allValidCandidates(NodeAddr<StmtNode *> SA,
NodeList &UNodeList);
114 short getBaseWithLongOffset(
const MachineInstr &
MI)
const;
115 bool changeStore(MachineInstr *OldMI, MachineOperand ImmOp,
117 bool changeLoad(MachineInstr *OldMI, MachineOperand ImmOp,
unsigned ImmOpNum);
118 bool changeAddAsl(NodeAddr<UseNode *> AddAslUN, MachineInstr *AddAslMI,
119 const MachineOperand &ImmOp,
unsigned ImmOpNum);
120 bool isValidOffset(MachineInstr *
MI,
int Offset);
121 unsigned getBaseOpPosition(MachineInstr *
MI);
122 unsigned getOffsetOpPosition(MachineInstr *
MI);
127char HexagonOptAddrMode::ID = 0;
130 "Optimize addressing mode",
false,
false)
136bool HexagonOptAddrMode::hasRepForm(
MachineInstr &
MI,
unsigned TfrDefR) {
143 MachineOperand StOp = MI.getOperand(MI.getNumOperands() - 1);
144 if (StOp.isReg() && StOp.getReg() == TfrDefR)
150 return (HII->changeAddrMode_rr_ur(
MI) >= 0);
153 return (HII->changeAddrMode_io_abs(
MI) >= 0);
172 const MachineOperand &
OffsetOp =
MI.getOperand(3);
176 Register OffsetReg =
MI.getOperand(2).getReg();
177 RegisterRef OffsetRR;
179 for (NodeAddr<UseNode *> UA : AddAslSN.
Addr->members_if(DFG->
IsUse, *DFG)) {
180 RegisterRef RR = UA.Addr->getRegRef(*DFG);
181 if (OffsetReg == RR.
asMCReg()) {
183 OffsetRegRD = UA.Addr->getReachingDef();
187 for (
auto I = UNodeList.rbegin(),
E = UNodeList.rend();
I !=
E; ++
I) {
188 NodeAddr<UseNode *> UA = *
I;
189 NodeAddr<InstrNode *>
IA = UA.
Addr->getOwner(*DFG);
193 if ((DFG->
IsDef(AA) && AA.
Id != OffsetRegRD) ||
194 AA.
Addr->getReachingDef() != OffsetRegRD)
197 MachineInstr &
UseMI = *NodeAddr<StmtNode *>(IA).Addr->getCode();
198 NodeAddr<DefNode *> OffsetRegDN = DFG->
addr<DefNode *>(OffsetRegRD);
201 MI.getParent() !=
UseMI.getParent())
204 const MCInstrDesc &UseMID =
UseMI.getDesc();
207 getBaseWithLongOffset(
UseMI) < 0)
215 for (
auto &Mo :
UseMI.operands())
220 if (!
UseMI.getParent()->isLiveIn(OffsetReg) &&
223 <<
" is NOT live in to MBB "
224 <<
UseMI.getParent()->getName() <<
"\n");
231bool HexagonOptAddrMode::allValidCandidates(NodeAddr<StmtNode *> SA,
233 for (
auto I = UNodeList.rbegin(),
E = UNodeList.rend();
I !=
E; ++
I) {
234 NodeAddr<UseNode *> UN = *
I;
235 RegisterRef UR = UN.
Addr->getRegRef(*DFG);
240 dbgs() <<
"*** Unable to collect all reaching defs for use ***\n"
241 << PrintNode<UseNode*>(UN, *DFG) <<
'\n'
242 <<
"The program's complexity may exceed the limits.\n";
246 const auto &ReachingDefs =
P.first;
247 if (ReachingDefs.size() > 1) {
249 dbgs() <<
"*** Multiple Reaching Defs found!!! ***\n";
250 for (
auto DI : ReachingDefs) {
251 NodeAddr<UseNode *>
DA = DFG->
addr<UseNode *>(DI);
252 NodeAddr<StmtNode *> TempIA =
DA.Addr->getOwner(*DFG);
253 dbgs() <<
"\t\t[Reaching Def]: "
263void HexagonOptAddrMode::getAllRealUses(NodeAddr<StmtNode *> SA,
265 for (NodeAddr<DefNode *> DA : SA.
Addr->members_if(DFG->
IsDef, *DFG)) {
267 <<
Print<NodeAddr<DefNode *>>(DA, *DFG) <<
"\n");
268 RegisterRef DR =
DA.Addr->getRegRef(*DFG);
272 for (
auto UI : UseSet) {
273 NodeAddr<UseNode *> UA = DFG->
addr<UseNode *>(UI);
275 NodeAddr<StmtNode *> TempIA = UA.
Addr->getOwner(*DFG);
276 dbgs() <<
"\t\t\t[Reached Use]: "
281 NodeAddr<PhiNode *> PA = UA.
Addr->getOwner(*DFG);
286 if (!phiUse.
empty()) {
287 for (
auto I : phiUse) {
290 auto phiUseSet =
I.second;
291 for (
auto phiUI : phiUseSet) {
292 NodeAddr<UseNode *> phiUA = DFG->
addr<UseNode *>(phiUI.first);
293 UNodeList.push_back(phiUA);
298 UNodeList.push_back(UA);
303bool HexagonOptAddrMode::isSafeToExtLR(NodeAddr<StmtNode *> SN,
310 for (NodeAddr<UseNode *> UA : SN.
Addr->members_if(DFG->
IsUse, *DFG)) {
311 RegisterRef RR = UA.
Addr->getRegRef(*DFG);
312 if (LRExtReg == RR.
asMCReg()) {
314 LRExtRegRD = UA.
Addr->getReachingDef();
318 for (
auto I = UNodeList.rbegin(),
E = UNodeList.rend();
I !=
E; ++
I) {
319 NodeAddr<UseNode *> UA = *
I;
320 NodeAddr<InstrNode *>
IA = UA.
Addr->getOwner(*DFG);
326 if ((DFG->
IsDef(AA) && AA.
Id != LRExtRegRD) ||
327 AA.
Addr->getReachingDef() != LRExtRegRD) {
329 dbgs() <<
"isSafeToExtLR: Returning false; another reaching def\n");
339 MachineInstr *
UseMI = NodeAddr<StmtNode *>(IA).Addr->getCode();
340 NodeAddr<DefNode *> LRExtRegDN = DFG->
addr<DefNode *>(LRExtRegRD);
349 <<
" is NOT live in to MBB "
357bool HexagonOptAddrMode::isValidOffset(MachineInstr *
MI,
int Offset) {
361 switch (
MI->getOpcode()) {
362 case Hexagon::V6_vgathermh_pseudo:
363 case Hexagon::V6_vgathermw_pseudo:
364 case Hexagon::V6_vgathermhw_pseudo:
365 case Hexagon::V6_vgathermhq_pseudo:
366 case Hexagon::V6_vgathermwq_pseudo:
367 case Hexagon::V6_vgathermhwq_pseudo:
373 if ((AlignMask &
Offset) == 0)
383 unsigned AlignMask = 0;
385 case HexagonII::MemAccessSize::DoubleWordAccess:
388 case HexagonII::MemAccessSize::WordAccess:
391 case HexagonII::MemAccessSize::HalfWordAccess:
394 case HexagonII::MemAccessSize::ByteAccess:
401 if ((AlignMask &
Offset) != 0)
406unsigned HexagonOptAddrMode::getBaseOpPosition(MachineInstr *
MI) {
407 const MCInstrDesc &MID =
MI->getDesc();
408 switch (
MI->getOpcode()) {
412 case Hexagon::V6_vgathermh_pseudo:
413 case Hexagon::V6_vgathermw_pseudo:
414 case Hexagon::V6_vgathermhw_pseudo:
415 case Hexagon::V6_vgathermhq_pseudo:
416 case Hexagon::V6_vgathermwq_pseudo:
417 case Hexagon::V6_vgathermhwq_pseudo:
424unsigned HexagonOptAddrMode::getOffsetOpPosition(MachineInstr *
MI) {
427 "Looking for an offset in non-BaseImmOffset addressing mode instruction");
429 const MCInstrDesc &MID =
MI->getDesc();
430 switch (
MI->getOpcode()) {
434 case Hexagon::V6_vgathermh_pseudo:
435 case Hexagon::V6_vgathermw_pseudo:
436 case Hexagon::V6_vgathermhw_pseudo:
437 case Hexagon::V6_vgathermhq_pseudo:
438 case Hexagon::V6_vgathermwq_pseudo:
439 case Hexagon::V6_vgathermhwq_pseudo:
446bool HexagonOptAddrMode::usedInLoadStore(NodeAddr<StmtNode *> CurrentInstSN,
451 bool FoundLoadStoreUse =
false;
452 for (NodeAddr<UseNode *> UN : LoadStoreUseList) {
453 NodeAddr<StmtNode *> SN = UN.
Addr->getOwner(*DFG);
454 MachineInstr *LoadStoreMI = SN.
Addr->getCode();
455 const MCInstrDesc &MID = LoadStoreMI->
getDesc();
457 isValidOffset(LoadStoreMI, NewOffset)) {
458 FoundLoadStoreUse =
true;
462 return FoundLoadStoreUse;
465bool HexagonOptAddrMode::findFirstReachedInst(
467 std::vector<std::pair<NodeAddr<StmtNode *>, NodeAddr<UseNode *>>> &AddiList,
468 NodeAddr<StmtNode *> &UseSN) {
481 MachineBasicBlock *CurrentMBB = AddMI->
getParent();
482 for (
auto &InstIter : *CurrentMBB) {
484 if (InstIter.getOpcode() == Hexagon::A2_addi) {
485 auto Iter =
llvm::find_if(AddiList, [&InstIter](
const auto &SUPair) {
486 return SUPair.first.Addr->getCode() == &InstIter;
488 if (Iter != AddiList.end()) {
522bool HexagonOptAddrMode::processAddBases(NodeAddr<StmtNode *> AddSN,
523 MachineInstr *AddMI) {
527 LLVM_DEBUG(
dbgs() <<
"\n\t\t[Processing Addi]: " << *AddMI <<
"\n");
530 [](
const MachineInstr *
MI,
531 const DenseSet<MachineInstr *> &ProcessedAddiInsts) ->
bool {
534 LLVM_DEBUG(
dbgs() <<
"\t\t\tAddi already found in ProcessedAddiInsts: "
535 << *
MI <<
"\n\t\t\tSkipping...");
541 if (Processed(AddMI, ProcessedAddiInsts))
543 ProcessedAddiInsts.
insert(AddMI);
550 std::vector<std::pair<NodeAddr<StmtNode *>, NodeAddr<UseNode *>>> AddiList;
554 for (NodeAddr<UseNode *> UA : AddSN.
Addr->members_if(DFG->
IsUse, *DFG)) {
555 RegisterRef URR = UA.
Addr->getRegRef(*DFG);
559 UAReachingDefID = UA.
Addr->getReachingDef();
560 NodeAddr<DefNode *> UADef = DFG->
addr<DefNode *>(UAReachingDefID);
562 LLVM_DEBUG(
dbgs() <<
"\t\t\t Could not find reachingDef. Skipping...\n");
567 NodeAddr<DefNode *> UAReachingDef = DFG->
addr<DefNode *>(UAReachingDefID);
568 NodeAddr<StmtNode *> ReachingDefStmt = UAReachingDef.
Addr->getOwner(*DFG);
572 MachineInstr *ReachingDefInstr = ReachingDefStmt.Addr->getCode();
581 for (NodeAddr<UseNode *> UN : AddiUseList) {
582 NodeAddr<StmtNode *> SN = UN.
Addr->getOwner(*DFG);
583 MachineInstr *
MI = SN.
Addr->getCode();
586 if (
MI->getOpcode() == Hexagon::A2_addi &&
587 !(
MI != AddMI && Processed(
MI, ProcessedAddiInsts))) {
588 AddiList.push_back({SN, UN});
596 if (AddiList.size() <= 1)
599 NodeAddr<StmtNode *> FirstReachedUseSN;
601 if (!findFirstReachedInst(AddMI, AddiList, FirstReachedUseSN))
607 NodeAddr<DefNode *> FirstReachedUseDN =
608 FirstReachedUseSN.
Addr->members_if(DFG->
IsDef, *DFG).front();
610 MachineInstr *FirstReachedMI = FirstReachedUseSN.
Addr->getCode();
611 const MachineOperand FirstReachedMIImmOp = FirstReachedMI->
getOperand(2);
612 if (!FirstReachedMIImmOp.
isImm())
615 for (
auto &
I : AddiList) {
616 NodeAddr<StmtNode *> CurrentInstSN =
I.first;
617 NodeAddr<UseNode *> CurrentInstUN =
I.second;
619 MachineInstr *CurrentMI = CurrentInstSN.
Addr->getCode();
620 MachineOperand &CurrentMIImmOp = CurrentMI->
getOperand(2);
626 if (!CurrentMIImmOp.
isImm())
629 NewOffset = CurrentMIImmOp.
getImm() - FirstReachedMIImmOp.
getImm();
632 if (CurrentMI == FirstReachedMI) {
646 if (!usedInLoadStore(CurrentInstSN, NewOffset))
651 RegisterRef FirstReachedDefRR = FirstReachedUseDN.
Addr->getRegRef(*DFG);
652 NodeAddr<InstrNode *> CurrentAddiIN = CurrentInstUN.
Addr->getOwner(*DFG);
653 NodeAddr<RefNode *> NearestAA =
655 if ((DFG->
IsDef(NearestAA) && NearestAA.
Id != FirstReachedUseDN.
Id) ||
656 (!DFG->
IsDef(NearestAA) &&
657 NearestAA.
Addr->getReachingDef() != FirstReachedUseDN.
Id)) {
659 LLVM_DEBUG(
dbgs() <<
"\t\t\tCould not modify below Addi since the first "
660 "defined Addi register was redefined\n");
664 MachineOperand CurrentMIBaseOp = CurrentMI->
getOperand(1);
671 Changed |= updateAddBases(CurrentMI, FirstReachedMI, NewOffset);
674 CurrentInstUN.
Addr->linkToDef(CurrentInstUN.
Id, FirstReachedUseDN);
680bool HexagonOptAddrMode::updateAddBases(MachineInstr *CurrentMI,
681 MachineInstr *FirstReachedMI,
683 LLVM_DEBUG(
dbgs() <<
"[About to modify the Addi]: " << *CurrentMI <<
"\n");
684 const MachineOperand FirstReachedDef = FirstReachedMI->
getOperand(0);
687 MachineOperand &CurrentMIBaseOp = CurrentMI->
getOperand(1);
688 MachineOperand &CurrentMIImmOp = CurrentMI->
getOperand(2);
690 CurrentMIBaseOp.
setReg(FirstDefRegister);
693 CurrentMIImmOp.
setImm(NewOffset);
704 I->clearRegisterKills(FirstDefRegister,
TRI);
706 ProcessedAddiInsts.
insert(CurrentMI);
710bool HexagonOptAddrMode::processAddUses(NodeAddr<StmtNode *> AddSN,
716 for (
auto I = UNodeList.rbegin(),
E = UNodeList.rend();
I !=
E; ++
I) {
717 NodeAddr<UseNode *> UN = *
I;
718 NodeAddr<StmtNode *> SN = UN.
Addr->getOwner(*DFG);
719 MachineInstr *
MI = SN.
Addr->getCode();
720 const MCInstrDesc &MID =
MI->getDesc();
725 MachineOperand BaseOp =
MI->getOperand(getBaseOpPosition(
MI));
730 MachineOperand
OffsetOp =
MI->getOperand(getOffsetOpPosition(
MI));
735 if (!isValidOffset(
MI, newOffset))
748 if (!isSafeToExtLR(AddSN, AddMI, BaseReg, UNodeList))
754 for (NodeAddr<UseNode *> UA : AddSN.
Addr->members_if(DFG->
IsUse, *DFG)) {
755 RegisterRef RR = UA.
Addr->getRegRef(*DFG);
757 LRExtRegRD = UA.
Addr->getReachingDef();
763 for (
auto I = UNodeList.rbegin(),
E = UNodeList.rend();
I !=
E; ++
I) {
764 NodeAddr<UseNode *> UseN = *
I;
766 "Found a PhiRef node as a real reached use!!");
768 NodeAddr<StmtNode *> OwnerN = UseN.
Addr->getOwner(*DFG);
769 MachineInstr *
UseMI = OwnerN.
Addr->getCode();
771 <<
">]: " << *
UseMI <<
"\n");
777 NodeAddr<DefNode *> LRExtRegDN = DFG->
addr<DefNode *>(LRExtRegRD);
778 UseN.
Addr->linkToDef(UseN.
Id, LRExtRegDN);
787bool HexagonOptAddrMode::updateAddUses(MachineInstr *AddMI,
788 MachineInstr *
UseMI) {
789 const MachineOperand ImmOp = AddMI->
getOperand(2);
790 const MachineOperand AddRegOp = AddMI->
getOperand(1);
803bool HexagonOptAddrMode::analyzeUses(
unsigned tfrDefR,
805 InstrEvalMap &InstrEvalResult,
807 bool KeepTfr =
false;
808 bool HasRepInstr =
false;
809 InstrEvalResult.clear();
811 for (
auto I = UNodeList.rbegin(),
E = UNodeList.rend();
I !=
E; ++
I) {
812 bool CanBeReplaced =
false;
813 NodeAddr<UseNode *> UN = *
I;
814 NodeAddr<StmtNode *> SN = UN.
Addr->getOwner(*DFG);
815 MachineInstr &
MI = *SN.
Addr->getCode();
816 const MCInstrDesc &MID =
MI.getDesc();
818 if (!hasRepForm(
MI, tfrDefR)) {
823 CanBeReplaced =
true;
824 }
else if (
MI.getOpcode() == Hexagon::S2_addasl_rrri) {
830 if (allValidCandidates(SN, AddaslUseList) &&
831 canRemoveAddasl(SN,
MI, AddaslUseList)) {
832 SizeInc += AddaslUseList.size();
834 CanBeReplaced =
true;
844 InstrEvalResult[&
MI] = CanBeReplaced;
845 HasRepInstr |= CanBeReplaced;
855bool HexagonOptAddrMode::changeLoad(MachineInstr *OldMI, MachineOperand ImmOp,
858 MachineBasicBlock *BB = OldMI->
getParent();
864 MachineInstrBuilder MIB;
869 assert(NewOpCode >= 0 &&
"Invalid New opcode\n");
880 assert(NewOpCode >= 0 &&
"Invalid New opcode\n");
883 const GlobalValue *GV = ImmOp.
getGlobal();
894 }
else if (ImmOpNum == 2) {
897 assert(NewOpCode >= 0 &&
"Invalid New opcode\n");
910 for (
unsigned i = OpStart; i < OpEnd; ++i)
916bool HexagonOptAddrMode::changeStore(MachineInstr *OldMI, MachineOperand ImmOp,
919 unsigned OpStart = 0;
921 MachineBasicBlock *BB = OldMI->
getParent();
925 MachineInstrBuilder MIB;
929 assert(NewOpCode >= 0 &&
"Invalid New opcode\n");
939 assert(NewOpCode >= 0 &&
"Invalid New opcode\n");
941 const GlobalValue *GV = ImmOp.
getGlobal();
950 assert(NewOpCode >= 0 &&
"Invalid New opcode\n");
961 for (
unsigned i = OpStart; i < OpEnd; ++i)
968short HexagonOptAddrMode::getBaseWithLongOffset(
const MachineInstr &
MI)
const {
976bool HexagonOptAddrMode::changeAddAsl(NodeAddr<UseNode *> AddAslUN,
977 MachineInstr *AddAslMI,
978 const MachineOperand &ImmOp,
980 NodeAddr<StmtNode *> SA = AddAslUN.
Addr->getOwner(*DFG);
987 for (
auto I = UNodeList.rbegin(),
E = UNodeList.rend();
I !=
E; ++
I) {
988 NodeAddr<UseNode *> UseUN = *
I;
990 "Can't transform this 'AddAsl' instruction!");
992 NodeAddr<StmtNode *> UseIA = UseUN.
Addr->getOwner(*DFG);
994 <<
Print<NodeAddr<InstrNode *>>(UseIA, *DFG) <<
"\n");
995 MachineInstr *
UseMI = UseIA.
Addr->getCode();
997 <<
">]: " << *
UseMI <<
"\n");
1003 short NewOpCode = getBaseWithLongOffset(*
UseMI);
1004 assert(NewOpCode >= 0 &&
"Invalid New opcode\n");
1010 MachineInstrBuilder MIB =
1017 const GlobalValue *GV = ImmOp.
getGlobal();
1024 const GlobalValue *GV = ImmOp.
getGlobal();
1032 for (
unsigned i = OpStart; i < OpEnd; ++i)
1040bool HexagonOptAddrMode::xformUseMI(MachineInstr *TfrMI, MachineInstr *
UseMI,
1041 NodeAddr<UseNode *> UseN,
1042 unsigned UseMOnum) {
1043 const MachineOperand ImmOp = TfrMI->
getOperand(1);
1059bool HexagonOptAddrMode::processBlock(NodeAddr<BlockNode *> BA) {
1062 for (
auto IA : BA.
Addr->members(*DFG)) {
1066 NodeAddr<StmtNode *> SA =
IA;
1067 MachineInstr *
MI = SA.
Addr->getCode();
1068 if ((
MI->getOpcode() != Hexagon::A2_tfrsi ||
1069 !
MI->getOperand(1).isGlobal()) &&
1070 (
MI->getOpcode() != Hexagon::A2_addi ||
1075 <<
"]: " << *
MI <<
"\n\t[InstrNode]: "
1076 <<
Print<NodeAddr<InstrNode *>>(IA, *DFG) <<
'\n');
1078 if (
MI->getOpcode() == Hexagon::A2_addi)
1083 if (!allValidCandidates(SA, UNodeList))
1096 if (
MI->getOpcode() == Hexagon::A2_addi) {
1097 Changed |= processAddUses(SA,
MI, UNodeList);
1103 InstrEvalMap InstrEvalResult;
1107 if (!analyzeUses(DefR, UNodeList, InstrEvalResult, SizeInc))
1112 bool KeepTfr =
false;
1114 LLVM_DEBUG(
dbgs() <<
"\t[Total reached uses] : " << UNodeList.size()
1117 for (
auto I = UNodeList.rbegin(),
E = UNodeList.rend();
I !=
E; ++
I) {
1118 NodeAddr<UseNode *> UseN = *
I;
1120 "Found a PhiRef node as a real reached use!!");
1122 NodeAddr<StmtNode *> OwnerN = UseN.
Addr->getOwner(*DFG);
1123 MachineInstr *
UseMI = OwnerN.
Addr->getCode();
1125 <<
">]: " << *
UseMI <<
"\n");
1129 for (
unsigned j = 0;
j < NumOperands - 1; ++
j) {
1131 if (
op.isReg() &&
op.isUse() && DefR ==
op.getReg())
1140 bool Xformed =
false;
1141 if (UseMOnum >= 0 && InstrEvalResult[
UseMI])
1142 Xformed = xformUseMI(
MI,
UseMI, UseN, UseMOnum);
1144 KeepTfr |= !Xformed;
1160 <<
": too many basic blocks\n");
1168 HII = HST.getInstrInfo();
1169 HRI = HST.getRegisterInfo();
1170 const auto &MDF = getAnalysis<MachineDominanceFrontierWrapperPass>().getMDF();
1171 MDT = &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
1173 DataFlowGraph
G(MF, *HII, *HRI, *MDT, MDF);
1179 Liveness
L(*
MRI, *DFG);
1184 ProcessedAddiInsts.
clear();
1185 NodeAddr<FuncNode *> FA = DFG->
getFunc();
1187 <<
Print<NodeAddr<FuncNode *>>(FA, *DFG) <<
"\n");
1189 for (NodeAddr<BlockNode *> BA : FA.
Addr->members(*DFG))
1193 MI->eraseFromParent();
1214 constexpr unsigned MaxLiveInSweeps = 8;
1215 for (
unsigned Sweep = 0; Sweep != MaxLiveInSweeps; ++Sweep) {
1216 bool AnyChanged =
false;
1217 for (MachineBasicBlock *
MBB : Candidates)
1234 return new HexagonOptAddrMode();
MachineInstrBuilder & UseMI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file defines the DenseMap class.
This file defines the DenseSet and SmallDenseSet classes.
static cl::opt< int > CodeGrowthLimit("hexagon-amode-growth-limit", cl::Hidden, cl::init(0), cl::desc("Code growth limit for address mode " "optimization"))
cl::opt< unsigned > RDFFuncBlockLimit
static void getAllRealUses(NodeAddr< DefNode * > DA, NodeSet &UNodeSet, Liveness *L, DataFlowGraph *G, bool comprehensive=false)
std::pair< Instruction::BinaryOps, Value * > OffsetOp
Find all possible pairs (BinOp, RHS) that BinOp V, RHS can be simplified.
This file implements the LivePhysRegs utility for tracking liveness of physical registers.
Register const TargetRegisterInfo * TRI
Promote Memory to Register
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.
MachineRegisterInfo & MRI
static bool processBlock(MachineBasicBlock &MBB, const SystemZInstrInfo *TII, const TargetRegisterInfo *TRI)
AnalysisUsage & addRequired()
void setPreservesAll()
Set by analyses that do not transform their input at all.
FunctionPass class - This class is used to implement most global optimizations.
bool isPredicated(const MachineInstr &MI) const override
Returns true if the instruction is already predicated.
unsigned getAddrMode(const MachineInstr &MI) const
bool isConstExtended(const MachineInstr &MI) const
short changeAddrMode_rr_ur(short Opc) const
unsigned getMemAccessSize(const MachineInstr &MI) const
short changeAddrMode_io_abs(short Opc) const
short changeAddrMode_rr_io(short Opc) const
bool isHVXVec(const MachineInstr &MI) const
short changeAddrMode_io_rr(short Opc) const
bool isValidOffset(unsigned Opcode, int Offset, bool Extend=true) const
Describe properties that are true of each instruction in the target description file.
bool mayStore() const
Return true if this instruction could possibly modify memory.
bool mayLoad() const
Return true if this instruction could possibly read memory.
bool isEHPad() const
Returns true if the block is a landing pad.
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
LLVM_ABI bool isEntryBlock() const
Returns true if this is the entry block of the function.
Instructions::iterator instr_iterator
MachineInstrBundleIterator< MachineInstr > iterator
LLVM_ABI StringRef getName() const
Return the name of the corresponding LLVM basic block, or an empty string.
LLVM_ABI bool isLiveIn(MCRegister Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
Analysis pass which computes a MachineDominatorTree.
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
Register getReg(unsigned Idx) const
Get the register for the operand index.
const MachineInstrBuilder & add(const MachineOperand &MO) const
const MachineInstrBuilder & addGlobalAddress(const GlobalValue *GV, int64_t Offset=0, unsigned TargetFlags=0) const
Representation of each machine instruction.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
const MachineBasicBlock * getParent() const
unsigned getNumOperands() const
Retuns the total number of operands.
const MCInstrDesc & getDesc() const
Returns the target instruction descriptor of this MachineInstr.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
const MachineOperand & getOperand(unsigned i) const
const GlobalValue * getGlobal() const
void setImplicit(bool Val=true)
void setImm(int64_t immVal)
bool isReg() const
isReg - Tests if this is a MO_Register operand.
LLVM_ABI void setReg(Register Reg)
Change the register this operand corresponds to.
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
unsigned getTargetFlags() const
void setIsUndef(bool Val=true)
Register getReg() const
getReg - Returns the register number.
int64_t getOffset() const
Return the offset from the symbol in this operand.
void push_back(const T &Elt)
virtual const TargetRegisterInfo * getRegisterInfo() const =0
Return the target's register information.
std::pair< iterator, bool > insert(const ValueT &V)
bool contains(const_arg_type_t< ValueT > V) const
Check if the set contains the given element.
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
initializer< Ty > init(const Ty &Val)
Print(const T &, const DataFlowGraph &) -> Print< T >
std::set< NodeId > NodeSet
SmallVector< Node, 4 > NodeList
BaseReg
Stack frame base register. Bit 0 of FREInfo.Info.
This is an optimization pass for GlobalISel generic memory operations.
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
auto post_order(const T &G)
Post-order traversal of a graph.
FunctionPass * createHexagonOptAddrMode()
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
LLVM_ABI Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
static bool recomputeLiveIns(MachineBasicBlock &MBB)
Convenience function for recomputing live-in's for a MBB.
static bool IsDef(const Node BA)
static bool IsUse(const Node BA)
const PhysicalRegisterInfo & getPRI() const
static bool IsCode(const Node BA)
NodeAddr< T > addr(NodeId N) const
const RefMap & getRealUses(NodeId P) const
LLVM_ABI NodeAddr< RefNode * > getNearestAliasedRef(RegisterRef RefRR, NodeAddr< InstrNode * > IA)
Find the nearest ref node aliased to RefRR, going upwards in the data flow, starting from the instruc...
DenseMap< RegisterId, NodeRefSet > RefMap
LLVM_ABI std::pair< NodeSet, bool > getAllReachingDefsRec(RegisterRef RefRR, NodeAddr< RefNode * > RefA, NodeSet &Visited, const NodeSet &Defs)
LLVM_ABI NodeSet getAllReachedUses(RegisterRef RefRR, NodeAddr< DefNode * > DefA, const RegisterAggr &DefRRs)
LLVM_ABI bool alias(RegisterRef RA, RegisterRef RB) const
constexpr MCRegister asMCReg() const