static cselib_val *cselib_lookup_mem (rtx, int);
static void cselib_invalidate_regno (unsigned int, enum machine_mode);
static void cselib_invalidate_mem (rtx);
-static void cselib_invalidate_rtx (rtx, rtx, void *);
static void cselib_record_set (rtx, cselib_val *, cselib_val *);
static void cselib_record_sets (rtx);
rtx x = (rtx) x_arg;
enum machine_mode mode = GET_MODE (x);
- if (GET_CODE (x) == CONST_INT
- || (mode == VOIDmode && GET_CODE (x) == CONST_DOUBLE))
- abort ();
+ gcc_assert (GET_CODE (x) != CONST_INT
+ && (mode != VOIDmode || GET_CODE (x) != CONST_DOUBLE));
+
if (mode != GET_MODE (v->u.val_rtx))
return 0;
htab_traverse (hash_table, discard_useless_values, 0);
- if (n_useless_values != 0)
- abort ();
+ gcc_assert (!n_useless_values);
}
/* Return the mode in which a register was last set. If X is not a
contain anything but integers and other rtx's,
except for within LABEL_REFs and SYMBOL_REFs. */
default:
- abort ();
+ gcc_unreachable ();
}
}
return 1;
if (GET_CODE (x) != CONST_INT
&& (GET_CODE (x) != CONST_DOUBLE || GET_MODE (x) != VOIDmode))
return x;
- if (mode == VOIDmode)
- abort ();
+ gcc_assert (mode != VOIDmode);
return gen_rtx_CONST (mode, x);
}
fmt = GET_RTX_FORMAT (code);
for (; i >= 0; i--)
{
- if (fmt[i] == 'e')
+ switch (fmt[i])
{
- rtx tem = XEXP (x, i);
- unsigned int tem_hash = cselib_hash_rtx (tem, 0, create);
-
- if (tem_hash == 0)
- return 0;
-
- hash += tem_hash;
- }
- else if (fmt[i] == 'E')
- for (j = 0; j < XVECLEN (x, i); j++)
+ case 'e':
{
- unsigned int tem_hash = cselib_hash_rtx (XVECEXP (x, i, j), 0, create);
-
+ rtx tem = XEXP (x, i);
+ unsigned int tem_hash = cselib_hash_rtx (tem, 0, create);
+
if (tem_hash == 0)
return 0;
-
+
hash += tem_hash;
}
- else if (fmt[i] == 's')
- {
- const unsigned char *p = (const unsigned char *) XSTR (x, i);
+ break;
+ case 'E':
+ for (j = 0; j < XVECLEN (x, i); j++)
+ {
+ unsigned int tem_hash
+ = cselib_hash_rtx (XVECEXP (x, i, j), 0, create);
+
+ if (tem_hash == 0)
+ return 0;
+
+ hash += tem_hash;
+ }
+ break;
+
+ case 's':
+ {
+ const unsigned char *p = (const unsigned char *) XSTR (x, i);
+
+ if (p)
+ while (*p)
+ hash += *p++;
+ break;
+ }
+
+ case 'i':
+ hash += XINT (x, i);
+ break;
- if (p)
- while (*p)
- hash += *p++;
+ case '0':
+ case 't':
+ /* unused */
+ break;
+
+ default:
+ gcc_unreachable ();
}
- else if (fmt[i] == 'i')
- hash += XINT (x, i);
- else if (fmt[i] == '0' || fmt[i] == 't')
- /* unused */;
- else
- abort ();
}
return hash ? hash : 1 + (unsigned int) GET_CODE (x);
{
cselib_val *e = pool_alloc (cselib_val_pool);
-#ifdef ENABLE_CHECKING
- if (value == 0)
- abort ();
-#endif
+ gcc_assert (value);
e->value = value;
/* We use custom method to allocate this RTL construct because it accounts
if (GET_MODE (l->elt->u.val_rtx) == GET_MODE (x))
return l->elt->u.val_rtx;
- abort ();
+ gcc_unreachable ();
case MEM:
e = cselib_lookup_mem (x, 0);
unsigned int i;
/* If we see pseudos after reload, something is _wrong_. */
- if (reload_completed && regno >= FIRST_PSEUDO_REGISTER
- && reg_renumber[regno] >= 0)
- abort ();
+ gcc_assert (!reload_completed || regno < FIRST_PSEUDO_REGISTER
+ || reg_renumber[regno] < 0);
/* Determine the range of registers that must be invalidated. For
pseudos, only REGNO is affected. For hard regs, we must take MODE
if they contain values that overlap REGNO. */
if (regno < FIRST_PSEUDO_REGISTER)
{
- if (mode == VOIDmode)
- abort ();
+ gcc_assert (mode != VOIDmode);
if (regno < max_value_regs)
i = 0;
*vp = &dummy_val;
}
-/* Invalidate DEST, which is being assigned to or clobbered. The second and
- the third parameter exist so that this function can be passed to
- note_stores; they are ignored. */
+/* Invalidate DEST, which is being assigned to or clobbered. */
-static void
-cselib_invalidate_rtx (rtx dest, rtx ignore ATTRIBUTE_UNUSED,
- void *data ATTRIBUTE_UNUSED)
+void
+cselib_invalidate_rtx (rtx dest)
{
while (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == SIGN_EXTRACT
|| GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SUBREG)
invalidate the stack pointer correctly. Note that invalidating
the stack pointer is different from invalidating DEST. */
if (push_operand (dest, GET_MODE (dest)))
- cselib_invalidate_rtx (stack_pointer_rtx, NULL_RTX, NULL);
+ cselib_invalidate_rtx (stack_pointer_rtx);
+}
+
+/* A wrapper for cselib_invalidate_rtx to be called via note_stores. */
+
+static void
+cselib_invalidate_rtx_note_stores (rtx dest, rtx ignore ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
+{
+ cselib_invalidate_rtx (dest);
}
/* Record the result of a SET instruction. DEST is being set; the source
}
else
{
- if (REG_VALUES (dreg)->elt == 0)
- REG_VALUES (dreg)->elt = src_elt;
- else
- /* The register should have been invalidated. */
- abort ();
+ /* The register should have been invalidated. */
+ gcc_assert (REG_VALUES (dreg)->elt == 0);
+ REG_VALUES (dreg)->elt = src_elt;
}
if (src_elt->locs == 0)
/* Invalidate all locations written by this insn. Note that the elts we
looked up in the previous loop aren't affected, just some of their
locations may go away. */
- note_stores (body, cselib_invalidate_rtx, NULL);
+ note_stores (body, cselib_invalidate_rtx_note_stores, NULL);
/* If this is an asm, look for duplicate sets. This can happen when the
user uses the same value as an output multiple times. This is valid
unlikely to help. */
for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
if (REG_NOTE_KIND (x) == REG_INC)
- cselib_invalidate_rtx (XEXP (x, 0), NULL_RTX, NULL);
+ cselib_invalidate_rtx (XEXP (x, 0));
#endif
/* Look for any CLOBBERs in CALL_INSN_FUNCTION_USAGE, but only
if (CALL_P (insn))
for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1))
if (GET_CODE (XEXP (x, 0)) == CLOBBER)
- cselib_invalidate_rtx (XEXP (XEXP (x, 0), 0), NULL_RTX, NULL);
+ cselib_invalidate_rtx (XEXP (XEXP (x, 0), 0));
cselib_current_insn = 0;