OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

c-common.c: Rename all identifiers named `class' to `cl'. 

* 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
This commit is contained in:
Bernardo Innocenti 2004-07-25 19:57:24 +02:00 committed by Bernardo Innocenti
parent 381166d48e
commit e3a64162f5
12 changed files with 249 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
gcc/ChangeLog
View File

@ -1,3 +1,17 @@
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

32
gcc/c-common.c
View File

@ -1196,7 +1196,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
{
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
({ }). */
@ -1205,7 +1205,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
restart:
code = TREE_CODE (x);
class = TREE_CODE_CLASS (code);
cl = TREE_CODE_CLASS (code);
if (warning_candidate_p (x))
{
@ -1349,7 +1349,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
break;
}
if (class == '1')
if (cl == '1')
{
if (first_rtl_op (code) == 0)
return;
@ -1358,7 +1358,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
goto restart;
}
switch (class)
switch (cl)
{
case 'r':
case '<':
@ -2460,9 +2460,12 @@ c_common_truthvalue_conversion (tree expr)
return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
}
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. */
@ -3269,10 +3272,10 @@ builtin_function_disabled_p (const char *name)
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,
@ -3280,21 +3283,22 @@ builtin_function_disabled_p (const char *name)
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);

6
gcc/c-decl.c
View File

@ -2475,15 +2475,15 @@ c_make_fname_decl (tree id, int type_dep)
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));

2
gcc/c-typeck.c
View File

@ -1975,7 +1975,7 @@ convert_arguments (tree typelist, tree values, tree name, tree fundecl)
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)

116
gcc/genmodes.c
View File

