* c-common.c: Rename all identifiers named `class' to `cl'.
* c-decl.c: Likewise.
* c-common.h: Likewise.
* c-parse.in: Likewise.
* c-typeck.c: Likewise.
* genmodes.c: Likewise.
* real.c: Likewise.
* real.h: Likewise.
* recog.c: Likewise.
* recog.h: Likewise.
* regrename.c: Likewise.
* tree.h: Likewise.
From-SVN: r85153
+2004-07-25 Bernardo Innocenti <bernie@develer.com>
+
+ * c-common.c: Rename all identifiers named `class' to `cl'.
+ * c-common.h: Likewise.
+ * c-parse.in: Likewise.
+ * c-typeck.c: Likewise.
+ * genmodes.c: Likewise.
+ * real.c: Likewise.
+ * real.h: Likewise.
+ * recog.c: Likewise.
+ * recog.h: Likewise.
+ * regrename.c: Likewise.
+ * tree.h: Likewise.
+
2004-07-25 Daniel Jacobowitz <dan@debian.org>
* regmove.c (optimize_reg_copy_1): Don't try to replace call-used
{
struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
enum tree_code code;
- char class;
+ char cl;
/* X may be NULL if it is the operand of an empty statement expression
({ }). */
restart:
code = TREE_CODE (x);
- class = TREE_CODE_CLASS (code);
+ cl = TREE_CODE_CLASS (code);
if (warning_candidate_p (x))
{
break;
}
- if (class == '1')
+ if (cl == '1')
{
if (first_rtl_op (code) == 0)
return;
goto restart;
}
- switch (class)
+ switch (cl)
{
case 'r':
case '<':
return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
}
\f
-static tree builtin_function_2 (const char *, const char *, tree, tree,
- int, enum built_in_class, int, int,
- tree);
+static tree builtin_function_2 (const char *builtin_name, const char *name,
+ tree builtin_type, tree type,
+ enum built_in_function function_code,
+ enum built_in_class cl, int library_name_p,
+ bool nonansi_p,
+ tree attrs);
/* Make a variant type in the proper way for C/C++, propagating qualifiers
down to the element type of an array. */
BUILTIN_TYPE is the type of the __builtin_-prefixed function;
TYPE is the type of the function with the ordinary name. These
may differ if the ordinary name is declared with a looser type to avoid
- conflicts with headers. FUNCTION_CODE and CLASS are as for
+ conflicts with headers. FUNCTION_CODE and CL are as for
builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
- If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
+ If NONANSI_P is true, the name NAME is treated as a non-ANSI name;
ATTRS is the tree list representing the builtin's function attributes.
Returns the declaration of BUILTIN_NAME, if any, otherwise
the declaration of NAME. Does not declare NAME if flag_no_builtin,
static tree
builtin_function_2 (const char *builtin_name, const char *name,
- tree builtin_type, tree type, int function_code,
- enum built_in_class class, int library_name_p,
- int nonansi_p, tree attrs)
+ tree builtin_type, tree type,
+ enum built_in_function function_code,
+ enum built_in_class cl, int library_name_p,
+ bool nonansi_p, tree attrs)
{
tree bdecl = NULL_TREE;
tree decl = NULL_TREE;
if (builtin_name != 0)
bdecl = lang_hooks.builtin_function (builtin_name, builtin_type,
- function_code, class,
+ function_code, cl,
library_name_p ? name : NULL, attrs);
if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
&& !(nonansi_p && flag_no_nonansi_builtin))
- decl = lang_hooks.builtin_function (name, type, function_code, class,
+ decl = lang_hooks.builtin_function (name, type, function_code, cl,
NULL, attrs);
return (bdecl != 0 ? bdecl : decl);
tree
builtin_function (const char *name, tree type, int function_code,
- enum built_in_class class, const char *library_name,
+ enum built_in_class cl, const char *library_name,
tree attrs)
{
tree id = get_identifier (name);
tree decl = build_decl (FUNCTION_DECL, id, type);
TREE_PUBLIC (decl) = 1;
DECL_EXTERNAL (decl) = 1;
- DECL_LANG_SPECIFIC (decl) = ggc_alloc_cleared (sizeof (struct lang_decl));
- DECL_BUILT_IN_CLASS (decl) = class;
+ DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
+ DECL_BUILT_IN_CLASS (decl) = cl;
DECL_FUNCTION_CODE (decl) = function_code;
if (library_name)
SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
differ from the default conversions. */
if (warn_conversion || warn_traditional)
{
- int formal_prec = TYPE_PRECISION (type);
+ unsigned int formal_prec = TYPE_PRECISION (type);
if (INTEGRAL_TYPE_P (type)
&& TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
struct mode_data *next; /* next this class - arbitrary order */
const char *name; /* printable mode name -- SI, not SImode */
- enum mode_class class; /* this mode class */
+ enum mode_class cl; /* this mode class */
unsigned int precision; /* size in bits, equiv to TYPE_PRECISION */
unsigned int bytesize; /* storage size in addressable units */
unsigned int ncomponents; /* number of subunits */
static const struct mode_data blank_mode = {
0, "<unknown>", MAX_MODE_CLASS,
- -1, -1, -1, -1,
+ -1U, -1U, -1U, -1U,
0, 0, 0, 0, 0,
"<unknown>", 0
};
/* Mode class operations. */
static enum mode_class
-complex_class (enum mode_class class)
+complex_class (enum mode_class c)
{
- switch (class)
+ switch (c)
{
case MODE_INT: return MODE_COMPLEX_INT;
case MODE_FLOAT: return MODE_COMPLEX_FLOAT;
default:
- error ("no complex class for class %s", mode_class_names[class]);
+ error ("no complex class for class %s", mode_class_names[c]);
return MODE_RANDOM;
}
}
static enum mode_class
-vector_class (enum mode_class class)
+vector_class (enum mode_class cl)
{
- switch (class)
+ switch (cl)
{
case MODE_INT: return MODE_VECTOR_INT;
case MODE_FLOAT: return MODE_VECTOR_FLOAT;
default:
- error ("no vector class for class %s", mode_class_names[class]);
+ error ("no vector class for class %s", mode_class_names[cl]);
return MODE_RANDOM;
}
}
struct mode_data key;
key.name = name;
- return htab_find (modes_by_name, &key);
+ return (struct mode_data *) htab_find (modes_by_name, &key);
}
static struct mode_data *
-new_mode (enum mode_class class, const char *name,
+new_mode (enum mode_class cl, const char *name,
const char *file, unsigned int line)
{
struct mode_data *m;
return m;
}
- m = xmalloc (sizeof (struct mode_data));
+ m = XNEW (struct mode_data);
memcpy (m, &blank_mode, sizeof (struct mode_data));
- m->class = class;
+ m->cl = cl;
m->name = name;
if (file)
m->file = trim_filename (file);
m->line = line;
- m->next = modes[class];
- modes[class] = m;
- n_modes[class]++;
+ m->next = modes[cl];
+ modes[cl] = m;
+ n_modes[cl]++;
*htab_find_slot (modes_by_name, m, INSERT) = m;
return;
}
- if (required_class != MODE_RANDOM && mode->class != required_class)
+ if (required_class != MODE_RANDOM && mode->cl != required_class)
{
error ("%s:%d: mode \"%s\" is not class %s",
file, line, name, mode_class_names[required_class] + 5);
error ("%s:%d: mode with no name", m->file, m->line);
return;
}
- if (m->class == MAX_MODE_CLASS)
+ if (m->cl == MAX_MODE_CLASS)
{
error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
return;
}
- switch (m->class)
+ switch (m->cl)
{
case MODE_RANDOM:
/* Nothing more need be said. */
and must not have components. A float mode must have a
format. */
validate_mode (m, OPTIONAL, SET, UNSET, UNSET,
- m->class == MODE_FLOAT ? SET : UNSET);
+ m->cl == MODE_FLOAT ? SET : UNSET);
m->ncomponents = 1;
m->component = 0;
/* If not already specified, the mode alignment defaults to the largest
power of two that divides the size of the object. Complex types are
not more aligned than their contents. */
- if (m->class == MODE_COMPLEX_INT || m->class == MODE_COMPLEX_FLOAT)
+ if (m->cl == MODE_COMPLEX_INT || m->cl == MODE_COMPLEX_FLOAT)
alignment = m->component->bytesize;
else
alignment = m->bytesize;
complete_all_modes (void)
{
struct mode_data *m;
- enum mode_class c;
-
- for_all_modes (c, m)
+ int cl;
+
+ for_all_modes (cl, m)
complete_mode (m);
}
/* For each mode in class CLASS, construct a corresponding complex mode. */
#define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
static void
-make_complex_modes (enum mode_class class,
+make_complex_modes (enum mode_class cl,
const char *file, unsigned int line)
{
struct mode_data *m;
struct mode_data *c;
char buf[8];
- enum mode_class cclass = complex_class (class);
+ enum mode_class cclass = complex_class (cl);
if (cclass == MODE_RANDOM)
return;
-
- for (m = modes[class]; m; m = m->next)
+
+ for (m = modes[cl]; m; m = m->next)
{
/* Skip BImode. FIXME: BImode probably shouldn't be MODE_INT. */
if (m->precision == 1)
/* Float complex modes are named SCmode, etc.
Int complex modes are named CSImode, etc.
This inconsistency should be eliminated. */
- if (class == MODE_FLOAT)
+ if (cl == MODE_FLOAT)
{
char *p;
strncpy (buf, m->name, sizeof buf);
}
}
-/* For all modes in class CLASS, construct vector modes of width
+/* For all modes in class CL, construct vector modes of width
WIDTH, having as many components as necessary. */
#define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
static void ATTRIBUTE_UNUSED
-make_vector_modes (enum mode_class class, unsigned int width,
+make_vector_modes (enum mode_class cl, unsigned int width,
const char *file, unsigned int line)
{
struct mode_data *m;
struct mode_data *v;
char buf[8];
unsigned int ncomponents;
- enum mode_class vclass = vector_class (class);
+ enum mode_class vclass = vector_class (cl);
if (vclass == MODE_RANDOM)
return;
- for (m = modes[class]; m; m = m->next)
+ for (m = modes[cl]; m; m = m->next)
{
/* Do not construct vector modes with only one element, or
vector modes where the element size doesn't divide the full
/* Skip QFmode and BImode. FIXME: this special case should
not be necessary. */
- if (class == MODE_FLOAT && m->bytesize == 1)
+ if (cl == MODE_FLOAT && m->bytesize == 1)
continue;
- if (class == MODE_INT && m->precision == 1)
+ if (cl == MODE_INT && m->precision == 1)
continue;
if ((size_t)snprintf (buf, sizeof buf, "V%u%s", ncomponents, m->name)
#define CC_MODE(N) _SPECIAL_MODE (CC, N)
static void
-make_special_mode (enum mode_class class, const char *name,
+make_special_mode (enum mode_class cl, const char *name,
const char *file, unsigned int line)
{
- new_mode (class, name, file, line);
+ new_mode (cl, name, file, line);
}
-#define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1, Y)
+#define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
#define FRACTIONAL_INT_MODE(N, B, Y) \
make_int_mode (#N, B, Y, __FILE__, __LINE__)
m->precision = precision;
}
-#define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1, Y, F)
+#define FLOAT_MODE(N, Y, F) FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
#define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
error ("%s:%d: no mode \"%s\"", file, line, name);
return;
}
- if (m->class != MODE_FLOAT)
+ if (m->cl != MODE_FLOAT)
{
error ("%s:%d: mode \"%s\" is not class FLOAT", file, line, name);
return;
/* Partial integer modes are specified by relation to a full integer mode.
For now, we do not attempt to narrow down their bit sizes. */
#define PARTIAL_INT_MODE(M) \
- make_partial_integer_mode (#M, "P" #M, -1, __FILE__, __LINE__)
+ make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__)
static void ATTRIBUTE_UNUSED
make_partial_integer_mode (const char *base, const char *name,
unsigned int precision,
error ("%s:%d: no mode \"%s\"", file, line, name);
return;
}
- if (component->class != MODE_INT)
+ if (component->cl != MODE_INT)
{
error ("%s:%d: mode \"%s\" is not class INT", file, line, name);
return;
}
-
+
m = new_mode (MODE_PARTIAL_INT, name, file, line);
m->precision = precision;
m->component = component;
error ("%s:%d: no mode \"%s\"", file, line, base);
return;
}
- if (component->class != bclass)
+ if (component->cl != bclass)
{
error ("%s:%d: mode \"%s\" is not class %s",
file, line, base, mode_class_names[bclass] + 5);
static void
calc_wider_mode (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
struct mode_data **sortbuf;
unsigned int max_n_modes = 0;
static void
emit_insn_modes_h (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m, *first, *last;
printf ("/* Generated automatically from machmode.def%s%s\n",
static void
emit_mode_name (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
static void
emit_mode_class (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
for_all_modes (c, m)
- tagged_printf ("%s", mode_class_names[m->class], m->name);
+ tagged_printf ("%s", mode_class_names[m->cl], m->name);
print_closer ();
}
static void
emit_mode_precision (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
static void
emit_mode_size (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
print_maybe_const_decl ("%sunsigned char", "mode_size",
static void
emit_mode_nunits (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
static void
emit_mode_wider (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
static void
emit_mode_mask (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
static void
emit_mode_inner (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
static void
emit_mode_base_align (void)
{
- enum mode_class c;
+ int c;
struct mode_data *m;
print_maybe_const_decl ("%sunsigned char",
static void
emit_class_narrowest_mode (void)
{
- enum mode_class c;
+ int c;
print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
for (m = a->mode->contained; m; m = m->next_cont)
{
- switch (m->class)
+ switch (m->cl)
{
case MODE_COMPLEX_INT:
case MODE_COMPLEX_FLOAT:
for (m = a->mode->contained; m; m = m->next_cont)
{
- switch (m->class)
+ switch (m->cl)
{
case MODE_COMPLEX_INT:
case MODE_COMPLEX_FLOAT:
get_canonical_qnan (REAL_VALUE_TYPE *r, int sign)
{
memset (r, 0, sizeof (*r));
- r->class = rvc_nan;
+ r->cl = rvc_nan;
r->sign = sign;
r->canonical = 1;
}
get_canonical_snan (REAL_VALUE_TYPE *r, int sign)
{
memset (r, 0, sizeof (*r));
- r->class = rvc_nan;
+ r->cl = rvc_nan;
r->sign = sign;
r->signalling = 1;
r->canonical = 1;
get_inf (REAL_VALUE_TYPE *r, int sign)
{
memset (r, 0, sizeof (*r));
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
/* Zero significand flushes to zero. */
if (i < 0)
{
- r->class = rvc_zero;
+ r->cl = rvc_zero;
SET_REAL_EXP (r, 0);
return;
}
sign = a->sign;
subtract_p = (sign ^ b->sign) ^ subtract_p;
- switch (CLASS2 (a->class, b->class))
+ switch (CLASS2 (a->cl, b->cl))
{
case CLASS2 (rvc_zero, rvc_zero):
/* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0. */
}
}
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp);
/* Special case: if the subtraction results in zero, the result
is positive. */
- if (r->class == rvc_zero)
+ if (r->cl == rvc_zero)
r->sign = 0;
else
r->sig[0] |= inexact;
int sign = a->sign ^ b->sign;
bool inexact = false;
- switch (CLASS2 (a->class, b->class))
+ switch (CLASS2 (a->cl, b->cl))
{
case CLASS2 (rvc_zero, rvc_zero):
case CLASS2 (rvc_zero, rvc_normal):
}
memset (&u, 0, sizeof (u));
- u.class = rvc_normal;
+ u.cl = rvc_normal;
SET_REAL_EXP (&u, exp);
for (k = j; k < SIGSZ * 2; k += 2)
REAL_VALUE_TYPE t, *rr;
bool inexact;
- switch (CLASS2 (a->class, b->class))
+ switch (CLASS2 (a->cl, b->cl))
{
case CLASS2 (rvc_zero, rvc_zero):
/* 0 / 0 = NaN. */
/* Make sure all fields in the result are initialized. */
get_zero (rr, 0);
- rr->class = rvc_normal;
+ rr->cl = rvc_normal;
rr->sign = sign;
exp = REAL_EXP (a) - REAL_EXP (b) + 1;
{
int ret;
- switch (CLASS2 (a->class, b->class))
+ switch (CLASS2 (a->cl, b->cl))
{
case CLASS2 (rvc_zero, rvc_zero):
/* Sign of zero doesn't matter for compares. */
{
*r = *a;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
case rvc_inf:
break;
case MIN_EXPR:
- if (op1->class == rvc_nan)
+ if (op1->cl == rvc_nan)
*r = *op1;
else if (do_compare (op0, op1, -1) < 0)
*r = *op0;
break;
case MAX_EXPR:
- if (op1->class == rvc_nan)
+ if (op1->cl == rvc_nan)
*r = *op1;
else if (do_compare (op0, op1, 1) < 0)
*r = *op1;
case NE_EXPR:
return do_compare (op0, op1, -1) != 0;
case UNORDERED_EXPR:
- return op0->class == rvc_nan || op1->class == rvc_nan;
+ return op0->cl == rvc_nan || op1->cl == rvc_nan;
case ORDERED_EXPR:
- return op0->class != rvc_nan && op1->class != rvc_nan;
+ return op0->cl != rvc_nan && op1->cl != rvc_nan;
case UNLT_EXPR:
return do_compare (op0, op1, -1) < 0;
case UNLE_EXPR:
int
real_exponent (const REAL_VALUE_TYPE *r)
{
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
return 0;
real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
{
*r = *op0;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
case rvc_inf:
bool
real_isinf (const REAL_VALUE_TYPE *r)
{
- return (r->class == rvc_inf);
+ return (r->cl == rvc_inf);
}
/* Determine whether a floating-point value X is a NaN. */
bool
real_isnan (const REAL_VALUE_TYPE *r)
{
- return (r->class == rvc_nan);
+ return (r->cl == rvc_nan);
}
/* Determine whether a floating-point value X is negative. */
bool
real_isnegzero (const REAL_VALUE_TYPE *r)
{
- return r->sign && r->class == rvc_zero;
+ return r->sign && r->cl == rvc_zero;
}
/* Compare two floating-point objects for bitwise identity. */
{
int i;
- if (a->class != b->class)
+ if (a->cl != b->cl)
return false;
if (a->sign != b->sign)
return false;
- switch (a->class)
+ switch (a->cl)
{
case rvc_zero:
case rvc_inf:
REAL_VALUE_TYPE u;
int i;
- if (r->class != rvc_normal)
+ if (r->cl != rvc_normal)
return false;
/* Check for a power of two: all significand bits zero except the MSB. */
real_convert (&u, mode, &u);
/* The rounding may have overflowed. */
- if (u.class != rvc_normal)
+ if (u.cl != rvc_normal)
return false;
for (i = 0; i < SIGSZ-1; ++i)
if (u.sig[i] != 0)
{
unsigned HOST_WIDE_INT i;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
underflow:
HOST_WIDE_INT low, high;
int exp;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
underflow:
bool sign;
r = *r_orig;
- switch (r.class)
+ switch (r.cl)
{
case rvc_zero:
strcpy (str, (r.sign ? "-0.0" : "0.0"));
char exp_buf[16];
size_t max_digits;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
exp = 0;
exp += d;
}
- r->class = rvc_normal;
+ r->cl = rvc_normal;
SET_REAL_EXP (r, exp);
normalize (r);
if (*str == '.')
{
str++;
- if (r->class == rvc_zero)
+ if (r->cl == rvc_zero)
{
while (*str == '0')
str++, exp--;
get_zero (r, 0);
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = high < 0 && !unsigned_p;
SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
if (n < 0 || n >= EXP_BITS)
abort ();
- if (tens[n].class == rvc_zero)
+ if (tens[n].cl == rvc_zero)
{
if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
{
if (n < 0 || n >= EXP_BITS)
abort ();
- if (tens[n].class == rvc_zero)
+ if (tens[n].cl == rvc_zero)
do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
return &tens[n];
if (n < 0 || n > 9)
abort ();
- if (n > 0 && num[n].class == rvc_zero)
+ if (n > 0 && num[n].cl == rvc_zero)
real_from_integer (&num[n], VOIDmode, n, 0, 1);
return &num[n];
bool neg = false;
memset (r, 0, sizeof (*r));
- r->class = rvc_nan;
+ r->cl = rvc_nan;
/* Parse akin to strtol into the significand of R. */
if (fmt == NULL)
abort ();
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
r->signalling = 0;
r->canonical = 0;
n++;
if (n > MAX_EXP)
- r->class = rvc_inf;
+ r->cl = rvc_inf;
else if (n < -MAX_EXP)
;
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
SET_REAL_EXP (r, n);
r->sig[SIGSZ-1] = SIG_MSB;
}
emax2 = fmt->emax * fmt->log2_b;
np2 = SIGNIFICAND_BITS - p2;
- switch (r->class)
+ switch (r->cl)
{
underflow:
get_zero (r, r->sign);
round_for_format (fmt, r);
/* round_for_format de-normalizes denormals. Undo just that part. */
- if (r->class == rvc_normal)
+ if (r->cl == rvc_normal)
normalize (r);
}
unsigned int h;
size_t i;
- h = r->class | (r->sign << 2);
- switch (r->class)
+ h = r->cl | (r->sign << 2);
+ switch (r->cl)
{
case rvc_zero:
case rvc_inf:
image = sign << 31;
sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
break;
{
if (image && fmt->has_denorm)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, -126);
r->sig[SIGSZ-1] = image << 1;
{
if (image)
{
- r->class = rvc_nan;
+ r->cl = rvc_nan;
r->sign = sign;
r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
^ fmt->qnan_msb_set);
}
else
{
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
}
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp - 127 + 1);
r->sig[SIGSZ-1] = image | SIG_MSB;
sig_hi = (sig_hi >> 11) & 0xfffff;
}
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
break;
{
if ((image_hi || image_lo) && fmt->has_denorm)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, -1022);
if (HOST_BITS_PER_LONG == 32)
{
if (image_hi || image_lo)
{
- r->class = rvc_nan;
+ r->cl = rvc_nan;
r->sign = sign;
r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
if (HOST_BITS_PER_LONG == 32)
}
else
{
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
}
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp - 1023 + 1);
if (HOST_BITS_PER_LONG == 32)
image_hi = r->sign << 15;
sig_hi = sig_lo = 0;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
break;
{
if ((sig_hi || sig_lo) && fmt->has_denorm)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
/* When the IEEE format contains a hidden bit, we know that
if (sig_hi || sig_lo)
{
- r->class = rvc_nan;
+ r->cl = rvc_nan;
r->sign = sign;
r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
if (HOST_BITS_PER_LONG == 32)
}
else
{
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
}
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp - 16383 + 1);
if (HOST_BITS_PER_LONG == 32)
/* Renormlize R before doing any arithmetic on it. */
normr = *r;
- if (normr.class == rvc_normal)
+ if (normr.cl == rvc_normal)
normalize (&normr);
/* u = IEEE double precision portion of significand. */
round_for_format (base_fmt, &u);
encode_ieee_double (base_fmt, &buf[0], &u);
- if (u.class == rvc_normal)
+ if (u.cl == rvc_normal)
{
do_add (&v, &normr, &u, 1);
/* Call round_for_format since we might need to denormalize. */
base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
decode_ieee_double (base_fmt, &u, &buf[0]);
- if (u.class != rvc_zero && u.class != rvc_inf && u.class != rvc_nan)
+ if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
{
decode_ieee_double (base_fmt, &v, &buf[2]);
do_add (r, &u, &v, 0);
rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
break;
{
if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
{
if (image3 | image2 | image1 | image0)
{
- r->class = rvc_nan;
+ r->cl = rvc_nan;
r->sign = sign;
r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
}
else
{
- r->class = rvc_inf;
+ r->cl = rvc_inf;
r->sign = sign;
}
}
else
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp - 16383 + 1);
sign = r->sign << 15;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image = 0;
if (exp != 0)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = (image >> 15) & 1;
SET_REAL_EXP (r, exp - 128);
{
unsigned long image0, image1, sign = r->sign << 15;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image0 = image1 = 0;
if (exp != 0)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = (image0 >> 15) & 1;
SET_REAL_EXP (r, exp - 128);
{
unsigned long image0, image1, sign = r->sign << 15;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image0 = image1 = 0;
if (exp != 0)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = (image0 >> 15) & 1;
SET_REAL_EXP (r, exp - 1024);
sign = r->sign << 31;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image = 0;
if (exp || sig)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, (exp - 64) * 4);
r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
sign = r->sign << 31;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
image_hi = image_lo = 0;
if (exp || image_hi || image_lo)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, (exp - 64) * 4 + (SIGNIFICAND_BITS - 56));
{
unsigned long image, exp, sig;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
exp = -128;
if (exp != -128)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
sig = sf & 0x7fffff;
if (sf < 0)
{
unsigned long exp, sig;
- switch (r->class)
+ switch (r->cl)
{
case rvc_zero:
exp = -128;
if (exp != -128)
{
- r->class = rvc_normal;
+ r->cl = rvc_normal;
sig = sf & 0x7fffffff;
if (sf < 0)
/* Use the same underlying type for all bit-fields, so as to make
sure they're packed together, otherwise REAL_VALUE_TYPE_SIZE will
be miscomputed. */
- unsigned int /* ENUM_BITFIELD (real_value_class) */ class : 2;
+ unsigned int /* ENUM_BITFIELD (real_value_class) */ cl : 2;
unsigned int sign : 1;
unsigned int signalling : 1;
unsigned int canonical : 1;
for (j = 0; j < recog_data.n_alternatives; j++)
{
- op_alt[j].class = NO_REGS;
+ op_alt[j].cl = NO_REGS;
op_alt[j].constraint = p;
op_alt[j].matches = -1;
op_alt[j].matched = -1;
case 'p':
op_alt[j].is_address = 1;
- op_alt[j].class = reg_class_subunion[(int) op_alt[j].class]
+ op_alt[j].cl = reg_class_subunion[(int) op_alt[j].cl]
[(int) MODE_BASE_REG_CLASS (VOIDmode)];
break;
- case 'g': case 'r':
- op_alt[j].class = reg_class_subunion[(int) op_alt[j].class][(int) GENERAL_REGS];
+ case 'g':
+ case 'r':
+ op_alt[j].cl =
+ reg_class_subunion[(int) op_alt[j].cl][(int) GENERAL_REGS];
break;
default:
if (EXTRA_ADDRESS_CONSTRAINT (c, p))
{
op_alt[j].is_address = 1;
- op_alt[j].class
+ op_alt[j].cl
= (reg_class_subunion
- [(int) op_alt[j].class]
+ [(int) op_alt[j].cl]
[(int) MODE_BASE_REG_CLASS (VOIDmode)]);
break;
}
- op_alt[j].class
+ op_alt[j].cl
= (reg_class_subunion
- [(int) op_alt[j].class]
+ [(int) op_alt[j].cl]
[(int) REG_CLASS_FROM_CONSTRAINT ((unsigned char) c, p)]);
break;
}
default:
{
- enum reg_class class;
+ enum reg_class cl;
- class = (c == 'r'
+ cl = (c == 'r'
? GENERAL_REGS : REG_CLASS_FROM_CONSTRAINT (c, p));
- if (class != NO_REGS)
+ if (cl != NO_REGS)
{
if (strict < 0
|| (strict == 0
&& REGNO (op) >= FIRST_PSEUDO_REGISTER)
|| (strict == 0 && GET_CODE (op) == SCRATCH)
|| (REG_P (op)
- && reg_fits_class_p (op, class, offset, mode)))
+ && reg_fits_class_p (op, cl, offset, mode)))
win = 1;
}
#ifdef EXTRA_CONSTRAINT_STR
If REG occupies multiple hard regs, all of them must be in CLASS. */
int
-reg_fits_class_p (rtx operand, enum reg_class class, int offset,
+reg_fits_class_p (rtx operand, enum reg_class cl, int offset,
enum machine_mode mode)
{
int regno = REGNO (operand);
if (regno < FIRST_PSEUDO_REGISTER
- && TEST_HARD_REG_BIT (reg_class_contents[(int) class],
+ && TEST_HARD_REG_BIT (reg_class_contents[(int) cl],
regno + offset))
{
int sr;
regno += offset;
for (sr = hard_regno_nregs[regno][mode] - 1;
sr > 0; sr--)
- if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
+ if (! TEST_HARD_REG_BIT (reg_class_contents[(int) cl],
regno + sr))
break;
return sr == 0;
enum machine_mode mode, HARD_REG_SET *reg_set)
{
static int search_ofs;
- enum reg_class class;
+ enum reg_class cl;
HARD_REG_SET live;
int i;
IOR_HARD_REG_SET (live, this_live);
}
- class = (class_str[0] == 'r' ? GENERAL_REGS
+ cl = (class_str[0] == 'r' ? GENERAL_REGS
: REG_CLASS_FROM_CONSTRAINT (class_str[0], class_str));
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (fixed_regs[regno])
continue;
/* Make sure the register is of the right class. */
- if (! TEST_HARD_REG_BIT (reg_class_contents[class], regno))
+ if (! TEST_HARD_REG_BIT (reg_class_contents[cl], regno))
continue;
/* And can support the mode we need. */
if (! HARD_REGNO_MODE_OK (regno, mode))
const char *constraint;
/* The register class valid for this alternative (possibly NO_REGS). */
- enum reg_class class;
+ enum reg_class cl;
/* "Badness" of this alternative, computed from number of '?' and '!'
characters in the constraint string. */
for (i = 0; i < n_outputs; i++)
if (STACK_REG_P (recog_data.operand[i]))
{
- if (reg_class_size[(int) recog_op_alt[i][alt].class] != 1)
+ if (reg_class_size[(int) recog_op_alt[i][alt].cl] != 1)
{
error_for_asm (insn, "output constraint %d must specify a single register", i);
malformed_asm = 1;
for (i = n_outputs; i < n_outputs + n_inputs; i++)
if (STACK_REG_P (recog_data.operand[i])
- && reg_class_subset_p (recog_op_alt[i][alt].class,
+ && reg_class_subset_p (recog_op_alt[i][alt].cl,
FLOAT_REGS)
- && recog_op_alt[i][alt].class != FLOAT_REGS)
+ && recog_op_alt[i][alt].cl != FLOAT_REGS)
{
/* If an operand needs to be in a particular reg in
FLOAT_REGS, the constraint was either 't' or 'u'. Since
rtx insn;
rtx *loc;
- ENUM_BITFIELD(reg_class) class : 16;
+ ENUM_BITFIELD(reg_class) cl : 16;
unsigned int need_caller_save_reg:1;
unsigned int earlyclobber:1;
};
{
n_uses++;
IOR_COMPL_HARD_REG_SET (this_unavailable,
- reg_class_contents[last->class]);
+ reg_class_contents[last->cl]);
}
if (n_uses < 1)
continue;
IOR_COMPL_HARD_REG_SET (this_unavailable,
- reg_class_contents[last->class]);
+ reg_class_contents[last->cl]);
if (this->need_caller_save_reg)
IOR_HARD_REG_SET (this_unavailable, call_used_reg_set);
static struct du_chain *closed_chains;
static void
-scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
+scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
enum scan_actions action, enum op_type type, int earlyclobber)
{
struct du_chain **p;
this->next_chain = open_chains;
this->loc = loc;
this->insn = insn;
- this->class = class;
+ this->cl = cl;
this->need_caller_save_reg = 0;
this->earlyclobber = earlyclobber;
open_chains = this;
EXTRA_CONSTRAINTS to match registers. Which is arguably
wrong, but there we are. Since we know not what this may
be replaced with, terminate the chain. */
- if (class != NO_REGS)
+ if (cl != NO_REGS)
{
this = obstack_alloc (&rename_obstack, sizeof (struct du_chain));
this->next_use = 0;
this->next_chain = (*p)->next_chain;
this->loc = loc;
this->insn = insn;
- this->class = class;
+ this->cl = cl;
this->need_caller_save_reg = 0;
while (*p)
p = &(*p)->next_use;
}
}
-/* Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or
+/* Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
BASE_REG_CLASS depending on how the register is being considered. */
static void
-scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
+scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl,
enum scan_actions action, enum machine_mode mode)
{
rtx x = *loc;
return;
case REG:
- scan_rtx_reg (insn, loc, class, action, OP_IN, 0);
+ scan_rtx_reg (insn, loc, cl, action, OP_IN, 0);
return;
default:
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
- scan_rtx_address (insn, &XEXP (x, i), class, action, mode);
+ scan_rtx_address (insn, &XEXP (x, i), cl, action, mode);
else if (fmt[i] == 'E')
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
- scan_rtx_address (insn, &XVECEXP (x, i, j), class, action, mode);
+ scan_rtx_address (insn, &XVECEXP (x, i, j), cl, action, mode);
}
}
static void
-scan_rtx (rtx insn, rtx *loc, enum reg_class class,
+scan_rtx (rtx insn, rtx *loc, enum reg_class cl,
enum scan_actions action, enum op_type type, int earlyclobber)
{
const char *fmt;
return;
case REG:
- scan_rtx_reg (insn, loc, class, action, type, earlyclobber);
+ scan_rtx_reg (insn, loc, cl, action, type, earlyclobber);
return;
case MEM:
return;
case SET:
- scan_rtx (insn, &SET_SRC (x), class, action, OP_IN, 0);
- scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT, 0);
+ scan_rtx (insn, &SET_SRC (x), cl, action, OP_IN, 0);
+ scan_rtx (insn, &SET_DEST (x), cl, action, OP_OUT, 0);
return;
case STRICT_LOW_PART:
- scan_rtx (insn, &XEXP (x, 0), class, action, OP_INOUT, earlyclobber);
+ scan_rtx (insn, &XEXP (x, 0), cl, action, OP_INOUT, earlyclobber);
return;
case ZERO_EXTRACT:
case SIGN_EXTRACT:
- scan_rtx (insn, &XEXP (x, 0), class, action,
+ scan_rtx (insn, &XEXP (x, 0), cl, action,
type == OP_IN ? OP_IN : OP_INOUT, earlyclobber);
- scan_rtx (insn, &XEXP (x, 1), class, action, OP_IN, 0);
- scan_rtx (insn, &XEXP (x, 2), class, action, OP_IN, 0);
+ scan_rtx (insn, &XEXP (x, 1), cl, action, OP_IN, 0);
+ scan_rtx (insn, &XEXP (x, 2), cl, action, OP_IN, 0);
return;
case POST_INC:
abort ();
case CLOBBER:
- scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT, 1);
+ scan_rtx (insn, &SET_DEST (x), cl, action, OP_OUT, 1);
return;
case EXPR_LIST:
- scan_rtx (insn, &XEXP (x, 0), class, action, type, 0);
+ scan_rtx (insn, &XEXP (x, 0), cl, action, type, 0);
if (XEXP (x, 1))
- scan_rtx (insn, &XEXP (x, 1), class, action, type, 0);
+ scan_rtx (insn, &XEXP (x, 1), cl, action, type, 0);
return;
default:
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
- scan_rtx (insn, &XEXP (x, i), class, action, type, 0);
+ scan_rtx (insn, &XEXP (x, i), cl, action, type, 0);
else if (fmt[i] == 'E')
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
- scan_rtx (insn, &XVECEXP (x, i, j), class, action, type, 0);
+ scan_rtx (insn, &XVECEXP (x, i, j), cl, action, type, 0);
}
}
{
int matches = recog_op_alt[i][alt].matches;
if (matches >= 0)
- recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class;
+ recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
|| (predicated && recog_data.operand_type[i] == OP_OUT))
recog_data.operand_type[i] = OP_INOUT;
rtx *loc = (i < n_ops
? recog_data.operand_loc[opn]
: recog_data.dup_loc[i - n_ops]);
- enum reg_class class = recog_op_alt[opn][alt].class;
+ enum reg_class cl = recog_op_alt[opn][alt].cl;
enum op_type type = recog_data.operand_type[opn];
/* Don't scan match_operand here, since we've no reg class
continue;
if (recog_op_alt[opn][alt].is_address)
- scan_rtx_address (insn, loc, class, mark_read, VOIDmode);
+ scan_rtx_address (insn, loc, cl, mark_read, VOIDmode);
else
- scan_rtx (insn, loc, class, mark_read, type, 0);
+ scan_rtx (insn, loc, cl, mark_read, type, 0);
}
/* Step 4: Close chains for registers that die here.
{
rtx *loc = recog_data.operand_loc[i];
rtx op = *loc;
- enum reg_class class = recog_op_alt[i][alt].class;
+ enum reg_class cl = recog_op_alt[i][alt].cl;
if (REG_P (op)
&& REGNO (op) == ORIGINAL_REGNO (op))
continue;
- scan_rtx (insn, loc, class, mark_write, OP_OUT,
+ scan_rtx (insn, loc, cl, mark_write, OP_OUT,
recog_op_alt[i][alt].earlyclobber);
}
}
rtx *loc = (i < n_ops
? recog_data.operand_loc[opn]
: recog_data.dup_loc[i - n_ops]);
- enum reg_class class = recog_op_alt[opn][alt].class;
+ enum reg_class cl = recog_op_alt[opn][alt].cl;
if (recog_data.operand_type[opn] == OP_OUT)
- scan_rtx (insn, loc, class, mark_write, OP_OUT,
+ scan_rtx (insn, loc, cl, mark_write, OP_OUT,
recog_op_alt[opn][alt].earlyclobber);
}
while (this)
{
fprintf (dump_file, " %d [%s]", INSN_UID (this->insn),
- reg_class_names[this->class]);
+ reg_class_names[this->cl]);
this = this->next_use;
}
fprintf (dump_file, "\n");
}
/* Find the oldest copy of the value contained in REGNO that is in
- register class CLASS and has mode MODE. If found, return an rtx
+ register class CL and has mode MODE. If found, return an rtx
of that oldest register, otherwise return NULL. */
static rtx
-find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
+find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd)
{
unsigned int regno = REGNO (reg);
enum machine_mode mode = GET_MODE (reg);
unsigned int last;
for (last = i; last < i + hard_regno_nregs[i][mode]; last++)
- if (!TEST_HARD_REG_BIT (reg_class_contents[class], last))
+ if (!TEST_HARD_REG_BIT (reg_class_contents[cl], last))
return NULL_RTX;
new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
}
/* If possible, replace the register at *LOC with the oldest register
- in register class CLASS. Return true if successfully replaced. */
+ in register class CL. Return true if successfully replaced. */
static bool
-replace_oldest_value_reg (rtx *loc, enum reg_class class, rtx insn,
+replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn,
struct value_data *vd)
{
- rtx new = find_oldest_value_reg (class, *loc, vd);
+ rtx new = find_oldest_value_reg (cl, *loc, vd);
if (new)
{
if (dump_file)
}
/* Similar to replace_oldest_value_reg, but *LOC contains an address.
- Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or
+ Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
BASE_REG_CLASS depending on how the register is being considered. */
static bool
-replace_oldest_value_addr (rtx *loc, enum reg_class class,
+replace_oldest_value_addr (rtx *loc, enum reg_class cl,
enum machine_mode mode, rtx insn,
struct value_data *vd)
{
return replace_oldest_value_mem (x, insn, vd);
case REG:
- return replace_oldest_value_reg (loc, class, insn, vd);
+ return replace_oldest_value_reg (loc, cl, insn, vd);
default:
break;
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
- changed |= replace_oldest_value_addr (&XEXP (x, i), class, mode,
+ changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode,
insn, vd);
else if (fmt[i] == 'E')
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
- changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), class,
+ changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
mode, insn, vd);
}
{
int matches = recog_op_alt[i][alt].matches;
if (matches >= 0)
- recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class;
+ recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
|| (predicated && recog_data.operand_type[i] == OP_OUT))
recog_data.operand_type[i] = OP_INOUT;
if (recog_op_alt[i][alt].is_address)
replaced
= replace_oldest_value_addr (recog_data.operand_loc[i],
- recog_op_alt[i][alt].class,
+ recog_op_alt[i][alt].cl,
VOIDmode, insn, vd);
else if (REG_P (recog_data.operand[i]))
replaced
= replace_oldest_value_reg (recog_data.operand_loc[i],
- recog_op_alt[i][alt].class,
+ recog_op_alt[i][alt].cl,
insn, vd);
else if (MEM_P (recog_data.operand[i]))
replaced = replace_oldest_value_mem (recog_data.operand[i],
extern int integer_nonzerop (tree);
-/* staticp (tree x) is nonzero if X is a reference to data allocated
+/* staticp (tree x) is true if X is a reference to data allocated
at a fixed address in memory. */
extern bool staticp (tree);
projects / gcc.git / commitdiff