Lines Matching refs:basic
13 @findex basic-block.h
19 represent basic blocks and edges represent possible transfer of
20 control flow from one basic block to another. The data structures
22 @file{basic-block.h}.
39 * Basic Blocks:: The definition and representation of basic blocks.
50 @cindex basic block
52 A basic block is a straight-line sequence of code with only one entry
53 point and only one exit. In GCC, basic blocks are represented using
57 Special basic blocks represent possible entry and exit points of a
62 The @code{BASIC_BLOCK} array contains all basic blocks in an
66 The total number of basic blocks in the function is
67 @code{n_basic_blocks}. Both the basic block indices and
68 the total number of basic blocks may vary during the compilation
69 process, as passes reorder, create, duplicate, and destroy basic
78 doubly linked chain of basic blocks in the same order as the
79 underlying instruction stream. The chain of basic blocks is updated
81 @code{FOR_EACH_BB} can be used to visit all the basic blocks in
83 The macro @code{FOR_ALL_BB} also visits all basic blocks in
89 stored as vectors of basic block indices. The @code{BASIC_BLOCK} array
90 can be used to iterate each basic block by index.
92 @code{walk_dominator_tree}. Given two basic blocks A and B, block A
97 or @dfn{end} of the instruction stream contained in a basic block. In
100 and RTL), there are pointers to the head and end of a basic block for
113 Any function that moves or duplicates the basic blocks needs
120 basic block always follow a @code{NOTE_INSN_BASIC_BLOCK}, but zero
122 A basic block ends with a control flow instruction or with the last
126 the instruction stream of a basic block.
132 appear in the basic block and should always be placed just after the
144 contained in a basic block are in a @code{gimple_seq} pointed to by
145 the basic block intermediate language specific pointers.
147 and statements in a basic blocks. These iterators are called
184 basic block A to the head of another basic block B@. We say that A is
187 link between two basic blocks: The @code{src} member of an edge
188 points to the predecessor basic block of the @code{dest} basic block.
258 starts a new basic block. In this case a @dfn{fall-thru} edge links
259 the basic block to the first following basic block. But there are
274 Fall-thru edges are present in case where the basic block may continue
277 edges must come into the basic block immediately following in the
280 is needed. Note that this may require creation of a new basic block.
386 By definition, execution of function starts at basic block 0, so there
387 is always an edge from the @code{ENTRY_BLOCK_PTR} to basic block 0.
423 of executions of basic blocks and edges back to the compiler while
437 estimated frequencies of each basic block by propagating the
443 @code{frequency} is an estimation how often is basic block executed
446 basic block in function is initially set to @code{BB_FREQ_BASE} and
448 the frequency of the most frequent basic block can both decrease (for
460 basic block, but a few passes may want to know hard execution counts.
468 passing control from the end of the @code{src} basic block to the
469 @code{dest} basic block, i.e.@: the probability that control will flow
473 basic block.
475 The basic block frequencies are not represented in the instruction
483 destination basic block is called @dfn{reverse probability} and is not
485 of basic blocks.
525 and creating and deleting basic blocks. These hooks should provide
529 At the moment, the basic block boundaries are maintained transparently
532 basic block explicitly).
536 @code{BLOCK_FOR_INSN} value that represents pointer to the basic block
538 function @code{gimple_bb} returns a pointer to the basic block
552 the first non-empty statement in a basic block.
556 the last statement in a basic block.
560 represents the end of a basic block.
584 rechains the remaining statements in a basic block, if any.
589 may be used to get the head and end @code{rtx} of a basic block. No
600 call @code{purge_dead_edges} on a given basic block to remove
613 into the middle of a basic block, thus creating an entry point in the
614 middle of the basic block, which is impossible by definition: The
616 head of the basic block. The CFG hook @code{split_block} may be used
617 when an instruction in the middle of a basic block has to become the
631 edge into the instruction stream contained in a basic block. This
632 includes the creation of new basic blocks where needed. In the
670 The macros take a basic block number and return a bitmap that is indexed