@ -55,7 +55,7 @@ struct mode_data
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 */
@ -79,7 +79,7 @@ static struct mode_data *void_mode;
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
};
@ -105,27 +105,27 @@ static struct mode_adjust *adj_format;
/* 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;
}
}
@ -137,11 +137,11 @@ find_mode (const char *name)
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;
@ -155,17 +155,17 @@ new_mode (enum mode_class class, const char *name,
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;
@ -210,7 +210,7 @@ new_adjust (const char *name,
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);
@ -289,13 +289,13 @@ complete_mode (struct mode_data *m)
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. */
@ -326,7 +326,7 @@ complete_mode (struct mode_data *m)
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;
@ -370,7 +370,7 @@ complete_mode (struct mode_data *m)
/* 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;
@ -390,27 +390,27 @@ static void
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)
@ -426,7 +426,7 @@ make_complex_modes (enum mode_class class,
/* 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);
@ -448,23 +448,23 @@ make_complex_modes (enum mode_class class,
}
}
/* 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
@ -477,9 +477,9 @@ make_vector_modes (enum mode_class class, unsigned int width,
/* 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)
@ -503,13 +503,13 @@ make_vector_modes (enum mode_class class, unsigned int width,
#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__)
@ -523,7 +523,7 @@ make_int_mode (const char *name,
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__)
@ -551,7 +551,7 @@ reset_float_format (const char *name, const char *format,
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;
@ -562,7 +562,7 @@ reset_float_format (const char *name, const char *format,
/* 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,
@ -575,12 +575,12 @@ make_partial_integer_mode (const char *base, const char *name,
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;
@ -608,7 +608,7 @@ make_vector_mode (enum mode_class bclass,
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);
@ -692,7 +692,7 @@ cmp_modes (const void *a, const void *b)
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;
@ -765,7 +765,7 @@ calc_wider_mode (void)
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",
@ -866,7 +866,7 @@ emit_min_insn_modes_c_header (void)
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");
@ -880,13 +880,13 @@ emit_mode_name (void)
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 ();
}
@ -894,7 +894,7 @@ emit_mode_class (void)
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");
@ -911,7 +911,7 @@ emit_mode_precision (void)
static void
emit_mode_size (void)
{
enum mode_class c;
int c;
struct mode_data *m;
print_maybe_const_decl ("%sunsigned char", "mode_size",
@ -926,7 +926,7 @@ emit_mode_size (void)
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");
@ -940,7 +940,7 @@ emit_mode_nunits (void)
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");
@ -956,7 +956,7 @@ emit_mode_wider (void)
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",
@ -980,7 +980,7 @@ emit_mode_mask (void)
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");
@ -996,7 +996,7 @@ emit_mode_inner (void)
static void
emit_mode_base_align (void)
{
enum mode_class c;
int c;
struct mode_data *m;
print_maybe_const_decl ("%sunsigned char",
@ -1012,7 +1012,7 @@ emit_mode_base_align (void)
static void
emit_class_narrowest_mode (void)
{
enum mode_class c;
int c;
print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
@ -1084,7 +1084,7 @@ emit_mode_adjustments (void)
for (m = a->mode->contained; m; m = m->next_cont)
{
switch (m->class)
switch (m->cl)
{
case MODE_COMPLEX_INT:
case MODE_COMPLEX_FLOAT:
@ -1120,7 +1120,7 @@ emit_mode_adjustments (void)
for (m = a->mode->contained; m; m = m->next_cont)
{
switch (m->class)
switch (m->cl)
{
case MODE_COMPLEX_INT:
case MODE_COMPLEX_FLOAT:

162
gcc/real.c
View File

@ -138,7 +138,7 @@ static inline void
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;
}
@ -147,7 +147,7 @@ static inline void
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;
@ -157,7 +157,7 @@ static inline void
get_inf (REAL_VALUE_TYPE *r, int sign)
{
memset (r, 0, sizeof (*r));
r->class = rvc_inf;
r->cl = rvc_inf;
r->sign = sign;
}
@ -490,7 +490,7 @@ normalize (REAL_VALUE_TYPE *r)
/* Zero significand flushes to zero. */
if (i < 0)
{
r->class = rvc_zero;
r->cl = rvc_zero;
SET_REAL_EXP (r, 0);
return;
}
@ -531,7 +531,7 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
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. */
@ -637,7 +637,7 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
}
}
r->class = rvc_normal;
r->cl = rvc_normal;
r->sign = sign;
SET_REAL_EXP (r, exp);
@ -646,7 +646,7 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
/* 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;
@ -665,7 +665,7 @@ do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
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):
@ -764,7 +764,7 @@ do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
}
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)
@ -800,7 +800,7 @@ do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
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. */
@ -860,7 +860,7 @@ do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
/* 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;
@ -897,7 +897,7 @@ do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
{
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. */
@ -952,7 +952,7 @@ do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
{
*r = *a;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
case rvc_inf:
@ -999,7 +999,7 @@ real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
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;
@ -1008,7 +1008,7 @@ real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *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;
@ -1067,9 +1067,9 @@ real_compare (int icode, const REAL_VALUE_TYPE *op0,
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:
@ -1093,7 +1093,7 @@ real_compare (int icode, const REAL_VALUE_TYPE *op0,
int
real_exponent (const REAL_VALUE_TYPE *r)
{
switch (r->class)
switch (r->cl)
{
case rvc_zero:
return 0;
@ -1113,7 +1113,7 @@ void
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:
@ -1140,7 +1140,7 @@ real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
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. */
@ -1148,7 +1148,7 @@ real_isinf (const REAL_VALUE_TYPE *r)
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. */
@ -1164,7 +1164,7 @@ real_isneg (const REAL_VALUE_TYPE *r)
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. */
@ -1174,12 +1174,12 @@ real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
{
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:
@ -1219,7 +1219,7 @@ exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
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. */
@ -1234,7 +1234,7 @@ exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
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)
@ -1253,7 +1253,7 @@ real_to_integer (const REAL_VALUE_TYPE *r)
{
unsigned HOST_WIDE_INT i;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
underflow:
@ -1309,7 +1309,7 @@ real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
HOST_WIDE_INT low, high;
int exp;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
underflow:
@ -1431,7 +1431,7 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
bool sign;
r = *r_orig;
switch (r.class)
switch (r.cl)
{
case rvc_zero:
strcpy (str, (r.sign ? "-0.0" : "0.0"));
@ -1698,7 +1698,7 @@ real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
char exp_buf[16];
size_t max_digits;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
exp = 0;
@ -1851,7 +1851,7 @@ real_from_string (REAL_VALUE_TYPE *r, const char *str)
exp += d;
}
r->class = rvc_normal;
r->cl = rvc_normal;
SET_REAL_EXP (r, exp);
normalize (r);
@ -1874,7 +1874,7 @@ real_from_string (REAL_VALUE_TYPE *r, const char *str)
if (*str == '.')
{
str++;
if (r->class == rvc_zero)
if (r->cl == rvc_zero)
{
while (*str == '0')
str++, exp--;
@ -1963,7 +1963,7 @@ real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
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);
@ -2011,7 +2011,7 @@ ten_to_ptwo (int n)
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))
{
@ -2043,7 +2043,7 @@ ten_to_mptwo (int n)
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];
@ -2059,7 +2059,7 @@ real_digit (int 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];
@ -2127,7 +2127,7 @@ real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
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. */
@ -2204,7 +2204,7 @@ real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
if (fmt == NULL)
abort ();
r->class = rvc_normal;
r->cl = rvc_normal;
r->sign = sign;
r->signalling = 0;
r->canonical = 0;
@ -2224,12 +2224,12 @@ real_2expN (REAL_VALUE_TYPE *r, int n)
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;
}
@ -2249,7 +2249,7 @@ round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
emax2 = fmt->emax * fmt->log2_b;
np2 = SIGNIFICAND_BITS - p2;
switch (r->class)
switch (r->cl)
{
underflow:
get_zero (r, r->sign);
@ -2382,7 +2382,7 @@ real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
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);
}
@ -2493,8 +2493,8 @@ real_hash (const REAL_VALUE_TYPE *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:
@ -2546,7 +2546,7 @@ encode_ieee_single (const struct real_format *fmt, long *buf,
image = sign << 31;
sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
break;
@ -2618,7 +2618,7 @@ decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
{
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;
@ -2631,7 +2631,7 @@ decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
{
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);
@ -2639,13 +2639,13 @@ decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
}
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;
@ -2720,7 +2720,7 @@ encode_ieee_double (const struct real_format *fmt, long *buf,
sig_hi = (sig_hi >> 11) & 0xfffff;
}
switch (r->class)
switch (r->cl)
{
case rvc_zero:
break;
@ -2819,7 +2819,7 @@ decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
{
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)
@ -2843,7 +2843,7 @@ decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
{
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)
@ -2856,13 +2856,13 @@ decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
}
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)
@ -2930,7 +2930,7 @@ encode_ieee_extended (const struct real_format *fmt, long *buf,
image_hi = r->sign << 15;
sig_hi = sig_lo = 0;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
break;
@ -3108,7 +3108,7 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
{
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
@ -3139,7 +3139,7 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
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)
@ -3152,13 +3152,13 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
}
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)
@ -3322,7 +3322,7 @@ encode_ibm_extended (const struct real_format *fmt, long *buf,
/* 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. */
@ -3330,7 +3330,7 @@ encode_ibm_extended (const struct real_format *fmt, long *buf,
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. */
@ -3356,7 +3356,7 @@ decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_
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);
@ -3424,7 +3424,7 @@ encode_ieee_quad (const struct real_format *fmt, long *buf,
rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
switch (r->class)
switch (r->cl)
{
case rvc_zero:
break;
@ -3576,7 +3576,7 @@ decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
{
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));
@ -3602,7 +3602,7 @@ decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
{
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;
@ -3622,13 +3622,13 @@ decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
}
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);
@ -3716,7 +3716,7 @@ encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
sign = r->sign << 15;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
image = 0;
@ -3755,7 +3755,7 @@ decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
if (exp != 0)
{
r->class = rvc_normal;
r->cl = rvc_normal;
r->sign = (image >> 15) & 1;
SET_REAL_EXP (r, exp - 128);
@ -3770,7 +3770,7 @@ encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
{
unsigned long image0, image1, sign = r->sign << 15;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
image0 = image1 = 0;
@ -3838,7 +3838,7 @@ decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
if (exp != 0)
{
r->class = rvc_normal;
r->cl = rvc_normal;
r->sign = (image0 >> 15) & 1;
SET_REAL_EXP (r, exp - 128);
@ -3870,7 +3870,7 @@ encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
{
unsigned long image0, image1, sign = r->sign << 15;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
image0 = image1 = 0;
@ -3938,7 +3938,7 @@ decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
if (exp != 0)
{
r->class = rvc_normal;
r->cl = rvc_normal;
r->sign = (image0 >> 15) & 1;
SET_REAL_EXP (r, exp - 1024);
@ -4042,7 +4042,7 @@ encode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
sign = r->sign << 31;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
image = 0;
@ -4081,7 +4081,7 @@ decode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
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);
@ -4097,7 +4097,7 @@ encode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
sign = r->sign << 31;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
image_hi = image_lo = 0;
@ -4159,7 +4159,7 @@ decode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
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));
@ -4245,7 +4245,7 @@ encode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
{
unsigned long image, exp, sig;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
exp = -128;
@ -4294,7 +4294,7 @@ decode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
if (exp != -128)
{
r->class = rvc_normal;
r->cl = rvc_normal;
sig = sf & 0x7fffff;
if (sf < 0)
@ -4318,7 +4318,7 @@ encode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
{
unsigned long exp, sig;
switch (r->class)
switch (r->cl)
{
case rvc_zero:
exp = -128;
@ -4381,7 +4381,7 @@ decode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
if (exp != -128)
{
r->class = rvc_normal;
r->cl = rvc_normal;
sig = sf & 0x7fffffff;
if (sf < 0)

2
gcc/real.h
View File

@ -45,7 +45,7 @@ struct real_value GTY(())
/* 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;

38
gcc/recog.c
View File

@ -2096,7 +2096,7 @@ preprocess_constraints (void)
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;
@ -2171,12 +2171,14 @@ preprocess_constraints (void)
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:
@ -2188,16 +2190,16 @@ preprocess_constraints (void)
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;
}
@ -2518,11 +2520,11 @@ constrain_operands (int strict)
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
@ -2530,7 +2532,7 @@ constrain_operands (int strict)
&& 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
@ -2623,19 +2625,19 @@ constrain_operands (int strict)
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;
@ -2898,7 +2900,7 @@ peep2_find_free_register (int from, int to, const char *class_str,
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;
@ -2928,7 +2930,7 @@ peep2_find_free_register (int from, int to, const char *class_str,
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++)
@ -2949,7 +2951,7 @@ peep2_find_free_register (int from, int to, const char *class_str,
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))

2
gcc/recog.h
View File

@ -38,7 +38,7 @@ struct operand_alternative
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. */

6
gcc/reg-stack.c
View File

@ -667,7 +667,7 @@ check_asm_stack_operands (rtx insn)
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;
@ -2147,9 +2147,9 @@ subst_asm_stack_regs (rtx insn, stack regstack)
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

96
gcc/regrename.c
View File

@ -51,7 +51,7 @@ struct du_chain
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;
};
@ -270,13 +270,13 @@ regrename_optimize (void)
{
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);
@ -385,7 +385,7 @@ static struct du_chain *open_chains;
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;
@ -404,7 +404,7 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
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;
@ -451,14 +451,14 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
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;
@ -502,11 +502,11 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
}
}
/* 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;
@ -620,7 +620,7 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
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:
@ -631,15 +631,15 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
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;
@ -661,7 +661,7 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
return;
case REG:
scan_rtx_reg (insn, loc, class, action, type, earlyclobber);
scan_rtx_reg (insn, loc, cl, action, type, earlyclobber);
return;
case MEM:
@ -671,20 +671,20 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
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:
@ -697,13 +697,13 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
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:
@ -714,10 +714,10 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
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);
}
}
@ -775,7 +775,7 @@ build_def_use (basic_block bb)
{
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;
@ -850,7 +850,7 @@ build_def_use (basic_block bb)
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
@ -860,9 +860,9 @@ build_def_use (basic_block bb)
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.
@ -924,13 +924,13 @@ build_def_use (basic_block bb)
{
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);
}
}
@ -941,10 +941,10 @@ build_def_use (basic_block bb)
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);
}
@ -979,7 +979,7 @@ dump_def_use_chain (struct du_chain *chains)
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");
@ -1312,11 +1312,11 @@ maybe_mode_change (enum machine_mode orig_mode, enum machine_mode copy_mode,
}
/* 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);
@ -1343,7 +1343,7 @@ find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
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);
@ -1359,13 +1359,13 @@ find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
}
/* 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)
@ -1379,11 +1379,11 @@ replace_oldest_value_reg (rtx *loc, enum reg_class class, rtx insn,
}
/* 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)
{
@ -1491,7 +1491,7 @@ replace_oldest_value_addr (rtx *loc, enum reg_class class,
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;
@ -1501,11 +1501,11 @@ replace_oldest_value_addr (rtx *loc, enum reg_class class,
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);
}
@ -1562,7 +1562,7 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *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;
@ -1669,12 +1669,12 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
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],

2
gcc/tree.h
View File

@ -3140,7 +3140,7 @@ extern int integer_pow2p (tree);
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);