Lines Matching +defs:indent +defs:to
20 /* This file contains low level functions to manipulate the CFG and analyze it
27 - Edge splitting and committing to edges
35 - Infrastructure to determine quickly basic block for insn
166 Convert them to the special NOTE_INSN_DELETED_LABEL note. */
268 insns that cannot be removed to NULL. */
275 /* Unchain the insns one by one. It would be quicker to delete all of these
276 with a single unchaining, rather than one at a time, but we need to keep
298 inclusive. This function is designed to allow fast BB construction - reuses
301 END can be NULL in to create new empty basic block before HEAD. Both END
302 and HEAD can be NULL to create basic block at the end of INSN chain.
379 and place it to the BB chain after block AFTER. END can be NULL to
381 NULL to create basic block at the end of INSN chain. */
422 to post-process the stream to remove empty blocks, loops, ranges, etc. */
431 to remove the label from the exception_handler_label list. */
511 /* The resource.c machinery uses DF but the CFG isn't guaranteed to be
512 valid at that point so it would be too late to call df_analyze. */
535 /* Return RTX to emit after when we want to emit code on the entry of function. */
572 /* Update BLOCK_FOR_INSN of insns in BB to BB,
593 programs that fail to return a value. Its effect is to
595 function. If we allow it to be skipped, we introduce the
605 /* Return true if the block has no effect and only forwards control flow to
665 /* ??? Later we may add code to move jump tables offline. */
683 edge to the exit block, we can't do that. */
846 /* Blocks A and B are to be merged into a single block A. The insns
904 /* If this was a conditional jump, we need to also delete
974 /* If we are partitioning hot/cold basic blocks, we don't want to
978 Basic block partitioning may result in some jumps that appear to
979 be optimizable (or blocks that appear to be mergeable), but which really
980 must be left untouched (they are required to make it safely across
1026 /* Attempt to perform edge redirection by replacing possibly complex jump
1028 apply only if all edges now point to the same block. The parameters and
1029 return values are equivalent to redirect_edge_and_branch. */
1039 /* If we are partitioning hot/cold basic blocks, we don't want to
1043 Basic block partitioning may result in some jumps that appear to
1044 be optimizable (or blocks that appear to be mergeable), but which really
1045 must be left untouched (they are required to make it safely across
1057 edge that is not E must also go to TARGET. */
1072 /* In case we zap a conditional jump, we'll need to kill
1123 fprintf (dump_file, "Redirecting jump %i from %i to %i.\n",
1154 /* Recognize a tablejump that we are converting to a
1206 /* Subroutine of redirect_branch_edge that tries to patch the jump
1294 one basic block to the other in case only one computed_jump is
1349 fprintf (dump_file, "Edge %i->%i redirected to %i\n",
1358 /* Called when edge E has been redirected to a new destination,
1359 in order to update the region crossing flag on the edge and
1402 /* Called when block BB has been reassigned to the cold partition,
1404 to ensure that the region crossing attributes are updated. */
1412 /* This is called when a hot bb is found to now be dominated
1413 by a cold bb and therefore needs to become cold. Therefore,
1423 /* Possibly need to make bb's successor edges region crossing,
1439 /* Attempt to change code to redirect edge E to TARGET. Don't do that on
1442 Function can be also called with edge destination equivalent to the TARGET.
1448 managed to simplify instruction stream. */
1510 when redirecting to the EXIT_BLOCK, it is either ret_rtx or
1511 simple_return_rtx, indicating which kind of returnjump to create.
1524 /* In the case the last instruction is conditional jump to the next
1526 by creating a basic block afterwards to redirect fallthru edge. */
1545 /* Update this to use GCOV_COMPUTE_SCALE. */
1558 /* Irritating special case - fallthru edge to the same block as abnormal
1561 one and create separate abnormal edge to original destination.
1562 This allows bb-reorder to make such edge non-fallthru. */
1573 at the start of the function which we use to add the new
1582 /* Change the existing edge's source to be the new block, and add
1583 a new edge from the entry block to the new block. */
1607 don't point to the target or fallthru label. */
1695 /* If asm goto has any label refs to target's label,
1696 add also edge from asm goto bb to target. */
1759 /* Edge E is assumed to be fallthru edge. Emit needed jump instruction
1760 (and possibly create new basic block) to make edge non-fallthru.
1780 /* In case the edge redirection failed, try to force it to be non-fallthru
1797 and the target label. They ought to be chastised and fixed.
1825 a note instead and move before the tablejump that is going to
1837 /* If this was a conditional jump, we need to also delete
1881 ??? The code generally expects to be called on critical edges.
1882 The case of a block ending in an unconditional jump to a
1894 /* We are going to place the new block in front of edge destination.
1910 /* If this is a fall through edge to the exit block, the blocks might be
1930 boundary, the new block needs to be inserted in the bb chain
1935 to a different block. */
1947 /* Put the split bb into the src partition, to avoid creating
1957 /* Can't allow a region crossing edge to be fallthrough. */
1966 jump instruction to target our new block. */
1977 need insn patching, as other labels might point to the
2001 It will be easier to find the culprit if we die now. */
2027 /* Figure out where to put these insns. If the destination has
2064 /* It is possible to have a non-simple jump here. Consider a target
2086 /* If E crossed a partition boundary, we needed to make bb end in
2108 to EXIT. */
2132 previously reached by both hot and cold blocks to become dominated only
2133 by cold blocks. This will cause the verification below to fail,
2134 and lead to now cold code in the hot section. In some cases this
2162 rtl_dump_bb (FILE *outf, basic_block bb, int indent, int flags)
2168 s_indent = (char *) alloca ((size_t) indent + 1);
2169 memset (s_indent, ' ', (size_t) indent);
2170 s_indent[indent] = '\0';
2338 /* Sanity check partition hotness to ensure that basic blocks in
2423 /* Do the partition fixup after all necessary blocks have been converted to
2425 places, which can require forcing edges to be non fallthru. */
2670 block. It ought to contain optional CODE_LABEL followed
2848 /* Work backwards from the end to the head of the basic block
2849 to verify the head is in the RTL chain. */
2893 /* Verify that fallthru edges point to adjacent blocks in layout order and
3022 cfglayout RTL, plus consistency checks specific to linearized RTL mode.
3031 - check that all fallthru edge points to the adjacent blocks
3089 /* There are three types of edges we need to handle correctly here: EH
3143 /* Avoid abnormal flags to leak from computed jumps turned
3173 /* Keep the edges that correspond to exceptions thrown by
3213 /* Update these to use GCOV_COMPUTE_SCALE. */
3236 edge we know that there used to be a jump here and can then safely
3295 calls, moving the basic block's end, while they in fact do want to emit
3353 edge. Simply delete this use and don't try to insert
3384 /* Cut the insns from FIRST to LAST out of the insns stream. */
3459 /* It is possible to hit contradictory sequence. For instance:
3465 Where barrier belongs to jump_insn, but the note does not. This can be
3655 to GIMPLE a long time ago, but it doesn't relink the basic block
3656 chain. It could do that (to give better initial RTL) if this function
3657 is made IR-agnostic (and moved to cfganal.c or cfg.c while at it). */
3719 /* Given a reorder chain, rearrange the code to match. */
3735 /* First do the bulk reordering -- rechain the blocks without regard to
3736 the needed changes to jumps and labels. */
3779 /* Now add jumps and labels as needed to match the blocks new
3812 Make the basic block to end with a barrier in order
3813 to prevent rtl_verify_flow_info from complaining. */
3823 /* If the old fallthru is still next, nothing to do. */
3828 /* The degenerated case of conditional jump jumping to the next
3830 to construct a forwarder block and this will be done just
3837 need to add a new unconditional jump. Choose the taken
3866 /* Otherwise we can try to invert the jump. This will
3889 __builtin_unreachable ()), nothing to do. */
3895 /* Otherwise we'll have to use the fallthru fixup below. */
3909 something similarly bizarre. In any case, we don't need to
3914 /* If the fallthru block is still next, nothing to do. */
3918 /* A fallthru to exit block. */
3923 /* We got here if we need to add a new jump insn.
3924 Note force_nonfallthru can delete E_FALL and thus we have to
3925 save E_FALL->src prior to the call to force_nonfallthru. */
3981 /* Non-fallthru edges to the exit block cannot be split. */
4001 /* If there are other incoming edges to the destination block
4002 with the same goto locus, redirect them to the new block as
4045 /* If we have assembler epilogues, the block falling through to exit must
4068 edge, we have to split that block. */
4142 /* Return true in case it is possible to duplicate the basic block BB. */
4147 /* Do not attempt to duplicate tablejumps, as we need to unshare
4148 the dispatch table. This is difficult to do, as the instructions
4171 duplicate_insn_chain (rtx_insn *from, rtx_insn *to)
4182 for (insn = from; insn != NEXT_INSN (to); insn = NEXT_INSN (insn))
4208 next != NEXT_INSN (to);
4212 if (next != NEXT_INSN (to) && BARRIER_P (next))
4227 in first BB, we may want to copy the block. */
4233 /* No problem to strip these. */
4235 /* There is always just single entry to function. */
4298 /* Main entry point to this module - initialize the datastructures for
4299 CFG layout changes. It keeps LOOPS up-to-date if not null.
4301 FLAGS is a set of additional flags to pass to cleanup_cfg(). */
4312 layout required moving a block from the hot to the cold
4362 /* Finalize the changes: reorder insn list according to the sequence specified
4405 /* Redirect Edge to DEST. */
4429 fprintf (dump_file, "Redirecting entry edge from bb %i to %i\n",
4437 /* Redirect_edge_and_branch may decide to turn branch into fallthru edge
4438 in the case the basic block appears to be in sequence. Avoid this
4452 "%i->%i redirected to %i\n",
4461 /* In case we are redirecting fallthru edge to the branch edge
4474 fprintf (dump_file, "Redirecting fallthru edge %i->%i to %i\n",
4504 rtx_insn **to;
4554 to = &BB_HEADER (bb->next_bb);
4556 to = &cfg_layout_function_footer;
4575 SET_NEXT_INSN (insn) = *to;
4576 if (*to)
4577 SET_PREV_INSN (*to) = insn;
4578 *to = remaints;
4587 /* If we are partitioning hot/cold basic blocks, we don't want to
4591 Basic block partitioning may result in some jumps that appear to
4592 be optimizable (or blocks that appear to be mergeable), but which really
4593 must be left untouched (they are required to make it safely across
4625 not allow us to redirect an edge by replacing a table jump. */
4651 /* We should have fallthru edge in a, or we can do dummy redirection to get
4714 We need to explicitly call. */
4833 /* Return true if we need to add fake edge to exit.
4856 /* Add fake edges to the function exit for any non constant and non noreturn
4858 BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks
4861 The goal is to expose cases in which entering a basic block does not imply
4882 a fallthru edge to EXIT. Special care is required if the last insn
4889 profiler needs to take this into account in order to solve the minimal
4916 /* Now add fake edges to the function exit for any non constant
4948 should be enough to verify that there is no edge to the exit
4950 cause us to mark that edge as fake and remove it later. */
4985 there is no need to handle this here the loop versioning code handles
5051 /* Returns true if it is possible to remove edge E by redirecting
5052 it to the destination of the other edge from E->src. */
5152 basic block connected via fallthru edges does not have to be adjacent.