/* Check if all uses in DEF_INSN can be used in TARGET_INSN. This would require full computation of available expressions; we check only restricted conditions, see use_killed_between. */ static bool all_uses_available_at (rtx_insn *def_insn, rtx_insn *target_insn) { df_ref use; struct df_insn_info *insn_info = DF_INSN_INFO_GET (def_insn); rtx def_set = single_set (def_insn); rtx_insn *next; gcc_assert (def_set); /* If target_insn comes right after def_insn, which is very common for addresses, we can use a quicker test. Ignore debug insns other than target insns for this. */ next = NEXT_INSN (def_insn); while (next && next != target_insn && DEBUG_INSN_P (next)) next = NEXT_INSN (next); if (next == target_insn && REG_P (SET_DEST (def_set))) { rtx def_reg = SET_DEST (def_set); /* If the insn uses the reg that it defines, the substitution is invalid. */ FOR_EACH_INSN_INFO_USE (use, insn_info) if (rtx_equal_p (DF_REF_REG (use), def_reg)) return false; FOR_EACH_INSN_INFO_EQ_USE (use, insn_info) if (rtx_equal_p (DF_REF_REG (use), def_reg)) return false; }
static void union_match_dups (rtx insn, struct web_entry *def_entry, struct web_entry *use_entry, bool (*fun) (struct web_entry *, struct web_entry *)) { struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn); df_ref use_link = DF_INSN_INFO_USES (insn_info); df_ref def_link = DF_INSN_INFO_DEFS (insn_info); struct web_entry *dup_entry; int i; extract_insn (insn); for (i = 0; i < recog_data.n_dups; i++) { int op = recog_data.dup_num[i]; enum op_type type = recog_data.operand_type[op]; df_ref ref, dupref; struct web_entry *entry; dup_entry = use_entry; for (dupref = use_link; dupref; dupref = DF_REF_NEXT_LOC (dupref)) if (DF_REF_LOC (dupref) == recog_data.dup_loc[i]) break; if (dupref == NULL && type == OP_INOUT) { dup_entry = def_entry; for (dupref = def_link; dupref; dupref = DF_REF_NEXT_LOC (dupref)) if (DF_REF_LOC (dupref) == recog_data.dup_loc[i]) break; } /* ??? *DUPREF can still be zero, because when an operand matches a memory, DF_REF_LOC (use_link[n]) points to the register part of the address, whereas recog_data.dup_loc[m] points to the entire memory ref, thus we fail to find the duplicate entry, even though it is there. Example: i686-pc-linux-gnu gcc.c-torture/compile/950607-1.c -O3 -fomit-frame-pointer -funroll-loops */ if (dupref == NULL || DF_REF_REGNO (dupref) < FIRST_PSEUDO_REGISTER) continue; ref = type == OP_IN ? use_link : def_link; entry = type == OP_IN ? use_entry : def_entry; for (; ref; ref = DF_REF_NEXT_LOC (ref)) { rtx *l = DF_REF_LOC (ref); if (l == recog_data.operand_loc[op]) break; if (l && DF_REF_REAL_LOC (ref) == recog_data.operand_loc[op]) break; } if (!ref && type == OP_INOUT) { entry = use_entry; for (ref = use_link; ref; ref = DF_REF_NEXT_LOC (ref)) { rtx *l = DF_REF_LOC (ref); if (l == recog_data.operand_loc[op]) break; if (l && DF_REF_REAL_LOC (ref) == recog_data.operand_loc[op]) break; } } gcc_assert (ref); (*fun) (dup_entry + DF_REF_ID (dupref), entry + DF_REF_ID (ref)); } }