static void find_flags_uses_in_insn (struct comparison *cmp, rtx_insn *insn) { df_ref use; /* If we've already lost track of uses, don't bother collecting more. */ if (cmp->missing_uses) return; /* Find a USE of the flags register. */ FOR_EACH_INSN_USE (use, insn) if (DF_REF_REGNO (use) == targetm.flags_regnum) { rtx x, *loc; /* If this is an unusual use, quit. */ if (DF_REF_TYPE (use) != DF_REF_REG_USE) goto fail; /* If we've run out of slots to record uses, quit. */ if (cmp->n_uses == MAX_CMP_USE) goto fail; /* Unfortunately the location of the flags register, while present in the reference structure, doesn't help. We need to find the comparison code that is outer to the actual flags use. */ loc = DF_REF_LOC (use); x = PATTERN (insn); if (GET_CODE (x) == PARALLEL) x = XVECEXP (x, 0, 0); x = SET_SRC (x); if (GET_CODE (x) == IF_THEN_ELSE) x = XEXP (x, 0); if (COMPARISON_P (x) && loc == &XEXP (x, 0) && XEXP (x, 1) == const0_rtx) { /* We've found a use of the flags that we understand. */ struct comparison_use *cuse = &cmp->uses[cmp->n_uses++]; cuse->insn = insn; cuse->loc = loc; cuse->code = GET_CODE (x); } else goto fail; } return; fail: /* We failed to recognize this use of the flags register. */ cmp->missing_uses = true; }
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)); } }