search for: predbb

Hi all, I have faced a little bit of a strange transformation from the TailDuplicatePass In CodeGen. When the pass clones the contents of TailBB into PredBB, the bundled instructions in TailBB are not bundled in PredBB. I think the reason why it is not bundled is that the 'DuplicateInstruction' function does not set up the flag of the first instruction of the bundle in PredBB when it is cloned from TailBB. If the first instruction of the bu...

I think you realized this now, but to be clear: More likely, you've found some bugs. Unfortunately, not all of these utilities have good unit tests (though they should!). This would not be the first set of bugs people have found wrt to very start/end of blocks, or bb == predbb issues. On Sat, Feb 24, 2018 at 12:58 PM, Fedor Indutny via llvm-dev < llvm-dev at lists.llvm.org> wrote: > Update: > > I was able to make progress on it today ( See https://reviews.llvm.org/ > D43729 ). Apparently my problems were: > > * Iterating through the instruction...

...you realized this now, but to be clear: > More likely, you've found some bugs. > Unfortunately, not all of these utilities have good unit tests (though > they should!). > > This would not be the first set of bugs people have found wrt to very > start/end of blocks, or bb == predbb issues. > Coincidentally I stumbled over a similar issue with bb == predbb in DuplicateInstructionsInSplitBetween too and put up a patch trying to fix it https://reviews.llvm.org/D43822 > > On Sat, Feb 24, 2018 at 12:58 PM, Fedor Indutny via llvm-dev > <llvm-dev at lists.llvm....

...lonedLoop = cloneLoopWithPreheader(PreHeader, PreHeader, L, VMap, NameSuffix, LI, &DT, Blocks); VMap[ExitBlock] = PreHeader; // chain: cloned loop -> original loop remapInstructionsInBlocks(Blocks, VMap); // remap original predecessors to the cloned loop for (BasicBlock *PredBB : AllPredecessors) { Instruction *TI = PredBB->getTerminator(); for (unsigned i = 0; i < TI->getNumOperands(); i++) { if (TI->getOperand(i) == PreHeader) TI->setOperand(i, ClonedLoop->getLoopPreheader()); } } return...

...B#2 BB#3 %vreg2<def> = PHI %vreg0, <BB#2>, %vreg1, <BB#3>; rN:%vreg2 aNlh_0_7:%vreg0 aNlh_rN:%vreg1 mv_a32_r16_rmod1 %vreg3, %vreg2; aN32_0_7:%vreg3 rN:%vreg2 brr_uncond <BB#6>; Successors according to CFG: BB#6(?%) Then TailDuplication runs Tail-duplicating into PredBB: BB#2: derived from LLVM BB %bb2 [...] From Succ: BB#4: derived from LLVM BB %bb4 and we get: BB#2: derived from LLVM BB %bb2 Predecessors according to CFG: BB#1 %vreg12<def> = mv16Sym <ga:@a>; rN:%vreg12 %vreg13<def> = mv_nimm6_ar16 0; aNlh_rN:%vreg13 mv_ar16_r16_rmod1...

Hi all, Is there a way to walk through ALL the predecessors of a basic block in a CFG. I tried to iterate over the preds using this method for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++I) { BasicBlock *PredBB = *PI; } but this only gives the immediate predecessors for a basic block. For example, in this sample control flow graph. entry -> bb1 -> bb2 -> bb4 -> return | | bb3 <-| walking over the predecessors for bb2 only gives bb3 and bb1....

On Tue, May 19, 2009 at 12:30 PM, Nicolas Geoffray <nicolas.geoffray at lip6.fr> wrote: >> The pi functions can be implemented with copy instructions. > > Store instructions? I would assume something more like "select i1 true, <ty> %val, <ty> undef". -Eli

...as Geoffray > <nicolas.geoffray at lip6.fr> wrote: >>> The pi functions can be implemented with copy instructions. >> Store instructions? > > I would assume something more like "select i1 true, <ty> %val, <ty> undef". %x = phi <ty> [%val, %predbb]. Nick

...(Instruction *OldI, IRBuilder<> &IRB) { > if (isControlFlowInst(OldI)) return IRB.CreateExtractElement; // Don't > vectorize branches > return createVectorVersionOfInstruction(OldI, VF, IRB); // Defined > somewhere in LoopVectorize > } > }; > BasicBlock *PredBB; > Delegate D; > LoopEditor LE(L, DT, SE, LI); > LoopEditor VectorLE = LE.versionWidenAndInterleaveLoop(UF, PredBB, &D); > VectorLE.widen(VF); // Widen further, so it's widened by VF*UF. Only > affects induction variable steps and trip count. > > How does that look to y...

Some time ago I developed a fast BitVector class to use in some research here. It uses expression templates to fuse operation loops and runs much faster than the existing BitVector for some important use-cases. It also has the ability to efficiently report if a BitVector's contents changed after some operation. For example: ETBitVector A = ... ETBitVector B = ... ETBitVector C = ... bool

..., Prabhat Kumar Saraswat wrote: > Hi all, > > Is there a way to walk through ALL the predecessors of a basic block > in a CFG. I tried to iterate over the preds using this method > > for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; + > +I) { > BasicBlock *PredBB = *PI; > } > > but this only gives the immediate predecessors for a basic block. > > For example, in this sample control flow graph. > > entry -> bb1 -> bb2 -> bb4 -> return > | | > bb3 <-| > > > walking o...

...gt; Hi all, > > > > Is there a way to walk through ALL the predecessors of a basic block > > in a CFG. I tried to iterate over the preds using this method > > > > for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; + > > +I) { > > BasicBlock *PredBB = *PI; > > } > > > > but this only gives the immediate predecessors for a basic block. > > > > For example, in this sample control flow graph. > > > > entry -> bb1 -> bb2 -> bb4 -> return > > | | > >...

...gt; FBB->addLiveIn(Def); ==== //dwarc/Tools/MetaWare/Toolset/main/dev/llvm/lib/CodeGen/TailDuplication.cpp#6 - /remote/arctools/marksl/marksl_1/llvm/lib/CodeGen/TailDuplication.cpp ==== 798c798 < if (!RegsLiveAtExit[*I]) --- > if (!RegsLiveAtExit[*I] && !PredBB->isLiveIn(*I)) -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20130604/8aee9038/attachment.html>

Update: I was able to make progress on it today ( See https://reviews.llvm.org/D43729 ). Apparently my problems were: * Iterating through the instruction/block list after erasing block/instruction * Trying to split block after removing one predecessor Regarding the latter, it appears that semantics of `DuplicateInstructionsInSplitBetween` change significantly in such case, and it starts to loop

Hello! I've discovered that `CallSiteSplitting` optimization doesn't support musttail calls. The easiest fix as it stands is disabling it for such call sites: https://reviews.llvm.org/D43729 . However, I'm not happy with such contribution. My more sophisticated attempt has failed due to my poor understanding of llvm internals. Here is the attempted patch:

Hi! I want to know How to count the number of predecessors for each basic block? Thank You ____________________________________________________________________________________ Never miss a thing. Make Yahoo your home page. http://www.yahoo.com/r/hs

...ay at lip6.fr> wrote: >>>> The pi functions can be implemented with copy instructions. >>> Store instructions? >> >> I would assume something more like "select i1 true, <ty> %val, <ty> >> undef". > > %x = phi <ty> [%val, %predbb]. FWIW, I strongly recommend going this direction. It'll buy you a lot of free functionality, like replaceAllUsesWith(). --Owen -------------- next part -------------- A non-text attachment was scrubbed... Name: smime.p7s Type: application/pkcs7-signature Size: 2620 bytes Desc: not availab...