Lines Matching defs:is
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
76 is not supported;
83 A vinsn, or virtual insn, is an insn with additional data characterizing
86 different expressions. A vinsn is described by vinsn_t type.
88 An expression is a vinsn with additional data characterizing its properties
91 An expression is described by expr_t type.
93 Availability set (av_set) is a set of expressions at a given control flow
94 point. It is represented as av_set_t. The expressions in av sets are kept
98 A fence is a point through which code motion is prohibited. On each step,
99 we gather a parallel group of insns at a fence. It is possible to have
100 multiple fences. A fence is represented via fence_t.
102 A boundary is the border between the fence group and the rest of the code.
104 the fence group when a jump is scheduled. A boundary is represented
112 loop is pipelined, its prologue can be scheduled together with yet unprocessed
115 order, and a block is added to a region to which all its predecessors belong;
122 group. Second, we choose the best expression from it. If the stall is
133 The computation (compute_av_set) is a bottom-up traversal. At each insn,
137 exprs. Then the expr corresponding to the current insn is added.
138 The result is saved on each basic block header.
171 point. If a copy is not needed, it will be removed later during this
185 dependence is found in a particular part of an insn. Using these hooks, we
201 The same splitting is done with current_sched_info structure:
202 dependence-related parts are in sched_deps_info, common part is in
203 common_sched_info, and haifa/sel/etc part is in current_sched_info.
219 As the correct data dependence graph is not supported during scheduling (which
220 is to be changed in mid-term), we cache as much of the dependence analysis
227 whether the given expression is ready for scheduling by removing from it
265 /* True when pipelining is enabled. */
268 /* True if bookkeeping is enabled. */
281 /* The expression is not changed. */
314 /* True when regs_for_mode[mode] is initialized. */
318 The register in question is always set. If not, this means
319 that the whole set is not computed yet. */
391 /* An UID of expr_vliw which is to be moved up. If we find other exprs,
396 /* This is initialized to the insn on which the driver stopped its traversal. */
428 /* Called when original expr is found. */
431 /* Called while descending current basic block if current insn is not
467 This is used in sched_rgn_local_init and in various places in
471 /* GLOBAL_LEVEL is used to discard information stored in basic block headers
472 av_sets. Av_set of bb header is valid if its (bb header's) level is equal
473 to GLOBAL_LEVEL. And invalid if lesser. This is primarily used to advance
483 /* Used in verify_target_availability to assert that target reg is reported
486 if scheduled_something_on_previous_fence is true, TARGET_UNAVAILABLE can
494 /* Set of basic blocks that are forced to start new ebbs. This is a subset
518 /* A vector of expressions is used to be able to sort them. */
521 /* A vector of vinsns is used to hold temporary lists of vinsns. */
644 to the new fence. ORIG_MAX_SEQNO is the maximal seqno before this round
725 /* Returns whether INSN with dependence status DS is eligible for
726 substitution, i.e. it's a copy operation x := y, and RHS that is
747 source (if INSN is eligible for substitution). Returns TRUE if
750 destination or the resulting insn is invalid for the target machine.
751 When UNDO is true, perform unsubstitution instead (the difference is in
752 the part of rtx on which validate_replace_rtx is called). */
764 If the insn is not SET, we may still be able to substitute something
832 /* Bail out if mode is different or more than one register is
851 /* Returns TRUE if WHAT is found in WHERE rtx tree. */
880 NEW_SRC_REG. E.g. the following insn is valid for i386:
977 if a register is a hard one, one of the UNAVAILABLE_HARD_REGS registers. */
1052 may result in returning NO_REGS, cause flags is written implicitly through
1084 /* Check whether this is all calculated. */
1162 /* Initialize registers that are valid based on mode when this is
1167 /* Mark that all HARD_REGNO_RENAME_OK is not calculated. */
1182 if it isn't in USED_REGS. DEF is a definition insn of rhs for which the
1183 destination register is sought. LHS (DEF->ORIG_INSN) may be REG or MEM.
1203 is usually a register. */
1216 /* Stop if the original register is one of the fixed_regs, global_regs or
1238 FIXME: it is enough to do this once per all original defs. */
1251 is equivalent to as if all stack regs were in this set.
1314 /* Regno is always ok from the renaming part of view, but it really
1327 /* Choose the register among free, that is suitable for storing
1330 ORIGINAL_INSNS is the list of insns where the operation (rhs)
1335 Some code is adapted from regrename.c (regrename_optimize).
1336 If original register is available, function returns it.
1349 tick is returned to achieve more even register allocation.
1353 If no register satisfies the above conditions, NULL_RTX is returned. */
1367 /* If original register is available, return it. */
1377 This is done for the next loop; if we'd return from this
1456 /* Choose the pseudo register for storing rhs value. As this is supposed
1478 /* If original register is available, return it. */
1521 cross one. This condition is written in accordance with
1556 /* True when target of EXPR is available due to EXPR_TARGET_AVAILABLE,
1583 /* When target is not available, it may be due to hard register
1591 in which successors target register is actually available.
1635 /* FIXME: the assert is true until we'd have several boundaries. */
1641 /* Return TRUE if it is possible to replace LHSes of ORIG_INSNS with BEST_REG.
1642 If BEST_REG is valid, replace LHS of EXPR with it. */
1673 * EXPR_SEPARABLE_P is true but we were unable to find suitable register;
1674 * EXPR_SEPARABLE_P is false but the insn sets/clobbers one of the registers
1740 when EXPR's LHS is unavailable, and there is another LHS among
1807 C_EXPR is a speculative expression,
1809 ORIG_INSN is the original non-speculative insn in the stream. */
1819 /* Create a recovery block if target is going to emit branchy check, or if
1881 /* True when INSN is a "regN = regN" copy. */
1912 /* First, kill any EXPR that uses registers set by an insn. This is
1982 copy, which was in turn substituted. The history is wrong
2005 The difference from the below function is that only substitution is
2021 /* Substitution is the possible choice in this case. */
2044 /* This is either an output or an anti dependence, which usually have
2111 between EXPR and THROUGH_INSN is found because of renaming. */
2169 made in PTRANS_TYPE, when it is not NULL. When INSIDE_INSN_GROUP,
2187 insn is pulled ahead of it. It's hard to figure out how to
2203 dependencies allow to do so and jump is not speculative). */
2294 Anyways, we should mark that the original register is
2317 If dependency is in RHS, then try to perform substitution and move up
2426 /* This is the only case when propagation result can change over time,
2440 " is now disabled)\n");
2503 as it is always true, which is not useful outside the group. */
2729 /* Returns true if INSN is not a downward continuation of the given path P in
2736 /* Check if insn is not deleted. */
2742 /* If it's the first insn visited, then the successor is ok. */
2750 /* is already visited. */
2754 would be equal to seqno of prev_insn. This is possible
2755 when prev_insn is a previously created bookkeeping copy.
2757 whether insn is in current fence too. */
2763 scheduled earlier even if this insn is not in
2773 of handling multiple successors and properly merging its av_sets. P is
2774 the current path traversed. WS is the size of lookahead window.
2781 int is;
2804 FOR_EACH_VEC_ELT (sinfo->succs_ok, is, succ)
2812 sinfo->probs_ok[is],
2820 if (is == 0)
2840 if (sinfo->succs_ok_n == 2 && is == 1)
2858 FOR_EACH_VEC_ELT (sinfo->succs_ok, is, succ)
2869 FOR_EACH_VEC_ELT (sinfo->succs_other, is, succ)
2888 branches from av_set if current operator is a conditional
2912 traversed on the way to the FIRST_INSN (the path is sparse, only bb heads
2927 /* Return NULL if insn is not on the legitimate downward path. */
2931 sel_print ("Insn %d is ineligible_successor\n", INSN_UID (first_insn));
2982 sel_print ("Insn %d is ineligible_successor\n", INSN_UID (last_insn));
2996 sel_print ("Insn %d is beyond the software lookahead window size\n",
3011 /* This is needed only to obtain av_sets that are identical to
3017 /* END_WS is always already increased by 1 if LAST_INSN == AFTER_BB_END. */
3030 /* If the expression for CUR_INSN is already in the set,
3063 P - the current path, which is list of insns visited so far
3117 it at INSN if INSN is bb header. */
3160 Start searching from the next insn: either ignore_first is true, or
3238 of INSN. EXPR is one of the original ops we are searching for. */
3280 if one of the following conditions is not satisfied:
3287 (3) not live on the other path of any conditional branch that is passed
3294 REG_RENAME_P->CROSSES_CALL is true, if there is a call insn on the path
3296 to unavailable hard regs at the point original operation is found. */
3330 av sets. This information is not as precise as it could be due to
3412 /* Now uniqueness means SCHED_GROUP_P is set, because schedule groups
3486 We can't safely use INSN_LUID as it is defined only for those insns
3527 /* The probability of a success is too low - don't speculate. */
3729 true if there is something to schedule. BNDS and FENCE are current
3774 /* Filter out inappropriate expressions. Loop's direction is reversed to
3808 /* If the availability of the EXPR is invalidated by the insertion of
3810 scheduling if it's not separable, and if it is separable, then
3816 sel_print ("Expr %d is blocked by bookkeeping inserted earlier\n",
3900 /* Don't allow any insns whose data is not yet ready.
3919 sel_print ("Expr %d is not ready until cycle %d (cached)\n",
3957 sel_print ("Expr %d is not ready yet until cycle %d\n",
3964 sel_print ("Expr %d is ok\n", INSN_UID (insn));
3982 when ready list is empty. */
4104 we can issue. FENCE is the current fence. */
4194 FOLLOW_READY_ELEMENT is true (i.e., an expr of
4229 /* In this loop insn is Ith element of the ready list given by
4295 number is ISSUE_MORE. FENCE and BEST_INSN are the current fence
4351 /* This is asm insn which is tryed to be issued on the
4435 /* Try choosing the best insn until we find one that is could be
4535 one must be created. If LAX holds, don't assume there is a simple path
4623 now is to swap the block numbers of new_bb and
4750 sel_print ("New block is %i, split from bookkeeping block %i\n",
4756 sel_print ("Pre-existing bookkeeping block is %i\n", book_block->index);
4834 All scheduler data is initialized for the newly created insn. */
4864 when single instruction is added to new basic block it should hold NULL
4882 /* An expression does not need bookkeeping if it is available on all paths
4885 EXPR_SPEC; this is not equivalent, because it may be positive even
4886 if expr is available on all paths (but if expr is not available on
4923 This is done in this way: first, new fallthrough basic block is created
4924 after jump (it is always can be done, because there already should be a
4929 to this new block. And the result is this:
4952 basic blocks. The only exception is when we move a jump through
4971 /* Jump is moved to the boundary. */
5013 /* Assert there is no jump to BLOCK_NEW, only fallthrough edge. */
5020 instructions from the other branch of INSN is no longer
5027 /* INSN is a new basic block header - so prepare its data
5059 tells us so. Next instruction is fetched from BNDS. */
5079 /* Compute available instructions on BNDS. FENCE is the current fence. Write
5138 expression. When FOR_MOVEOP is true, also replace the register of
5164 This is needed when renaming came up with original
5179 /* With substitution inside insn group, it is possible
5233 if (/* If this is not the first insn scheduled. */
5253 /* Add it before BND_TO. The difference is in the
5276 data sets. After that all we have to do is add the operation
5329 /* Advance state on FENCE with INSN. Return true if INSN is
5375 is nonzero if we need to stall after issuing INSN. */
5381 /* First, reflect that something is scheduled on this fence. */
5482 prepare CFG. After this, jump is at the boundary and can be
5499 /* Add the instruction. The corner case to care about is when
5501 is not equal to expr_vliw. Then expr_vliw may be insn in stream, and
5727 /* First, get correct liveness in the bookkeeping block. The problem is
5734 fence above, where we may choose to schedule an insn which is
5742 CUR_EXPR is in new AV_SET. */
5763 /* The main effect of this function is that sparams->c_expr is merged
5766 lparams->c_expr_merged is copied back to sparams->c_expr after all
5767 successors has been traversed. lparams->c_expr_local is an expr allocated
5768 on stack in the caller function, and is used if there is more than one
5771 SUCC is one of the SUCCS_NORMAL successors of INSN,
5772 MOVEOP_DRV_CALL_RES is the result of call code_motion_path_driver on succ,
5786 /* If this is a first successor. */
5807 However, EXPR_SCHED_TIMES is different -- we must get
5824 SUCC is one of the SUCCS_NORMAL successors of INSN,
5825 MOVEOP_DRV_CALL_RES is the result of call code_motion_path_driver on succ or 0,
5826 if SUCC is one of SUCCS_BACK or SUCCS_OUT.
5840 for such branches code_motion_path_driver is not called. */
5846 that is passed by the operation, in case original
5853 /* This function is called after the last successor. Copies LP->C_EXPR_MERGED
5864 rescheduling when INSN is found by move_op. */
5891 emitted one. PARAMS is the move_op static parameters. */
5907 that expr is not original operation's dest reg, substitute
5930 Return true if we've emitted one. PARAMS is the move_op static
5973 /* If INSN is the only insn in the basic block (not counting JUMP,
6018 /* Remove INSN from stream. When ONLY_DISCONNECT is true, its data
6019 is not removed but reused when INSN is re-emitted. */
6023 /* If there's only one insn in the BB, make sure that a nop is
6037 /* This function is called when original expr is found.
6039 LPARAMS is the local parameters of code modion driver, STATIC_PARAMS
6040 is static parameters of move_op. */
6060 /* The function is called when original expr is found.
6105 /* This function is called on the ascending pass, before returning from
6148 been scheduled, the CFG is as follows:
6163 way insn "r1 := r2" is no longer available as a whole instruction
6165 This situation is handled by calling update_data_sets.
6167 Since update_data_sets is called only on the bookkeeping block, and
6188 /* This function is called on the ascending pass, before returning from the
6217 /* This function is called on enter to the basic block.
6254 /* This function is called while descending current basic block if current
6255 insn is not the original EXPR we're searching for.
6278 /* This function is called while descending current basic block if current
6279 insn is not the original EXPR we're searching for.
6304 untouchable set only if there is an insn in ORIG_OPS that can
6354 /* Traverse all successors of INSN. For each successor that is SUCCS_NORMAL
6355 code_motion_path_driver is called recursively. Original operation
6356 was found at least on one path that is starting with one of INSN's
6357 successors (this fact is asserted). ORIG_OPS is expressions we're looking
6358 for, PATH is the path we've traversed, STATIC_PARAMS is the parameters
6444 only if at some point the expr searched is present in av_set, but is
6445 not found below. In most cases, this situation is an error.
6446 The exception is when the original operation is blocked by
6464 /* Perform a cleanup when the driver is about to terminate. ORIG_OPS_P
6465 is the pointer to the av set with expressions we were looking for,
6466 PATH_P is the pointer to the traversed path. */
6475 functionality dependent whether code_motion_path_driver_INFO is set to
6478 is the insn we're starting the search from, ORIG_OPS are the expressions
6479 we're searching for, PATH is traversed path, LOCAL_PARAMS_IN are local
6510 sel_print ("Insn %d is ineligible successor\n", INSN_UID (insn));
6570 /* It is not possible that all ORIG_OPS are filtered out. */
6573 /* It is enough to place only heads and tails of visited basic blocks into
6585 scheduling operation. If it is so, then the insn "dest = op" could
6594 When traversing the DAG below this insn is finished, insert
6595 bookkeeping code, if the insn is a joint point, and remove
6691 /* This is the case when one of the original expr is no longer available
6736 DEST is the register chosen for scheduling the current expr. Insert
6737 bookkeeping code in the join points. EXPR_VLIW is the chosen expression,
6738 C_EXPR is how it looks like at the given cfg point.
6742 Returns whether original instructions were found, which is asserted
6824 blocks on which we're rescheduling when pipelining, FROM is the block where
6856 /* cur_seqno may be positive if the number of instructions is less than
6935 /* Even if sched_is_disabled_for_current_region_p() is true, we still
6975 This is the only situation when we can't update liveness when calling
7113 /* This is asm insn which *had* to be scheduled first
7117 /* This is a use/clobber insn. It should not change
7151 issued, but on the next cycle it says that insn is ready
7159 /* When the data dependency stall is longer than the DFA stall,
7259 sel_print ("Cost for insn %d is %d\n", INSN_UID (insn), cost);
7264 RESET_SCHED_CYCLES_P is true, run a pass emulating the scheduler
7309 is true, make an additional pass emulating scheduler to get correct insn
7369 is the current maximum seqno. SCHEDULED_INSNS_TAILPP is the list
7394 on the cycle is guaranteed by two properties:
7420 /* As FENCE is nonnull, SEQNO is initialized. */
7439 /* The first element is already processed. */
7495 are the miminum and maximum seqnos of the group, HIGHEST_SEQNO_IN_USE is
7506 /* Actually, new_hs is the seqno of the instruction, that was
7507 scheduled first (i.e. it is the first one in SCHEDULED_INSNS). */
7536 /* The main driver for scheduling a region. This function is responsible
7539 pipelining. ORIG_MAX_SEQNO is the maximal seqno before this pass