[LLVMdev] Basic Block Chaining

[Chris Lattner]

On Thu, 20 Nov 2003, Reid Spencer wrote:

> Newbie Question .. (sorry if its redundant/silly) ..

No worries, this is good stuff to have archived on the list!

> As I've started to develop Stacker, I  had assumed that simply adding
> BasicBlocks to a function in sequence would imply that there is an
> implicit unconditional branch from the end of one basic block to the
> start of the next block. Based on the assertion checks that I get when I
> tried this, I assume that it is required to place a terminating
> instruction at the end of every basic block even if that should simply
> be a branch to the start of the next block. Is this indeed the case?

Yup, every basic block must end with a terminator.  The terminators are
what build the implicit CFG in LLVM (ie, the presence of terminators
makes pred_iterator & succ_iterator work on basic blocks).

> If it is, it would be "user friendly" to simply supply the branch
> instruction.  That is, provide a method on Function that appends a
> BasicBlock to the end of the block list. If the existing final basic
> block doesn't have a terminating instruction, simply add one that points
> to the block being appended.  Is this the RightThing(tm) or are there
> good reasons this can't or shouldn't be done?

I agree with Vikram that this would be hard to implement in a generally
useful way.  Besides that, you can always do something like this to add a
new basic block, assuming the last basic block in the function is
unterminated:

---

// Get the last basic block in the function, presumably you already have
// this cached somewhere.
BasicBlock *CurrentEnd = &F->back();

// Create the new basic block, adding the Function parameter causes it to
// be automatically inserted at the end of the function.
BasicBlock *New = new BasicBlock("label", F);

// Create a new branch instruction, jumping to the 'New' block.  Specify
// where in the LLVM program to insert it, in this case, at the end of the
// CurrentEnd block.
new BranchInst(New, CurrentEnd.end());

---

This is basically the strategy used to generate code by the C front-end as
well: there is always an unterminated block at the end of the function
which we are emitting statements into.  When a control flow instruction is
encountered, like an 'if', we emit the conditional branch, create a new
basic block to emit into, recursively generate the body, then emit the
else/fallthrough blocks.

-Chris

-- 
http://llvm.cs.uiuc.edu/
http://www.nondot.org/~sabre/Projects/