1 //===--- HexagonExpandCondsets.cpp ----------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Replace mux instructions with the corresponding legal instructions.
11 // It is meant to work post-SSA, but still on virtual registers. It was
12 // originally placed between register coalescing and machine instruction
14 // In this place in the optimization sequence, live interval analysis had
15 // been performed, and the live intervals should be preserved. A large part
16 // of the code deals with preserving the liveness information.
18 // Liveness tracking aside, the main functionality of this pass is divided
19 // into two steps. The first step is to replace an instruction
20 // vreg0 = C2_mux vreg1, vreg2, vreg3
21 // with a pair of conditional transfers
22 // vreg0 = A2_tfrt vreg1, vreg2
23 // vreg0 = A2_tfrf vreg1, vreg3
24 // It is the intention that the execution of this pass could be terminated
25 // after this step, and the code generated would be functionally correct.
27 // If the uses of the source values vreg1 and vreg2 are kills, and their
28 // definitions are predicable, then in the second step, the conditional
29 // transfers will then be rewritten as predicated instructions. E.g.
30 // vreg0 = A2_or vreg1, vreg2
31 // vreg3 = A2_tfrt vreg99, vreg0<kill>
32 // will be rewritten as
33 // vreg3 = A2_port vreg99, vreg1, vreg2
35 // This replacement has two variants: "up" and "down". Consider this case:
36 // vreg0 = A2_or vreg1, vreg2
37 // ... [intervening instructions] ...
38 // vreg3 = A2_tfrt vreg99, vreg0<kill>
40 // vreg3 = A2_port vreg99, vreg1, vreg2
41 // ... [intervening instructions, vreg0->vreg3] ...
45 // ... [intervening instructions] ...
46 // vreg3 = A2_port vreg99, vreg1, vreg2
48 // Both, one or none of these variants may be valid, and checks are made
49 // to rule out inapplicable variants.
51 // As an additional optimization, before either of the two steps above is
52 // executed, the pass attempts to coalesce the target register with one of
53 // the source registers, e.g. given an instruction
54 // vreg3 = C2_mux vreg0, vreg1, vreg2
55 // vreg3 will be coalesced with either vreg1 or vreg2. If this succeeds,
56 // the instruction would then be (for example)
57 // vreg3 = C2_mux vreg0, vreg3, vreg2
58 // and, under certain circumstances, this could result in only one predicated
60 // vreg3 = A2_tfrf vreg0, vreg2
63 // Splitting a definition of a register into two predicated transfers
64 // creates a complication in liveness tracking. Live interval computation
65 // will see both instructions as actual definitions, and will mark the
66 // first one as dead. The definition is not actually dead, and this
67 // situation will need to be fixed. For example:
68 // vreg1<def,dead> = A2_tfrt ... ; marked as dead
69 // vreg1<def> = A2_tfrf ...
71 // Since any of the individual predicated transfers may end up getting
72 // removed (in case it is an identity copy), some pre-existing def may
73 // be marked as dead after live interval recomputation:
74 // vreg1<def,dead> = ... ; marked as dead
76 // vreg1<def> = A2_tfrf ... ; if A2_tfrt is removed
77 // This case happens if vreg1 was used as a source in A2_tfrt, which means
78 // that is it actually live at the A2_tfrf, and so the now dead definition
79 // of vreg1 will need to be updated to non-dead at some point.
81 // This issue could be remedied by adding implicit uses to the predicated
82 // transfers, but this will create a problem with subsequent predication,
83 // since the transfers will no longer be possible to reorder. To avoid
84 // that, the initial splitting will not add any implicit uses. These
85 // implicit uses will be added later, after predication. The extra price,
86 // however, is that finding the locations where the implicit uses need
87 // to be added, and updating the live ranges will be more involved.
89 #define DEBUG_TYPE "expand-condsets"
91 #include "HexagonInstrInfo.h"
92 #include "llvm/ADT/DenseMap.h"
93 #include "llvm/ADT/SetVector.h"
94 #include "llvm/ADT/SmallVector.h"
95 #include "llvm/ADT/StringRef.h"
96 #include "llvm/CodeGen/LiveInterval.h"
97 #include "llvm/CodeGen/LiveIntervalAnalysis.h"
98 #include "llvm/CodeGen/MachineBasicBlock.h"
99 #include "llvm/CodeGen/MachineDominators.h"
100 #include "llvm/CodeGen/MachineFunction.h"
101 #include "llvm/CodeGen/MachineFunctionPass.h"
102 #include "llvm/CodeGen/MachineInstr.h"
103 #include "llvm/CodeGen/MachineInstrBuilder.h"
104 #include "llvm/CodeGen/MachineOperand.h"
105 #include "llvm/CodeGen/MachineRegisterInfo.h"
106 #include "llvm/CodeGen/SlotIndexes.h"
107 #include "llvm/IR/DebugLoc.h"
108 #include "llvm/Pass.h"
109 #include "llvm/Support/CommandLine.h"
110 #include "llvm/Support/Debug.h"
111 #include "llvm/Support/ErrorHandling.h"
112 #include "llvm/Support/raw_ostream.h"
113 #include "llvm/Target/TargetRegisterInfo.h"
119 using namespace llvm;
121 static cl::opt<unsigned> OptTfrLimit("expand-condsets-tfr-limit",
122 cl::init(~0U), cl::Hidden, cl::desc("Max number of mux expansions"));
123 static cl::opt<unsigned> OptCoaLimit("expand-condsets-coa-limit",
124 cl::init(~0U), cl::Hidden, cl::desc("Max number of segment coalescings"));
128 void initializeHexagonExpandCondsetsPass(PassRegistry&);
129 FunctionPass *createHexagonExpandCondsets();
131 } // end namespace llvm
135 class HexagonExpandCondsets : public MachineFunctionPass {
139 HexagonExpandCondsets() :
140 MachineFunctionPass(ID), HII(nullptr), TRI(nullptr), MRI(nullptr),
141 LIS(nullptr), CoaLimitActive(false),
142 TfrLimitActive(false), CoaCounter(0), TfrCounter(0) {
143 if (OptCoaLimit.getPosition())
144 CoaLimitActive = true, CoaLimit = OptCoaLimit;
145 if (OptTfrLimit.getPosition())
146 TfrLimitActive = true, TfrLimit = OptTfrLimit;
147 initializeHexagonExpandCondsetsPass(*PassRegistry::getPassRegistry());
150 StringRef getPassName() const override { return "Hexagon Expand Condsets"; }
152 void getAnalysisUsage(AnalysisUsage &AU) const override {
153 AU.addRequired<LiveIntervals>();
154 AU.addPreserved<LiveIntervals>();
155 AU.addPreserved<SlotIndexes>();
156 AU.addRequired<MachineDominatorTree>();
157 AU.addPreserved<MachineDominatorTree>();
158 MachineFunctionPass::getAnalysisUsage(AU);
161 bool runOnMachineFunction(MachineFunction &MF) override;
164 const HexagonInstrInfo *HII;
165 const TargetRegisterInfo *TRI;
166 MachineDominatorTree *MDT;
167 MachineRegisterInfo *MRI;
170 bool CoaLimitActive, TfrLimitActive;
171 unsigned CoaLimit, TfrLimit, CoaCounter, TfrCounter;
174 RegisterRef(const MachineOperand &Op) : Reg(Op.getReg()),
175 Sub(Op.getSubReg()) {}
176 RegisterRef(unsigned R = 0, unsigned S = 0) : Reg(R), Sub(S) {}
178 bool operator== (RegisterRef RR) const {
179 return Reg == RR.Reg && Sub == RR.Sub;
181 bool operator!= (RegisterRef RR) const { return !operator==(RR); }
182 bool operator< (RegisterRef RR) const {
183 return Reg < RR.Reg || (Reg == RR.Reg && Sub < RR.Sub);
189 typedef DenseMap<unsigned,unsigned> ReferenceMap;
190 enum { Sub_Low = 0x1, Sub_High = 0x2, Sub_None = (Sub_Low | Sub_High) };
191 enum { Exec_Then = 0x10, Exec_Else = 0x20 };
192 unsigned getMaskForSub(unsigned Sub);
193 bool isCondset(const MachineInstr &MI);
194 LaneBitmask getLaneMask(unsigned Reg, unsigned Sub);
196 void addRefToMap(RegisterRef RR, ReferenceMap &Map, unsigned Exec);
197 bool isRefInMap(RegisterRef, ReferenceMap &Map, unsigned Exec);
199 void updateDeadsInRange(unsigned Reg, LaneBitmask LM, LiveRange &Range);
200 void updateKillFlags(unsigned Reg);
201 void updateDeadFlags(unsigned Reg);
202 void recalculateLiveInterval(unsigned Reg);
203 void removeInstr(MachineInstr &MI);
204 void updateLiveness(std::set<unsigned> &RegSet, bool Recalc,
205 bool UpdateKills, bool UpdateDeads);
207 unsigned getCondTfrOpcode(const MachineOperand &SO, bool Cond);
208 MachineInstr *genCondTfrFor(MachineOperand &SrcOp,
209 MachineBasicBlock::iterator At, unsigned DstR,
210 unsigned DstSR, const MachineOperand &PredOp, bool PredSense,
211 bool ReadUndef, bool ImpUse);
212 bool split(MachineInstr &MI, std::set<unsigned> &UpdRegs);
214 bool isPredicable(MachineInstr *MI);
215 MachineInstr *getReachingDefForPred(RegisterRef RD,
216 MachineBasicBlock::iterator UseIt, unsigned PredR, bool Cond);
217 bool canMoveOver(MachineInstr &MI, ReferenceMap &Defs, ReferenceMap &Uses);
218 bool canMoveMemTo(MachineInstr &MI, MachineInstr &ToI, bool IsDown);
219 void predicateAt(const MachineOperand &DefOp, MachineInstr &MI,
220 MachineBasicBlock::iterator Where,
221 const MachineOperand &PredOp, bool Cond,
222 std::set<unsigned> &UpdRegs);
223 void renameInRange(RegisterRef RO, RegisterRef RN, unsigned PredR,
224 bool Cond, MachineBasicBlock::iterator First,
225 MachineBasicBlock::iterator Last);
226 bool predicate(MachineInstr &TfrI, bool Cond, std::set<unsigned> &UpdRegs);
227 bool predicateInBlock(MachineBasicBlock &B,
228 std::set<unsigned> &UpdRegs);
230 bool isIntReg(RegisterRef RR, unsigned &BW);
231 bool isIntraBlocks(LiveInterval &LI);
232 bool coalesceRegisters(RegisterRef R1, RegisterRef R2);
233 bool coalesceSegments(const SmallVectorImpl<MachineInstr*> &Condsets,
234 std::set<unsigned> &UpdRegs);
237 } // end anonymous namespace
239 char HexagonExpandCondsets::ID = 0;
243 char &HexagonExpandCondsetsID = HexagonExpandCondsets::ID;
245 } // end namespace llvm
247 INITIALIZE_PASS_BEGIN(HexagonExpandCondsets, "expand-condsets",
248 "Hexagon Expand Condsets", false, false)
249 INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
250 INITIALIZE_PASS_DEPENDENCY(SlotIndexes)
251 INITIALIZE_PASS_DEPENDENCY(LiveIntervals)
252 INITIALIZE_PASS_END(HexagonExpandCondsets, "expand-condsets",
253 "Hexagon Expand Condsets", false, false)
255 unsigned HexagonExpandCondsets::getMaskForSub(unsigned Sub) {
257 case Hexagon::isub_lo:
258 case Hexagon::vsub_lo:
260 case Hexagon::isub_hi:
261 case Hexagon::vsub_hi:
263 case Hexagon::NoSubRegister:
266 llvm_unreachable("Invalid subregister");
269 bool HexagonExpandCondsets::isCondset(const MachineInstr &MI) {
270 unsigned Opc = MI.getOpcode();
272 case Hexagon::C2_mux:
273 case Hexagon::C2_muxii:
274 case Hexagon::C2_muxir:
275 case Hexagon::C2_muxri:
276 case Hexagon::PS_pselect:
283 LaneBitmask HexagonExpandCondsets::getLaneMask(unsigned Reg, unsigned Sub) {
284 assert(TargetRegisterInfo::isVirtualRegister(Reg));
285 return Sub != 0 ? TRI->getSubRegIndexLaneMask(Sub)
286 : MRI->getMaxLaneMaskForVReg(Reg);
289 void HexagonExpandCondsets::addRefToMap(RegisterRef RR, ReferenceMap &Map,
291 unsigned Mask = getMaskForSub(RR.Sub) | Exec;
292 ReferenceMap::iterator F = Map.find(RR.Reg);
294 Map.insert(std::make_pair(RR.Reg, Mask));
299 bool HexagonExpandCondsets::isRefInMap(RegisterRef RR, ReferenceMap &Map,
301 ReferenceMap::iterator F = Map.find(RR.Reg);
304 unsigned Mask = getMaskForSub(RR.Sub) | Exec;
305 if (Mask & F->second)
310 void HexagonExpandCondsets::updateKillFlags(unsigned Reg) {
311 auto KillAt = [this,Reg] (SlotIndex K, LaneBitmask LM) -> void {
312 // Set the <kill> flag on a use of Reg whose lane mask is contained in LM.
313 MachineInstr *MI = LIS->getInstructionFromIndex(K);
314 for (auto &Op : MI->operands()) {
315 if (!Op.isReg() || !Op.isUse() || Op.getReg() != Reg)
317 LaneBitmask SLM = getLaneMask(Reg, Op.getSubReg());
318 if ((SLM & LM) == SLM) {
319 // Only set the kill flag on the first encountered use of Reg in this
327 LiveInterval &LI = LIS->getInterval(Reg);
328 for (auto I = LI.begin(), E = LI.end(); I != E; ++I) {
329 if (!I->end.isRegister())
331 // Do not mark the end of the segment as <kill>, if the next segment
332 // starts with a predicated instruction.
333 auto NextI = std::next(I);
334 if (NextI != E && NextI->start.isRegister()) {
335 MachineInstr *DefI = LIS->getInstructionFromIndex(NextI->start);
336 if (HII->isPredicated(*DefI))
339 bool WholeReg = true;
340 if (LI.hasSubRanges()) {
341 auto EndsAtI = [I] (LiveInterval::SubRange &S) -> bool {
342 LiveRange::iterator F = S.find(I->end);
343 return F != S.end() && I->end == F->end;
345 // Check if all subranges end at I->end. If so, make sure to kill
346 // the whole register.
347 for (LiveInterval::SubRange &S : LI.subranges()) {
349 KillAt(I->end, S.LaneMask);
355 KillAt(I->end, MRI->getMaxLaneMaskForVReg(Reg));
359 void HexagonExpandCondsets::updateDeadsInRange(unsigned Reg, LaneBitmask LM,
361 assert(TargetRegisterInfo::isVirtualRegister(Reg));
365 // Return two booleans: { def-modifes-reg, def-covers-reg }.
366 auto IsRegDef = [this,Reg,LM] (MachineOperand &Op) -> std::pair<bool,bool> {
367 if (!Op.isReg() || !Op.isDef())
368 return { false, false };
369 unsigned DR = Op.getReg(), DSR = Op.getSubReg();
370 if (!TargetRegisterInfo::isVirtualRegister(DR) || DR != Reg)
371 return { false, false };
372 LaneBitmask SLM = getLaneMask(DR, DSR);
373 LaneBitmask A = SLM & LM;
374 return { A.any(), A == SLM };
377 // The splitting step will create pairs of predicated definitions without
378 // any implicit uses (since implicit uses would interfere with predication).
379 // This can cause the reaching defs to become dead after live range
380 // recomputation, even though they are not really dead.
381 // We need to identify predicated defs that need implicit uses, and
382 // dead defs that are not really dead, and correct both problems.
384 auto Dominate = [this] (SetVector<MachineBasicBlock*> &Defs,
385 MachineBasicBlock *Dest) -> bool {
386 for (MachineBasicBlock *D : Defs)
387 if (D != Dest && MDT->dominates(D, Dest))
390 MachineBasicBlock *Entry = &Dest->getParent()->front();
391 SetVector<MachineBasicBlock*> Work(Dest->pred_begin(), Dest->pred_end());
392 for (unsigned i = 0; i < Work.size(); ++i) {
393 MachineBasicBlock *B = Work[i];
398 for (auto *P : B->predecessors())
404 // First, try to extend live range within individual basic blocks. This
405 // will leave us only with dead defs that do not reach any predicated
406 // defs in the same block.
407 SetVector<MachineBasicBlock*> Defs;
408 SmallVector<SlotIndex,4> PredDefs;
409 for (auto &Seg : Range) {
410 if (!Seg.start.isRegister())
412 MachineInstr *DefI = LIS->getInstructionFromIndex(Seg.start);
413 Defs.insert(DefI->getParent());
414 if (HII->isPredicated(*DefI))
415 PredDefs.push_back(Seg.start);
418 SmallVector<SlotIndex,8> Undefs;
419 LiveInterval &LI = LIS->getInterval(Reg);
420 LI.computeSubRangeUndefs(Undefs, LM, *MRI, *LIS->getSlotIndexes());
422 for (auto &SI : PredDefs) {
423 MachineBasicBlock *BB = LIS->getMBBFromIndex(SI);
424 auto P = Range.extendInBlock(Undefs, LIS->getMBBStartIdx(BB), SI);
425 if (P.first != nullptr || P.second)
429 // Calculate reachability for those predicated defs that were not handled
430 // by the in-block extension.
431 SmallVector<SlotIndex,4> ExtTo;
432 for (auto &SI : PredDefs) {
435 MachineBasicBlock *BB = LIS->getMBBFromIndex(SI);
436 if (BB->pred_empty())
438 // If the defs from this range reach SI via all predecessors, it is live.
439 // It can happen that SI is reached by the defs through some paths, but
440 // not all. In the IR coming into this optimization, SI would not be
441 // considered live, since the defs would then not jointly dominate SI.
442 // That means that SI is an overwriting def, and no implicit use is
443 // needed at this point. Do not add SI to the extension points, since
444 // extendToIndices will abort if there is no joint dominance.
445 // If the abort was avoided by adding extra undefs added to Undefs,
446 // extendToIndices could actually indicate that SI is live, contrary
447 // to the original IR.
448 if (Dominate(Defs, BB))
453 LIS->extendToIndices(Range, ExtTo, Undefs);
455 // Remove <dead> flags from all defs that are not dead after live range
456 // extension, and collect all def operands. They will be used to generate
457 // the necessary implicit uses.
458 // At the same time, add <dead> flag to all defs that are actually dead.
459 // This can happen, for example, when a mux with identical inputs is
460 // replaced with a COPY: the use of the predicate register disappears and
461 // the dead can become dead.
462 std::set<RegisterRef> DefRegs;
463 for (auto &Seg : Range) {
464 if (!Seg.start.isRegister())
466 MachineInstr *DefI = LIS->getInstructionFromIndex(Seg.start);
467 for (auto &Op : DefI->operands()) {
468 auto P = IsRegDef(Op);
469 if (P.second && Seg.end.isDead()) {
471 } else if (P.first) {
478 // Now, add implicit uses to each predicated def that is reached
480 for (auto &Seg : Range) {
481 if (!Seg.start.isRegister() || !Range.liveAt(Seg.start.getPrevSlot()))
483 MachineInstr *DefI = LIS->getInstructionFromIndex(Seg.start);
484 if (!HII->isPredicated(*DefI))
486 // Construct the set of all necessary implicit uses, based on the def
487 // operands in the instruction.
488 std::set<RegisterRef> ImpUses;
489 for (auto &Op : DefI->operands())
490 if (Op.isReg() && Op.isDef() && DefRegs.count(Op))
494 MachineFunction &MF = *DefI->getParent()->getParent();
495 for (RegisterRef R : ImpUses)
496 MachineInstrBuilder(MF, DefI).addReg(R.Reg, RegState::Implicit, R.Sub);
501 void HexagonExpandCondsets::updateDeadFlags(unsigned Reg) {
502 LiveInterval &LI = LIS->getInterval(Reg);
503 if (LI.hasSubRanges()) {
504 for (LiveInterval::SubRange &S : LI.subranges()) {
505 updateDeadsInRange(Reg, S.LaneMask, S);
506 LIS->shrinkToUses(S, Reg);
509 LIS->constructMainRangeFromSubranges(LI);
511 updateDeadsInRange(Reg, MRI->getMaxLaneMaskForVReg(Reg), LI);
515 void HexagonExpandCondsets::recalculateLiveInterval(unsigned Reg) {
516 LIS->removeInterval(Reg);
517 LIS->createAndComputeVirtRegInterval(Reg);
520 void HexagonExpandCondsets::removeInstr(MachineInstr &MI) {
521 LIS->RemoveMachineInstrFromMaps(MI);
522 MI.eraseFromParent();
525 void HexagonExpandCondsets::updateLiveness(std::set<unsigned> &RegSet,
526 bool Recalc, bool UpdateKills, bool UpdateDeads) {
527 UpdateKills |= UpdateDeads;
528 for (auto R : RegSet) {
530 recalculateLiveInterval(R);
532 MRI->clearKillFlags(R);
535 // Fixing <dead> flags may extend live ranges, so reset <kill> flags
539 LIS->getInterval(R).verify();
543 /// Get the opcode for a conditional transfer of the value in SO (source
544 /// operand). The condition (true/false) is given in Cond.
545 unsigned HexagonExpandCondsets::getCondTfrOpcode(const MachineOperand &SO,
547 using namespace Hexagon;
552 if (TargetRegisterInfo::isVirtualRegister(RS.Reg)) {
553 const TargetRegisterClass *VC = MRI->getRegClass(RS.Reg);
554 assert(VC->begin() != VC->end() && "Empty register class");
555 PhysR = *VC->begin();
557 assert(TargetRegisterInfo::isPhysicalRegister(RS.Reg));
560 unsigned PhysS = (RS.Sub == 0) ? PhysR : TRI->getSubReg(PhysR, RS.Sub);
561 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(PhysS);
562 switch (TRI->getRegSizeInBits(*RC)) {
564 return IfTrue ? A2_tfrt : A2_tfrf;
566 return IfTrue ? A2_tfrpt : A2_tfrpf;
568 llvm_unreachable("Invalid register operand");
570 if (SO.isImm() || SO.isFPImm())
571 return IfTrue ? C2_cmoveit : C2_cmoveif;
572 llvm_unreachable("Unexpected source operand");
575 /// Generate a conditional transfer, copying the value SrcOp to the
576 /// destination register DstR:DstSR, and using the predicate register from
577 /// PredOp. The Cond argument specifies whether the predicate is to be
578 /// if(PredOp), or if(!PredOp).
579 MachineInstr *HexagonExpandCondsets::genCondTfrFor(MachineOperand &SrcOp,
580 MachineBasicBlock::iterator At,
581 unsigned DstR, unsigned DstSR, const MachineOperand &PredOp,
582 bool PredSense, bool ReadUndef, bool ImpUse) {
583 MachineInstr *MI = SrcOp.getParent();
584 MachineBasicBlock &B = *At->getParent();
585 const DebugLoc &DL = MI->getDebugLoc();
587 // Don't avoid identity copies here (i.e. if the source and the destination
588 // are the same registers). It is actually better to generate them here,
589 // since this would cause the copy to potentially be predicated in the next
590 // step. The predication will remove such a copy if it is unable to
593 unsigned Opc = getCondTfrOpcode(SrcOp, PredSense);
594 unsigned DstState = RegState::Define | (ReadUndef ? RegState::Undef : 0);
595 unsigned PredState = getRegState(PredOp) & ~RegState::Kill;
596 MachineInstrBuilder MIB;
599 unsigned SrcState = getRegState(SrcOp);
600 if (RegisterRef(SrcOp) == RegisterRef(DstR, DstSR))
601 SrcState &= ~RegState::Kill;
602 MIB = BuildMI(B, At, DL, HII->get(Opc))
603 .addReg(DstR, DstState, DstSR)
604 .addReg(PredOp.getReg(), PredState, PredOp.getSubReg())
605 .addReg(SrcOp.getReg(), SrcState, SrcOp.getSubReg());
607 MIB = BuildMI(B, At, DL, HII->get(Opc))
608 .addReg(DstR, DstState, DstSR)
609 .addReg(PredOp.getReg(), PredState, PredOp.getSubReg())
613 DEBUG(dbgs() << "created an initial copy: " << *MIB);
617 /// Replace a MUX instruction MI with a pair A2_tfrt/A2_tfrf. This function
618 /// performs all necessary changes to complete the replacement.
619 bool HexagonExpandCondsets::split(MachineInstr &MI,
620 std::set<unsigned> &UpdRegs) {
621 if (TfrLimitActive) {
622 if (TfrCounter >= TfrLimit)
626 DEBUG(dbgs() << "\nsplitting BB#" << MI.getParent()->getNumber() << ": "
628 MachineOperand &MD = MI.getOperand(0); // Definition
629 MachineOperand &MP = MI.getOperand(1); // Predicate register
631 unsigned DR = MD.getReg(), DSR = MD.getSubReg();
632 bool ReadUndef = MD.isUndef();
633 MachineBasicBlock::iterator At = MI;
635 auto updateRegs = [&UpdRegs] (const MachineInstr &MI) -> void {
636 for (auto &Op : MI.operands())
638 UpdRegs.insert(Op.getReg());
641 // If this is a mux of the same register, just replace it with COPY.
642 // Ideally, this would happen earlier, so that register coalescing would
644 MachineOperand &ST = MI.getOperand(2);
645 MachineOperand &SF = MI.getOperand(3);
646 if (ST.isReg() && SF.isReg()) {
648 if (RT == RegisterRef(SF)) {
649 // Copy regs to update first.
651 MI.setDesc(HII->get(TargetOpcode::COPY));
652 unsigned S = getRegState(ST);
653 while (MI.getNumOperands() > 1)
654 MI.RemoveOperand(MI.getNumOperands()-1);
655 MachineFunction &MF = *MI.getParent()->getParent();
656 MachineInstrBuilder(MF, MI).addReg(RT.Reg, S, RT.Sub);
661 // First, create the two invididual conditional transfers, and add each
662 // of them to the live intervals information. Do that first and then remove
663 // the old instruction from live intervals.
665 genCondTfrFor(ST, At, DR, DSR, MP, true, ReadUndef, false);
667 genCondTfrFor(SF, At, DR, DSR, MP, false, ReadUndef, true);
668 LIS->InsertMachineInstrInMaps(*TfrT);
669 LIS->InsertMachineInstrInMaps(*TfrF);
671 // Will need to recalculate live intervals for all registers in MI.
678 bool HexagonExpandCondsets::isPredicable(MachineInstr *MI) {
679 if (HII->isPredicated(*MI) || !HII->isPredicable(*MI))
681 if (MI->hasUnmodeledSideEffects() || MI->mayStore())
683 // Reject instructions with multiple defs (e.g. post-increment loads).
685 for (auto &Op : MI->operands()) {
686 if (!Op.isReg() || !Op.isDef())
692 for (auto &Mo : MI->memoperands())
693 if (Mo->isVolatile())
698 /// Find the reaching definition for a predicated use of RD. The RD is used
699 /// under the conditions given by PredR and Cond, and this function will ignore
700 /// definitions that set RD under the opposite conditions.
701 MachineInstr *HexagonExpandCondsets::getReachingDefForPred(RegisterRef RD,
702 MachineBasicBlock::iterator UseIt, unsigned PredR, bool Cond) {
703 MachineBasicBlock &B = *UseIt->getParent();
704 MachineBasicBlock::iterator I = UseIt, S = B.begin();
708 bool PredValid = true;
711 MachineInstr *MI = &*I;
712 // Check if this instruction can be ignored, i.e. if it is predicated
713 // on the complementary condition.
714 if (PredValid && HII->isPredicated(*MI)) {
715 if (MI->readsRegister(PredR) && (Cond != HII->isPredicatedTrue(*MI)))
719 // Check the defs. If the PredR is defined, invalidate it. If RD is
720 // defined, return the instruction or 0, depending on the circumstances.
721 for (auto &Op : MI->operands()) {
722 if (!Op.isReg() || !Op.isDef())
725 if (RR.Reg == PredR) {
729 if (RR.Reg != RD.Reg)
731 // If the "Reg" part agrees, there is still the subregister to check.
732 // If we are looking for vreg1:loreg, we can skip vreg1:hireg, but
733 // not vreg1 (w/o subregisters).
734 if (RR.Sub == RD.Sub)
736 if (RR.Sub == 0 || RD.Sub == 0)
738 // We have different subregisters, so we can continue looking.
745 /// Check if the instruction MI can be safely moved over a set of instructions
746 /// whose side-effects (in terms of register defs and uses) are expressed in
747 /// the maps Defs and Uses. These maps reflect the conditional defs and uses
748 /// that depend on the same predicate register to allow moving instructions
749 /// over instructions predicated on the opposite condition.
750 bool HexagonExpandCondsets::canMoveOver(MachineInstr &MI, ReferenceMap &Defs,
751 ReferenceMap &Uses) {
752 // In order to be able to safely move MI over instructions that define
753 // "Defs" and use "Uses", no def operand from MI can be defined or used
754 // and no use operand can be defined.
755 for (auto &Op : MI.operands()) {
759 // For physical register we would need to check register aliases, etc.
760 // and we don't want to bother with that. It would be of little value
761 // before the actual register rewriting (from virtual to physical).
762 if (!TargetRegisterInfo::isVirtualRegister(RR.Reg))
764 // No redefs for any operand.
765 if (isRefInMap(RR, Defs, Exec_Then))
767 // For defs, there cannot be uses.
768 if (Op.isDef() && isRefInMap(RR, Uses, Exec_Then))
774 /// Check if the instruction accessing memory (TheI) can be moved to the
776 bool HexagonExpandCondsets::canMoveMemTo(MachineInstr &TheI, MachineInstr &ToI,
778 bool IsLoad = TheI.mayLoad(), IsStore = TheI.mayStore();
779 if (!IsLoad && !IsStore)
781 if (HII->areMemAccessesTriviallyDisjoint(TheI, ToI))
783 if (TheI.hasUnmodeledSideEffects())
786 MachineBasicBlock::iterator StartI = IsDown ? TheI : ToI;
787 MachineBasicBlock::iterator EndI = IsDown ? ToI : TheI;
788 bool Ordered = TheI.hasOrderedMemoryRef();
790 // Search for aliased memory reference in (StartI, EndI).
791 for (MachineBasicBlock::iterator I = std::next(StartI); I != EndI; ++I) {
792 MachineInstr *MI = &*I;
793 if (MI->hasUnmodeledSideEffects())
795 bool L = MI->mayLoad(), S = MI->mayStore();
798 if (Ordered && MI->hasOrderedMemoryRef())
801 bool Conflict = (L && IsStore) || S;
808 /// Generate a predicated version of MI (where the condition is given via
809 /// PredR and Cond) at the point indicated by Where.
810 void HexagonExpandCondsets::predicateAt(const MachineOperand &DefOp,
812 MachineBasicBlock::iterator Where,
813 const MachineOperand &PredOp, bool Cond,
814 std::set<unsigned> &UpdRegs) {
815 // The problem with updating live intervals is that we can move one def
816 // past another def. In particular, this can happen when moving an A2_tfrt
817 // over an A2_tfrf defining the same register. From the point of view of
818 // live intervals, these two instructions are two separate definitions,
819 // and each one starts another live segment. LiveIntervals's "handleMove"
820 // does not allow such moves, so we need to handle it ourselves. To avoid
821 // invalidating liveness data while we are using it, the move will be
822 // implemented in 4 steps: (1) add a clone of the instruction MI at the
823 // target location, (2) update liveness, (3) delete the old instruction,
824 // and (4) update liveness again.
826 MachineBasicBlock &B = *MI.getParent();
827 DebugLoc DL = Where->getDebugLoc(); // "Where" points to an instruction.
828 unsigned Opc = MI.getOpcode();
829 unsigned PredOpc = HII->getCondOpcode(Opc, !Cond);
830 MachineInstrBuilder MB = BuildMI(B, Where, DL, HII->get(PredOpc));
831 unsigned Ox = 0, NP = MI.getNumOperands();
832 // Skip all defs from MI first.
834 MachineOperand &MO = MI.getOperand(Ox);
835 if (!MO.isReg() || !MO.isDef())
839 // Add the new def, then the predicate register, then the rest of the
841 MB.addReg(DefOp.getReg(), getRegState(DefOp), DefOp.getSubReg());
842 MB.addReg(PredOp.getReg(), PredOp.isUndef() ? RegState::Undef : 0,
845 MachineOperand &MO = MI.getOperand(Ox);
846 if (!MO.isReg() || !MO.isImplicit())
851 MachineFunction &MF = *B.getParent();
852 MachineInstr::mmo_iterator I = MI.memoperands_begin();
853 unsigned NR = std::distance(I, MI.memoperands_end());
854 MachineInstr::mmo_iterator MemRefs = MF.allocateMemRefsArray(NR);
855 for (unsigned i = 0; i < NR; ++i)
857 MB.setMemRefs(MemRefs, MemRefs+NR);
859 MachineInstr *NewI = MB;
860 NewI->clearKillInfo();
861 LIS->InsertMachineInstrInMaps(*NewI);
863 for (auto &Op : NewI->operands())
865 UpdRegs.insert(Op.getReg());
868 /// In the range [First, Last], rename all references to the "old" register RO
869 /// to the "new" register RN, but only in instructions predicated on the given
871 void HexagonExpandCondsets::renameInRange(RegisterRef RO, RegisterRef RN,
872 unsigned PredR, bool Cond, MachineBasicBlock::iterator First,
873 MachineBasicBlock::iterator Last) {
874 MachineBasicBlock::iterator End = std::next(Last);
875 for (MachineBasicBlock::iterator I = First; I != End; ++I) {
876 MachineInstr *MI = &*I;
877 // Do not touch instructions that are not predicated, or are predicated
878 // on the opposite condition.
879 if (!HII->isPredicated(*MI))
881 if (!MI->readsRegister(PredR) || (Cond != HII->isPredicatedTrue(*MI)))
884 for (auto &Op : MI->operands()) {
885 if (!Op.isReg() || RO != RegisterRef(Op))
888 Op.setSubReg(RN.Sub);
889 // In practice, this isn't supposed to see any defs.
890 assert(!Op.isDef() && "Not expecting a def");
895 /// For a given conditional copy, predicate the definition of the source of
896 /// the copy under the given condition (using the same predicate register as
898 bool HexagonExpandCondsets::predicate(MachineInstr &TfrI, bool Cond,
899 std::set<unsigned> &UpdRegs) {
900 // TfrI - A2_tfr[tf] Instruction (not A2_tfrsi).
901 unsigned Opc = TfrI.getOpcode();
903 assert(Opc == Hexagon::A2_tfrt || Opc == Hexagon::A2_tfrf);
904 DEBUG(dbgs() << "\nattempt to predicate if-" << (Cond ? "true" : "false")
907 MachineOperand &MD = TfrI.getOperand(0);
908 MachineOperand &MP = TfrI.getOperand(1);
909 MachineOperand &MS = TfrI.getOperand(2);
910 // The source operand should be a <kill>. This is not strictly necessary,
911 // but it makes things a lot simpler. Otherwise, we would need to rename
912 // some registers, which would complicate the transformation considerably.
915 // Avoid predicating instructions that define a subregister if subregister
916 // liveness tracking is not enabled.
917 if (MD.getSubReg() && !MRI->shouldTrackSubRegLiveness(MD.getReg()))
921 unsigned PredR = MP.getReg();
922 MachineInstr *DefI = getReachingDefForPred(RT, TfrI, PredR, Cond);
923 if (!DefI || !isPredicable(DefI))
926 DEBUG(dbgs() << "Source def: " << *DefI);
928 // Collect the information about registers defined and used between the
929 // DefI and the TfrI.
930 // Map: reg -> bitmask of subregs
931 ReferenceMap Uses, Defs;
932 MachineBasicBlock::iterator DefIt = DefI, TfrIt = TfrI;
934 // Check if the predicate register is valid between DefI and TfrI.
935 // If it is, we can then ignore instructions predicated on the negated
936 // conditions when collecting def and use information.
937 bool PredValid = true;
938 for (MachineBasicBlock::iterator I = std::next(DefIt); I != TfrIt; ++I) {
939 if (!I->modifiesRegister(PredR, nullptr))
945 for (MachineBasicBlock::iterator I = std::next(DefIt); I != TfrIt; ++I) {
946 MachineInstr *MI = &*I;
947 // If this instruction is predicated on the same register, it could
948 // potentially be ignored.
949 // By default assume that the instruction executes on the same condition
950 // as TfrI (Exec_Then), and also on the opposite one (Exec_Else).
951 unsigned Exec = Exec_Then | Exec_Else;
952 if (PredValid && HII->isPredicated(*MI) && MI->readsRegister(PredR))
953 Exec = (Cond == HII->isPredicatedTrue(*MI)) ? Exec_Then : Exec_Else;
955 for (auto &Op : MI->operands()) {
958 // We don't want to deal with physical registers. The reason is that
959 // they can be aliased with other physical registers. Aliased virtual
960 // registers must share the same register number, and can only differ
961 // in the subregisters, which we are keeping track of. Physical
962 // registers ters no longer have subregisters---their super- and
963 // subregisters are other physical registers, and we are not checking
966 if (!TargetRegisterInfo::isVirtualRegister(RR.Reg))
969 ReferenceMap &Map = Op.isDef() ? Defs : Uses;
970 if (Op.isDef() && Op.isUndef()) {
971 assert(RR.Sub && "Expecting a subregister on <def,read-undef>");
972 // If this is a <def,read-undef>, then it invalidates the non-written
973 // part of the register. For the purpose of checking the validity of
974 // the move, assume that it modifies the whole register.
977 addRefToMap(RR, Map, Exec);
986 // If the register-in-the-middle (RT) is used or redefined between
987 // DefI and TfrI, we may not be able proceed with this transformation.
988 // We can ignore a def that will not execute together with TfrI, and a
989 // use that will. If there is such a use (that does execute together with
990 // TfrI), we will not be able to move DefI down. If there is a use that
991 // executed if TfrI's condition is false, then RT must be available
992 // unconditionally (cannot be predicated).
993 // Essentially, we need to be able to rename RT to RD in this segment.
994 if (isRefInMap(RT, Defs, Exec_Then) || isRefInMap(RT, Uses, Exec_Else))
997 // If the predicate register is defined between DefI and TfrI, the only
998 // potential thing to do would be to move the DefI down to TfrI, and then
999 // predicate. The reaching def (DefI) must be movable down to the location
1001 // If the target register of the TfrI (RD) is not used or defined between
1002 // DefI and TfrI, consider moving TfrI up to DefI.
1003 bool CanUp = canMoveOver(TfrI, Defs, Uses);
1004 bool CanDown = canMoveOver(*DefI, Defs, Uses);
1005 // The TfrI does not access memory, but DefI could. Check if it's safe
1006 // to move DefI down to TfrI.
1007 if (DefI->mayLoad() || DefI->mayStore())
1008 if (!canMoveMemTo(*DefI, TfrI, true))
1011 DEBUG(dbgs() << "Can move up: " << (CanUp ? "yes" : "no")
1012 << ", can move down: " << (CanDown ? "yes\n" : "no\n"));
1013 MachineBasicBlock::iterator PastDefIt = std::next(DefIt);
1015 predicateAt(MD, *DefI, PastDefIt, MP, Cond, UpdRegs);
1017 predicateAt(MD, *DefI, TfrIt, MP, Cond, UpdRegs);
1022 renameInRange(RT, RD, PredR, Cond, PastDefIt, TfrIt);
1023 UpdRegs.insert(RT.Reg);
1031 /// Predicate all cases of conditional copies in the specified block.
1032 bool HexagonExpandCondsets::predicateInBlock(MachineBasicBlock &B,
1033 std::set<unsigned> &UpdRegs) {
1034 bool Changed = false;
1035 MachineBasicBlock::iterator I, E, NextI;
1036 for (I = B.begin(), E = B.end(); I != E; I = NextI) {
1037 NextI = std::next(I);
1038 unsigned Opc = I->getOpcode();
1039 if (Opc == Hexagon::A2_tfrt || Opc == Hexagon::A2_tfrf) {
1040 bool Done = predicate(*I, (Opc == Hexagon::A2_tfrt), UpdRegs);
1042 // If we didn't predicate I, we may need to remove it in case it is
1043 // an "identity" copy, e.g. vreg1 = A2_tfrt vreg2, vreg1.
1044 if (RegisterRef(I->getOperand(0)) == RegisterRef(I->getOperand(2))) {
1045 for (auto &Op : I->operands())
1047 UpdRegs.insert(Op.getReg());
1057 bool HexagonExpandCondsets::isIntReg(RegisterRef RR, unsigned &BW) {
1058 if (!TargetRegisterInfo::isVirtualRegister(RR.Reg))
1060 const TargetRegisterClass *RC = MRI->getRegClass(RR.Reg);
1061 if (RC == &Hexagon::IntRegsRegClass) {
1065 if (RC == &Hexagon::DoubleRegsRegClass) {
1066 BW = (RR.Sub != 0) ? 32 : 64;
1072 bool HexagonExpandCondsets::isIntraBlocks(LiveInterval &LI) {
1073 for (LiveInterval::iterator I = LI.begin(), E = LI.end(); I != E; ++I) {
1074 LiveRange::Segment &LR = *I;
1075 // Range must start at a register...
1076 if (!LR.start.isRegister())
1078 // ...and end in a register or in a dead slot.
1079 if (!LR.end.isRegister() && !LR.end.isDead())
1085 bool HexagonExpandCondsets::coalesceRegisters(RegisterRef R1, RegisterRef R2) {
1086 if (CoaLimitActive) {
1087 if (CoaCounter >= CoaLimit)
1092 if (!isIntReg(R1, BW1) || !isIntReg(R2, BW2) || BW1 != BW2)
1094 if (MRI->isLiveIn(R1.Reg))
1096 if (MRI->isLiveIn(R2.Reg))
1099 LiveInterval &L1 = LIS->getInterval(R1.Reg);
1100 LiveInterval &L2 = LIS->getInterval(R2.Reg);
1103 if (L1.hasSubRanges() || L2.hasSubRanges())
1105 bool Overlap = L1.overlaps(L2);
1107 DEBUG(dbgs() << "compatible registers: ("
1108 << (Overlap ? "overlap" : "disjoint") << ")\n "
1109 << PrintReg(R1.Reg, TRI, R1.Sub) << " " << L1 << "\n "
1110 << PrintReg(R2.Reg, TRI, R2.Sub) << " " << L2 << "\n");
1111 if (R1.Sub || R2.Sub)
1116 // Coalescing could have a negative impact on scheduling, so try to limit
1117 // to some reasonable extent. Only consider coalescing segments, when one
1118 // of them does not cross basic block boundaries.
1119 if (!isIntraBlocks(L1) && !isIntraBlocks(L2))
1122 MRI->replaceRegWith(R2.Reg, R1.Reg);
1124 // Move all live segments from L2 to L1.
1125 typedef DenseMap<VNInfo*,VNInfo*> ValueInfoMap;
1127 for (LiveInterval::iterator I = L2.begin(), E = L2.end(); I != E; ++I) {
1128 VNInfo *NewVN, *OldVN = I->valno;
1129 ValueInfoMap::iterator F = VM.find(OldVN);
1130 if (F == VM.end()) {
1131 NewVN = L1.getNextValue(I->valno->def, LIS->getVNInfoAllocator());
1132 VM.insert(std::make_pair(OldVN, NewVN));
1136 L1.addSegment(LiveRange::Segment(I->start, I->end, NewVN));
1138 while (L2.begin() != L2.end())
1139 L2.removeSegment(*L2.begin());
1140 LIS->removeInterval(R2.Reg);
1142 updateKillFlags(R1.Reg);
1143 DEBUG(dbgs() << "coalesced: " << L1 << "\n");
1149 /// Attempt to coalesce one of the source registers to a MUX instruction with
1150 /// the destination register. This could lead to having only one predicated
1151 /// instruction in the end instead of two.
1152 bool HexagonExpandCondsets::coalesceSegments(
1153 const SmallVectorImpl<MachineInstr*> &Condsets,
1154 std::set<unsigned> &UpdRegs) {
1155 SmallVector<MachineInstr*,16> TwoRegs;
1156 for (MachineInstr *MI : Condsets) {
1157 MachineOperand &S1 = MI->getOperand(2), &S2 = MI->getOperand(3);
1158 if (!S1.isReg() && !S2.isReg())
1160 TwoRegs.push_back(MI);
1163 bool Changed = false;
1164 for (MachineInstr *CI : TwoRegs) {
1165 RegisterRef RD = CI->getOperand(0);
1166 RegisterRef RP = CI->getOperand(1);
1167 MachineOperand &S1 = CI->getOperand(2), &S2 = CI->getOperand(3);
1169 // Consider this case:
1170 // vreg1 = instr1 ...
1171 // vreg2 = instr2 ...
1172 // vreg0 = C2_mux ..., vreg1, vreg2
1173 // If vreg0 was coalesced with vreg1, we could end up with the following
1175 // vreg0 = instr1 ...
1176 // vreg2 = instr2 ...
1177 // vreg0 = A2_tfrf ..., vreg2
1178 // which will later become:
1179 // vreg0 = instr1 ...
1180 // vreg0 = instr2_cNotPt ...
1181 // i.e. there will be an unconditional definition (instr1) of vreg0
1182 // followed by a conditional one. The output dependency was there before
1183 // and it unavoidable, but if instr1 is predicable, we will no longer be
1184 // able to predicate it here.
1185 // To avoid this scenario, don't coalesce the destination register with
1186 // a source register that is defined by a predicable instruction.
1188 RegisterRef RS = S1;
1189 MachineInstr *RDef = getReachingDefForPred(RS, CI, RP.Reg, true);
1190 if (!RDef || !HII->isPredicable(*RDef)) {
1191 Done = coalesceRegisters(RD, RegisterRef(S1));
1193 UpdRegs.insert(RD.Reg);
1194 UpdRegs.insert(S1.getReg());
1198 if (!Done && S2.isReg()) {
1199 RegisterRef RS = S2;
1200 MachineInstr *RDef = getReachingDefForPred(RS, CI, RP.Reg, false);
1201 if (!RDef || !HII->isPredicable(*RDef)) {
1202 Done = coalesceRegisters(RD, RegisterRef(S2));
1204 UpdRegs.insert(RD.Reg);
1205 UpdRegs.insert(S2.getReg());
1214 bool HexagonExpandCondsets::runOnMachineFunction(MachineFunction &MF) {
1215 if (skipFunction(*MF.getFunction()))
1218 HII = static_cast<const HexagonInstrInfo*>(MF.getSubtarget().getInstrInfo());
1219 TRI = MF.getSubtarget().getRegisterInfo();
1220 MDT = &getAnalysis<MachineDominatorTree>();
1221 LIS = &getAnalysis<LiveIntervals>();
1222 MRI = &MF.getRegInfo();
1224 DEBUG(LIS->print(dbgs() << "Before expand-condsets\n",
1225 MF.getFunction()->getParent()));
1227 bool Changed = false;
1228 std::set<unsigned> CoalUpd, PredUpd;
1230 SmallVector<MachineInstr*,16> Condsets;
1234 Condsets.push_back(&I);
1236 // Try to coalesce the target of a mux with one of its sources.
1237 // This could eliminate a register copy in some circumstances.
1238 Changed |= coalesceSegments(Condsets, CoalUpd);
1240 // Update kill flags on all source operands. This is done here because
1241 // at this moment (when expand-condsets runs), there are no kill flags
1242 // in the IR (they have been removed by live range analysis).
1243 // Updating them right before we split is the easiest, because splitting
1244 // adds definitions which would interfere with updating kills afterwards.
1245 std::set<unsigned> KillUpd;
1246 for (MachineInstr *MI : Condsets)
1247 for (MachineOperand &Op : MI->operands())
1248 if (Op.isReg() && Op.isUse())
1249 if (!CoalUpd.count(Op.getReg()))
1250 KillUpd.insert(Op.getReg());
1251 updateLiveness(KillUpd, false, true, false);
1252 DEBUG(LIS->print(dbgs() << "After coalescing\n",
1253 MF.getFunction()->getParent()));
1255 // First, simply split all muxes into a pair of conditional transfers
1256 // and update the live intervals to reflect the new arrangement. The
1257 // goal is to update the kill flags, since predication will rely on
1259 for (MachineInstr *MI : Condsets)
1260 Changed |= split(*MI, PredUpd);
1261 Condsets.clear(); // The contents of Condsets are invalid here anyway.
1263 // Do not update live ranges after splitting. Recalculation of live
1264 // intervals removes kill flags, which were preserved by splitting on
1265 // the source operands of condsets. These kill flags are needed by
1266 // predication, and after splitting they are difficult to recalculate
1267 // (because of predicated defs), so make sure they are left untouched.
1268 // Predication does not use live intervals.
1269 DEBUG(LIS->print(dbgs() << "After splitting\n",
1270 MF.getFunction()->getParent()));
1272 // Traverse all blocks and collapse predicable instructions feeding
1273 // conditional transfers into predicated instructions.
1274 // Walk over all the instructions again, so we may catch pre-existing
1275 // cases that were not created in the previous step.
1277 Changed |= predicateInBlock(B, PredUpd);
1278 DEBUG(LIS->print(dbgs() << "After predicating\n",
1279 MF.getFunction()->getParent()));
1281 PredUpd.insert(CoalUpd.begin(), CoalUpd.end());
1282 updateLiveness(PredUpd, true, true, true);
1286 LIS->print(dbgs() << "After expand-condsets\n",
1287 MF.getFunction()->getParent());
1293 //===----------------------------------------------------------------------===//
1294 // Public Constructor Functions
1295 //===----------------------------------------------------------------------===//
1297 FunctionPass *llvm::createHexagonExpandCondsets() {
1298 return new HexagonExpandCondsets();