Cross Reference: /external/llvm/lib/Target/R600/AMDILCFGStructurizer.cpp

Lines Matching refs:MBB
210   int getSCCNum(MachineBasicBlock *MBB) const;
212   bool hasBackEdge(MachineBasicBlock *MBB) const;
214   bool isRetiredBlock(MachineBasicBlock *MBB) const;
215   bool isActiveLoophead(MachineBasicBlock *MBB) const;
220   bool needMigrateBlock(MachineBasicBlock *MBB) const;
228   void insertInstrEnd(MachineBasicBlock *MBB, int NewOpcode,
230   MachineInstr *insertInstrBefore(MachineBasicBlock *MBB, int NewOpcode,
235   void insertCondBranchBefore(MachineBasicBlock *MBB,
238   void insertCondBranchEnd(MachineBasicBlock *MBB, int NewOpcode, int RegNum);
244   static void setTrueBranch(MachineInstr *MI, MachineBasicBlock *MBB);
245   static MachineBasicBlock *getFalseBranch(MachineBasicBlock *MBB,
249   static DebugLoc getLastDebugLocInBB(MachineBasicBlock *MBB);
250   static MachineInstr *getNormalBlockBranchInstr(MachineBasicBlock *MBB);
255   MachineInstr *getLoopendBlockBranchInstr(MachineBasicBlock *MBB);
256   static MachineInstr *getReturnInstr(MachineBasicBlock *MBB);
257   static MachineInstr *getContinueInstr(MachineBasicBlock *MBB);
258   static bool isReturnBlock(MachineBasicBlock *MBB);
261   static MachineBasicBlock *clone(MachineBasicBlock *MBB);
267   static void wrapup(MachineBasicBlock *MBB);
270   int patternMatch(MachineBasicBlock *MBB);
271   int patternMatchGroup(MachineBasicBlock *MBB);
272   int serialPatternMatch(MachineBasicBlock *MBB);
273   int ifPatternMatch(MachineBasicBlock *MBB);
302       MachineBasicBlock *MBB, MachineBasicBlock *TrueMBB,
319   void removeUnconditionalBranch(MachineBasicBlock *MBB);
328   void removeRedundantConditionalBranch(MachineBasicBlock *MBB);
330   void removeSuccessor(MachineBasicBlock *MBB);
331   MachineBasicBlock *cloneBlockForPredecessor(MachineBasicBlock *MBB,
335   void recordSccnum(MachineBasicBlock *MBB, int SCCNum);
336   void retireBlock(MachineBasicBlock *MBB);
337   void setLoopLandBlock(MachineLoop *LoopRep, MachineBasicBlock *MBB = nullptr);
353 int AMDGPUCFGStructurizer::getSCCNum(MachineBasicBlock *MBB) const {
354   MBBInfoMap::const_iterator It = BlockInfoMap.find(MBB);
368 bool AMDGPUCFGStructurizer::hasBackEdge(MachineBasicBlock *MBB) const {
369   MachineLoop *LoopRep = MLI->getLoopFor(MBB);
373   return MBB->isSuccessor(LoopHeader);
380 bool AMDGPUCFGStructurizer::isRetiredBlock(MachineBasicBlock *MBB) const {
381   MBBInfoMap::const_iterator It = BlockInfoMap.find(MBB);
387 bool AMDGPUCFGStructurizer::isActiveLoophead(MachineBasicBlock *MBB) const {
388   MachineLoop *LoopRep = MLI->getLoopFor(MBB);
389   while (LoopRep && LoopRep->getHeader() == MBB) {
428 bool AMDGPUCFGStructurizer::needMigrateBlock(MachineBasicBlock *MBB) const {
431   bool MultiplePreds = MBB && (MBB->pred_size() > 1);
435   unsigned BlkSize = MBB->size();
437       (BlkSize * (MBB->pred_size() - 1) > CloneInstrThreshold));
468 void AMDGPUCFGStructurizer::insertInstrEnd(MachineBasicBlock *MBB,
470  MachineInstr *MI = MBB->getParent()
472   MBB->push_back(MI);
477 MachineInstr *AMDGPUCFGStructurizer::insertInstrBefore(MachineBasicBlock *MBB,
480       MBB->getParent()->CreateMachineInstr(TII->get(NewOpcode), DL);
481   if (MBB->begin() != MBB->end())
482     MBB->insert(MBB->begin(), MI);
484     MBB->push_back(MI);
492   MachineBasicBlock *MBB = OldMI->getParent();
494       MBB->getParent()->CreateMachineInstr(TII->get(NewOpcode), DebugLoc());
495   MBB->insert(I, NewMBB);
504   MachineBasicBlock *MBB = OldMI->getParent();
505   MachineFunction *MF = MBB->getParent();
507   MBB->insert(I, NewMI);
525 void AMDGPUCFGStructurizer::insertCondBranchEnd(MachineBasicBlock *MBB,
527   MachineFunction *MF = MBB->getParent();
530   MBB->push_back(NewInstr);
580     MachineBasicBlock *MBB) {
581   MI->getOperand(0).setMBB(MBB);
585 AMDGPUCFGStructurizer::getFalseBranch(MachineBasicBlock *MBB,
587   assert(MBB->succ_size() == 2);
589   MachineBasicBlock::succ_iterator It = MBB->succ_begin();
617 DebugLoc AMDGPUCFGStructurizer::getLastDebugLocInBB(MachineBasicBlock *MBB) {
620   for (MachineBasicBlock::iterator It = MBB->begin(); It != MBB->end();
630     MachineBasicBlock *MBB) {
631   MachineBasicBlock::reverse_iterator It = MBB->rbegin();
639     MachineBasicBlock *MBB) {
640   for (MachineBasicBlock::reverse_iterator It = MBB->rbegin(), E = MBB->rend();
654 MachineInstr *AMDGPUCFGStructurizer::getReturnInstr(MachineBasicBlock *MBB) {
655   MachineBasicBlock::reverse_iterator It = MBB->rbegin();
656   if (It != MBB->rend()) {
664 MachineInstr *AMDGPUCFGStructurizer::getContinueInstr(MachineBasicBlock *MBB) {
665   MachineBasicBlock::reverse_iterator It = MBB->rbegin();
666   if (It != MBB->rend()) {
674 bool AMDGPUCFGStructurizer::isReturnBlock(MachineBasicBlock *MBB) {
675   MachineInstr *MI = getReturnInstr(MBB);
676   bool IsReturn = (MBB->succ_size() == 0);
681       dbgs() << "BB" << MBB->getNumber()
693 MachineBasicBlock *AMDGPUCFGStructurizer::clone(MachineBasicBlock *MBB) {
694   MachineFunction *Func = MBB->getParent();
697   for (MachineBasicBlock::iterator It = MBB->begin(), E = MBB->end();
714 void AMDGPUCFGStructurizer::wrapup(MachineBasicBlock *MBB) {
715   assert((!MBB->getParent()->getJumpTableInfo()
716           || MBB->getParent()->getJumpTableInfo()->isEmpty())
721    MachineBasicBlock::iterator Pre = MBB->begin();
722    MachineBasicBlock::iterator E = MBB->end();
773     MachineBasicBlock *MBB = *It;
774     removeUnconditionalBranch(MBB);
775     removeRedundantConditionalBranch(MBB);
776     if (isReturnBlock(MBB)) {
777       RetBlks.push_back(MBB);
779     assert(MBB->succ_size() <= 2);
803   MachineBasicBlock *MBB;
828       MBB = *It;
832         SccBeginMBB = MBB;
841       if (!isRetiredBlock(MBB))
842         patternMatch(MBB);
854             dbgs() << "Can't reduce SCC " << getSCCNum(MBB)
864             dbgs() << "repeat processing SCC" << getSCCNum(MBB)
933   MachineBasicBlock *MBB;
940       MBB = *blockIter;
941       OrderedBlks.push_back(MBB);
942       recordSccnum(MBB, SccNum);
950     MachineBasicBlock *MBB = &(*It);
951     SccNum = getSCCNum(MBB);
953       dbgs() << "unreachable block BB" << MBB->getNumber() << "\n";
957 int AMDGPUCFGStructurizer::patternMatch(MachineBasicBlock *MBB) {
962         dbgs() << "Begin patternMatch BB" << MBB->getNumber() << "\n";
965   while ((CurMatch = patternMatchGroup(MBB)) > 0)
969         dbgs() << "End patternMatch BB" << MBB->getNumber()
976 int AMDGPUCFGStructurizer::patternMatchGroup(MachineBasicBlock *MBB) {
979   NumMatch += serialPatternMatch(MBB);
980   NumMatch += ifPatternMatch(MBB);
985 int AMDGPUCFGStructurizer::serialPatternMatch(MachineBasicBlock *MBB) {
986   if (MBB->succ_size() != 1)
989   MachineBasicBlock *childBlk = *MBB->succ_begin();
993   mergeSerialBlock(MBB, childBlk);
998 int AMDGPUCFGStructurizer::ifPatternMatch(MachineBasicBlock *MBB) {
1000   if (MBB->succ_size() != 2)
1002   if (hasBackEdge(MBB))
1004   MachineInstr *BranchMI = getNormalBlockBranchInstr(MBB);
1014   MachineBasicBlock *FalseMBB = getFalseBranch(MBB, BranchMI);
1035     reversePredicateSetter(MBB->end());
1045     return NumMatch + handleJumpintoIf(MBB, TrueMBB, FalseMBB);
1054      Cloned += improveSimpleJumpintoIf(MBB, TrueMBB, FalseMBB, &LandBlk);
1058     TrueMBB = cloneBlockForPredecessor(TrueMBB, MBB);
1063     FalseMBB = cloneBlockForPredecessor(FalseMBB, MBB);
1067   mergeIfthenelseBlock(BranchMI, MBB, TrueMBB, FalseMBB, LandBlk);
1155     MachineBasicBlock *MBB = *It;
1156     if (LoopRep->contains(MBB)) {
1157       handleLoopcontBlock(MBB, MLI->getLoopFor(MBB),
1159       ContMBB.push_back(MBB);
1454       MachineBasicBlock *MBB = *PI;
1455       if (MBB != TrueMBB && MBB != FalseMBB)
1498     MachineBasicBlock *MBB, MachineBasicBlock *TrueMBB,
1502     dbgs() << "ifPattern BB" << MBB->getNumber();
1538     MBB->splice(I, TrueMBB, TrueMBB->begin(), TrueMBB->end());
1539     MBB->removeSuccessor(TrueMBB);
1548     MBB->splice(I, FalseMBB, FalseMBB->begin(),
1550     MBB->removeSuccessor(FalseMBB);
1561     MBB->addSuccessor(LandMBB);
1659 AMDGPUCFGStructurizer::cloneBlockForPredecessor(MachineBasicBlock *MBB,
1661   assert(PredMBB->isSuccessor(MBB) &&
1664   MachineBasicBlock *CloneMBB = clone(MBB);  //clone instructions
1665   replaceInstrUseOfBlockWith(PredMBB, MBB, CloneMBB);
1668   PredMBB->removeSuccessor(MBB);
1672   cloneSuccessorList(CloneMBB, MBB);
1674   numClonedInstr += MBB->size();
1678            << MBB->getNumber() << "size " << MBB->size() << "\n";
1748 void AMDGPUCFGStructurizer::removeUnconditionalBranch(MachineBasicBlock *MBB) {
1753   while ((BranchMI = getLoopendBlockBranchInstr(MBB))
1761     MachineBasicBlock *MBB) {
1762   if (MBB->succ_size() != 2)
1764   MachineBasicBlock *MBB1 = *MBB->succ_begin();
1765   MachineBasicBlock *MBB2 = *std::next(MBB->succ_begin());
1769   MachineInstr *BranchMI = getNormalBlockBranchInstr(MBB);
1774   MBB->removeSuccessor(MBB1);
1785     MachineBasicBlock *MBB = *It;
1786     MachineInstr *MI = getReturnInstr(MBB);
1789     MBB->addSuccessor(DummyExitBlk);
1791       dbgs() << "Add dummyExitBlock to BB" << MBB->getNumber()
1798 void AMDGPUCFGStructurizer::removeSuccessor(MachineBasicBlock *MBB) {
1799   while (MBB->succ_size())
1800     MBB->removeSuccessor(*MBB->succ_begin());
1803 void AMDGPUCFGStructurizer::recordSccnum(MachineBasicBlock *MBB,
1805   BlockInformation *&srcBlkInfo = BlockInfoMap[MBB];
1811 void AMDGPUCFGStructurizer::retireBlock(MachineBasicBlock *MBB) {
1813         dbgs() << "Retiring BB" << MBB->getNumber() << "\n";
1816   BlockInformation *&SrcBlkInfo = BlockInfoMap[MBB];
1822   assert(MBB->succ_size() == 0 && MBB->pred_size() == 0
1827     MachineBasicBlock *MBB) {
1829   if (!MBB) {
1830     MBB = FuncRep->CreateMachineBasicBlock();
1831     FuncRep->push_back(MBB);  //insert to function
1832     SHOWNEWBLK(MBB, "DummyLandingBlock for loop without break: ");
1834   TheEntry = MBB;
1838            << "  landing-block = BB" << MBB->getNumber() << "\n";
1880     MachineBasicBlock *MBB = *It;
1881     if (MBB != CommonDom)
1882       CommonDom = findNearestCommonPostDom(MBB, CommonDom);