[LLVMdev] Question regarding basic-block placement optimization

Chandler Carruth chandlerc at google.com
Tue Oct 18 17:22:15 PDT 2011

On Tue, Oct 18, 2011 at 4:31 PM, Jakob Stoklund Olesen <stoklund at 2pi.dk>wrote:

> On Oct 18, 2011, at 3:07 PM, Chandler Carruth wrote:
> On Tue, Oct 18, 2011 at 2:59 PM, Cameron Zwarich <zwarich at apple.com>wrote:
>> I think this should really live as a CodeGen pass. Is there any good
>> reason to make it an IR pass?
> So, as it happens, I was *completely* wrong here. CodeGen correctly
> preserves the ordering of blocks from IR, *unless* it can do folding, etc.
> That's right. However, the CFG changes quite a bit during CodeGen.
> Switches can be lowered into branch trees, multiple passes can split
> critical edges, and then there is taildup and tailmerge.
> An IR code layout algorithm simply doesn't know the final CFG.

To be clear, I don't disagree with any of this. =] However, my rough
experiments thus far (hoping to have real benchmark data soon) seem to
indicate that just giving a baseline ordering of block to the CodeGen layer

> As for why it should be an IR pass, mostly because once the selection dag
> runs through the code, we can never recover all of the freedom we have at
> the IR level. To start with, splicing MBBs around requires known about the
> terminators (which we only some of the time do), and it requires re-writing
> them a touch to account for the different fall-through pattern. To make
> matters worse, at this point we don't have the nicely analyzable 'switch'
> terminator (I think), and so the existing MBB placement code just bails on
> non-branch-exit blocks.
> Those are all the wrong reasons for not doing the right thing.

Sorry, I'm not trying to do the wrong thing because of this... Currently, it
feels like a trade-off in terms of cost/benefit. It's not yet clear to me
that the benefit of doing this analysis in the CodeGen layer outweighs the
cost and I was trying to clarify what the costs I perceive are.

Some basic blocks are glued together and must be placed next to each other.
> That situation can be recognized by "MBB->canFallThrough() &&
> TII->AnalyzeBranch(MBB..)".
> Treat glued-together blocks as super-blocks, and everything should be as
> breezy as IR.

But that's just the thing -- a primary goal of this pass would be to
*change* the fall-through pattern. Currently, that can be done very easily,
although to a limited extent, by changing the IR which enters the selection

Maybe what we need is to have this pass at both layers? Then the codegen
layer can work on the glued-together blocks to check for (and correct) any
inappropriate CFG changes made in the intervening passes?

Also, it's still not clear to me how to analyze switches in CodeGen, but
that's likely my lack of having read the appropriate interfaces thoroughly.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20111018/2163fe58/attachment.html>

More information about the llvm-dev mailing list