contrib/gcc/cse.c

2579 	  /* Can't merge two expressions in different alias sets, since we
4888   struct set *sets = (struct set *) 0;
4909       sets = alloca (sizeof (struct set));
4910       sets[0].rtl = x;
4944       sets = alloca (lim * sizeof (struct set));
4991 		sets[n_sets++].rtl = y;
5040       && (! rtx_equal_p (XEXP (tem, 0), SET_SRC (sets[0].rtl))
5041 	  || GET_CODE (SET_DEST (sets[0].rtl)) == STRICT_LOW_PART))
5059       rtx dest = SET_DEST (sets[i].rtl);
5060       rtx src = SET_SRC (sets[i].rtl);
5063       sets[i].orig_src = src;
5064       validate_change (insn, &SET_SRC (sets[i].rtl), new, 1);
5093   /* Set sets[i].src_elt to the class each source belongs to.
5124       dest = SET_DEST (sets[i].rtl);
5125       src = SET_SRC (sets[i].rtl);
5132       sets[i].mode = mode;
5173       if (GET_CODE (SET_DEST (sets[i].rtl)) == ZERO_EXTRACT)
5175 	  rtx width = XEXP (SET_DEST (sets[i].rtl), 1);
5193       sets[i].src = src;
5194       sets[i].src_hash = HASH (src, mode);
5195       sets[i].src_volatile = do_not_record;
5196       sets[i].src_in_memory = hash_arg_in_memory;
5209 	sets[i].src_volatile = 1;
5222 	sets[i].src_volatile = 1;
5241       if (!sets[i].src_volatile)
5242 	elt = lookup (src, sets[i].src_hash, mode);
5244       sets[i].src_elt = elt;
5266 	 table, also set `sets[i].src_const_hash').  */
5292 	  sets[i].src_const_hash = HASH (src_const, mode);
5293 	  src_const_elt = lookup (src_const, sets[i].src_const_hash, mode);
5296       sets[i].src_const = src_const;
5297       sets[i].src_const_elt = src_const_elt;
5672 	      SET_SRC (sets[i].rtl) = trial;
5694 	  else if (validate_change (insn, &SET_SRC (sets[i].rtl), trial, 0))
5696 	      rtx new = canon_reg (SET_SRC (sets[i].rtl), insn);
5702 		  && (REG_P (sets[i].orig_src)
5703 		      || GET_CODE (sets[i].orig_src) == SUBREG
5704 		      || MEM_P (sets[i].orig_src)))
5709 							   sets[i].orig_src,
5716 	      validate_change (insn, &SET_SRC (sets[i].rtl), new, 1);
5741       src = SET_SRC (sets[i].rtl);
5760 	      && (!REG_P (sets[i].src)
5761 		  || REGNO (sets[i].src) >= FIRST_PSEUDO_REGISTER)
5776 	      if (validate_change (insn, &SET_SRC (sets[i].rtl), new_src, 0))
5783 		      && validate_change (insn, &SET_SRC (sets[i].rtl),
5791       if (src != sets[i].src)
5796 	  sets[i].src = src;
5797 	  sets[i].src_hash = HASH (src, mode);
5798 	  sets[i].src_volatile = do_not_record;
5799 	  sets[i].src_in_memory = hash_arg_in_memory;
5800 	  sets[i].src_elt = lookup (src, sets[i].src_hash, mode);
5841       sets[i].inner_dest = dest;
5859       sets[i].dest_hash = HASH (dest, mode);
5865       if (GET_CODE (SET_DEST (sets[i].rtl)) == ZERO_EXTRACT)
5867 	  rtx width = XEXP (SET_DEST (sets[i].rtl), 1);
5883 	      sets[i].src_elt = 0;
5884 	      sets[i].src_volatile = 1;
5898 	  sets[i].rtl = 0;
5915 	     If this insn has multiple sets, then reemitting the
5949 	  sets[i].rtl = 0;
5964 	  sets[i].rtl = 0;
5967       if (sets[i].rtl != 0 && dest != SET_DEST (sets[i].rtl))
5968 	sets[i].dest_hash = HASH (SET_DEST (sets[i].rtl), mode);
5995   if (src_eqv && src_eqv_elt == 0 && sets[0].rtl != 0 && ! src_eqv_volatile
5996       && ! rtx_equal_p (src_eqv, SET_DEST (sets[0].rtl)))
5999       struct table_elt *classp = sets[0].src_elt;
6000       rtx dest = SET_DEST (sets[0].rtl);
6021 	if (sets[i].rtl && sets[i].src_elt == 0
6022 	    && rtx_equal_p (SET_SRC (sets[i].rtl), src_eqv))
6023 	  sets[i].src_elt = src_eqv_elt;
6027     if (sets[i].rtl && ! sets[i].src_volatile
6028 	&& ! rtx_equal_p (SET_SRC (sets[i].rtl), SET_DEST (sets[i].rtl)))
6030 	if (GET_CODE (SET_DEST (sets[i].rtl)) == STRICT_LOW_PART)
6037 	    sets[i].src_elt = src_eqv_elt;
6038 	    sets[i].src_hash = src_eqv_hash;
6045 	    rtx src = sets[i].src;
6046 	    rtx dest = SET_DEST (sets[i].rtl);
6058 	      classp = sets[i].src_const_elt;
6060 	    if (sets[i].src_elt == 0)
6075 			sets[i].src_hash = HASH (src, mode);
6077 		    elt = insert (src, classp, sets[i].src_hash, mode);
6078 		    elt->in_memory = sets[i].src_in_memory;
6079 		    sets[i].src_elt = classp = elt;
6082 		  sets[i].src_elt = classp;
6084 	    if (sets[i].src_const && sets[i].src_const_elt == 0
6085 		&& src != sets[i].src_const
6086 		&& ! rtx_equal_p (sets[i].src_const, src))
6087 	      sets[i].src_elt = insert (sets[i].src_const, classp,
6088 					sets[i].src_const_hash, mode);
6091     else if (sets[i].src_elt == 0)
6095       sets[i].src_elt = src_eqv_elt;
6098      check if they are invalidated by other sets.  */
6101       if (sets[i].rtl)
6103 	  rtx x = sets[i].inner_dest;
6118 		      rtx dest = SET_DEST (sets[i].rtl);
6122 		      sets[i].dest_hash = HASH (dest, GET_MODE (dest));
6127 	      sets[i].dest_addr_elt = elt;
6130 	    sets[i].dest_addr_elt = NULL;
6148      sets[i].rtl is still nonzero, so here we invalidate the reg
6152     if (sets[i].rtl)
6156 	rtx dest = SET_DEST (sets[i].rtl);
6187       if (sets[i].rtl)
6189 	  rtx x = SET_DEST (sets[i].rtl);
6230     if (sets[i].rtl)
6232 	if (sets[i].dest_addr_elt
6233 	    && sets[i].dest_addr_elt->first_same_value == 0)
6237 	    sets[i].rtl = NULL_RTX;
6239 	else if (sets[i].src_elt && sets[i].src_elt->first_same_value == 0)
6243 	    struct table_elt *elt = sets[i].src_elt;
6250 	    sets[i].src_elt = elt ? elt->first_same_value : 0;
6257     if (sets[i].rtl)
6259 	rtx dest = SET_DEST (sets[i].rtl);
6279 	    || sets[i].src_elt == 0
6288 		&& (GET_CODE (sets[i].src) == SIGN_EXTEND
6289 		    || GET_CODE (sets[i].src) == ZERO_EXTEND)))
6300 	  if (insert_regs (dest, sets[i].src_elt, 1))
6305 	      sets[i].dest_hash = HASH (dest, GET_MODE (dest));
6308 	elt = insert (dest, sets[i].src_elt,
6309 		      sets[i].dest_hash, GET_MODE (dest));
6311 	elt->in_memory = (MEM_P (sets[i].inner_dest)
6312 			  && !MEM_READONLY_P (sets[i].inner_dest));
6335 	    && sets[i].src_elt != 0)
6340 	    for (elt = sets[i].src_elt->first_same_value; elt;
6426   if (n_sets == 1 && sets[0].rtl && REG_P (SET_DEST (sets[0].rtl))
6428       && REG_P (SET_SRC (sets[0].rtl))
6429       && REGNO (SET_SRC (sets[0].rtl)) >= FIRST_PSEUDO_REGISTER
6430       && REGNO_QTY_VALID_P (REGNO (SET_SRC (sets[0].rtl))))
6432       int src_q = REG_QTY (REGNO (SET_SRC (sets[0].rtl)));
6435       if ((src_ent->first_reg == REGNO (SET_DEST (sets[0].rtl)))
6462 	      && SET_DEST (PATTERN (prev)) == SET_SRC (sets[0].rtl)
6465 	      rtx dest = SET_DEST (sets[0].rtl);
6466 	      rtx src = SET_SRC (sets[0].rtl);
6470 	      validate_change (insn, &SET_DEST (sets[0].rtl), src, 1);
6471 	      validate_change (insn, &SET_SRC (sets[0].rtl), dest, 1);
7016       /* If this basic block was already processed or has no sets, skip it.  */
7030 	fprintf (dump_file, ";; Processing block from %d to %d, %d sets.\n",
7754 	  /* Check whether INSN sets CC_REG to CC_SRC.  */
7813 		      /* INSN sets CC_REG to a value equal to CC_SRC
7824 	      /* We found an instruction which sets the condition
7829 	  /* If INSN sets CC_REG in some other way, don't look any
7917 	 sets the condition code register.  Then look through the