156 #include "hard-reg-set.h"
194    2) Compute table of places where registers are set.
211    (set (pseudo-reg) (expression)).
397    is set.
409    need to iterate over the number of times a pseudo-reg is set, not over the
411    where a pseudo is set more than once in a block, however it is believed
421   /* The index of the block where it was set.  */
460 /* Array of implicit set patterns indexed by basic block index.  */
470    Used when performing GCSE to track which registers have been set since
474 /* For each block, a bitmap of registers set in the block.
693   /* Record where pseudo-registers are set.  This data is kept accurate
698      It may be tempting to compute MEM set information here too, but MEM sets
822   /* Record where pseudo-registers are set.  */
829 /* Nonzero for each mode that supports (set (reg) (reg)).
919    and reg/memory set tracking tables.
1011    TABLE controls which hash table to look at.  If it is  set hash table,
1051 	     we want to set to nonzero in ANTLOC.  */
1063 	     we want to set to nonzero in COMP.  */
1082 /* Register set information.
1084    `reg_set_table' records where each register is set or otherwise
1145 /* Scan the function and record each set of each pseudo-register.
1176 /* See whether X, the source of a set, is something we want to consider for
1337    possibly conflicts with the load found in gcse_mem_operand, then set
1375    To check the entire block, set UID_LIMIT to max_uid + 1 and
1461 /* Hash a set of register REGNO.
1463    Sets are hashed on the register that is set.  This simplifies the PRE copy
1689 /* Scan pattern PAT of INSN and add an entry to the hash TABLE (set or
1745 	     a set after the branch.  */
1802 	          a set after the branch.  */
1829    Only available expressions that set a single pseudo-reg are recorded.
1911 /* Record register first/last/block set information for REGNO in INSN.
1914    is set and is used to compute "anticipatability".
1917    is set and is used to compute "availability".
1922    reg_set_in_block records whether the register is set in the block
1976    about the memory location(s) that are set, or even how they are set (consider
2025    - they are of the form (set (pseudo-reg) src),
2030    - they are of the form (set (pseudo-reg) src),
2044      registers are set in which blocks.
2051   /* Some working arrays used to track first and last set in each block.  */
2064 	 determine when registers and memory are first and last set.
2110 /* Allocate space for the set/expr hash TABLE.
2113    SET_P determines whether set or expression table will
2158 /* Lookup REGNO in the set TABLE.  The result is a pointer to the
2241   /* Maintain a bitmap of which regs have been set since beginning of
2251 /* Return nonzero if the operands of X are not set before INSN in
2315 /* Mark things set by a CALL.  */
2324 /* Mark things set by a SET.  */
2345 /* Record things set by a CLOBBER.  */
2361 /* Record things set by INSN.
2430    element of X is modified, set (SET_P == 1) or reset (SET_P == 0) the INDX
2660   rtx set = single_set (insn);
2667   if (success && set && CONSTANT_P (to))
2669       src = simplify_rtx (SET_SRC (set));
2672 	validate_change (insn, &SET_SRC (set), src, 0);
2680   if (!success && set && reg_mentioned_p (from, SET_SRC (set)))
2682       /* If above failed and this is a single set, try to simplify the source of
2683 	 the set given our substitution.  We could perhaps try this for multiple
2685       src = simplify_replace_rtx (SET_SRC (set), from, to);
2687       if (!rtx_equal_p (src, SET_SRC (set))
2688 	  && validate_change (insn, &SET_SRC (set), src, 0))
2694       if (!success && note == 0 && set != 0
2695 	  && GET_CODE (SET_DEST (set)) != ZERO_EXTRACT
2696 	  && GET_CODE (SET_DEST (set)) != STRICT_LOW_PART)
2710 /* Find a set of REGNOs that are available on entry to INSN's block.  Returns
2711    NULL no such set is found.  */
2716   /* SET1 contains the last set found that can be returned to the caller for
2724        (set (reg X) (reg Y))
2725        (set (reg Y) (reg X))
2727      This can not happen since the set of (reg Y) would have killed the
2728      set of (reg X) making it unavailable at the start of this block.  */
2732       struct expr *set = lookup_set (regno, &set_hash_table);
2734       /* Find a set that is available at the start of the block
2736       while (set)
2738 	  if (TEST_BIT (cprop_avin[BLOCK_NUM (insn)], set->bitmap_index))
2740 	  set = next_set (regno, set);
2743       /* If no available set was found we've reached the end of the
2745       if (set == 0)
2748       gcc_assert (GET_CODE (set->expr) == SET);
2750       src = SET_SRC (set->expr);
2752       /* We know the set is available.
2760 	set1 = set;
2762       /* If the source of the set is anything except a register, then
2772   /* SET1 holds the last set that was available and anticipatable at
2788   rtx set = pc_set (jump);
2800   set_src = note_src ? note_src : SET_SRC (set);
2822   if (rtx_equal_p (new, SET_SRC (set)))
2834       if (! validate_change (jump, &SET_SRC (set), new, 0))
2857       if (GET_CODE (SET_SRC (set)) == LABEL_REF)
2911      (set (pc) (if_then_else ...))  */
2944       struct expr *set;
2951       /* If the register has already been set in this block, there's
2958       set = find_avail_set (regno, insn);
2959       if (! set)
2962       pat = set->expr;
3315 /* Check the comparison COND to see if we can safely form an implicit set from
3347 /* Find the implicit sets of a function.  An "implicit set" is a constraint
3350    conditional performed an "explicit set", in this example, "x = 2".  This
3351    function records the set patterns that are implicit at the start of each
3385 		    fprintf(dump_file, "Implicit set of reg %d in ",
3464 /* Find a set of REGNO to a constant that is available at the end of basic
3465    block BB.  Returns NULL if no such set is found.  Based heavily upon
3476       struct expr *set = lookup_set (regno, &set_hash_table);
3478       while (set)
3480 	  if (TEST_BIT (cprop_avout[bb], set->bitmap_index))
3482 	  set = next_set (regno, set);
3485       if (set == 0)
3488       gcc_assert (GET_CODE (set->expr) == SET);
3490       src = SET_SRC (set->expr);
3492 	result = set;
3543   /* Determine set of register uses in INSN.  */
3591 	  struct expr *set;
3597 	  set = find_bypass_set (regno, e->src->index);
3599 	  if (! set)
3614 				      SET_SRC (set->expr));
3666 		  print_rtl (dump_file, SET_SRC (set->expr));
4046 	 if cc0 isn't set.  */
4059       /* FIXME: What if something in cc0/jump uses value set in new insn?  */
4083 	 in different orders, assume nothing.  Collect the set of all
4232   rtx set, first_set, new_insn;
4240       set = pat;
4244       /* Search through the parallel looking for the set whose
4247       set = NULL_RTX;
4255 		 case the PARALLEL will have a single set.  */
4260 	          set = x;
4267       if (set == NULL_RTX)
4268         set = first_set;
4275   if (REG_P (SET_DEST (set)))
4277       old_reg = SET_DEST (set);
4278       /* Check if we can modify the set destination in the original insn.  */
4279       if (validate_change (insn, &SET_DEST (set), reg, 0))
4284           /* Keep register set table up to date.  */
4292           /* Keep register set table up to date.  */
4298       old_reg = SET_SRC (set);
4301       /* Check if we can modify the set source in the original insn.  */
4302       if (validate_change (insn, &SET_SRC (set), reg, 0))
4307       /* Keep register set table up to date.  */
4393   rtx set = single_set (insn), set2;
4409     eqv = SET_SRC (set);
4445 	    rtx set;
4450 		&& (set = single_set (insn)) != 0)
4457 		    = gen_reg_rtx (GET_MODE (SET_DEST (set)));
4459 		gcse_emit_move_after (expr->reaching_reg, SET_DEST (set), insn);
4960 		      rtx set;
4968 		      set = single_set (insn);
4969 		      gcc_assert (set);
4976 			  = gen_reg_rtx (GET_MODE (SET_DEST (set)));
4978 		      gcse_emit_move_after (expr->reaching_reg, SET_DEST (set), insn);
5422 	 matter to set the reaching reg everywhere...  some might be
5425       /* We replace (set mem expr) with (set reg expr) (set mem reg)
5427 	 compute_ld_motion_mems that we can replace (set mem expr) with
5428 	 (set reg expr) in that insn.  */
5484 /* Checks to set if we need to mark a register set.  Called from
5522    due to set of registers in bitmap REGS_SET.  */
5626    REGS_SET_BEFORE is bitmap of registers set before (and including) the
5627    current insn, REGS_SET_AFTER is bitmap of registers set after (and
5651   rtx dest, set, tmp;
5655   set = single_set (insn);
5656   if (!set)
5659   dest = SET_DEST (set);
5684   if (!can_assign_to_reg_p (SET_SRC (set)))
5773       /* First compute the registers set in this block.  */
5817 	  /* Unmark regs that are no longer set.  */
6006    within basic block BB.  REGS_SET_AFTER is bitmap of registers set in
6038    REGS_SET_BEFORE is bitmap of registers set before or in this insn.  */
6188      store, then we haven't set the reaching reg yet either.  */
6243    memory location in SMEXPR set in basic block BB.
6331   rtx insn, mem, note, set, ptr, pair;
6381 	set = single_set (insn);
6382 	if (!set)
6384 	if (expr_equiv_p (SET_DEST (set), mem))
6562   /* Record where pseudo-registers are set.  This data is kept accurate
6567      It may be tempting to compute MEM set information here too, but MEM sets

Indexes created Thu May 23 20:32:32 MDT 2024