#include "config.h"
#include "system.h"
#include "rtl.h"
#include "real.h"
#include "ggc.h"
#include "errors.h"
#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
const unsigned char rtx_length[NUM_RTX_CODE] = {
#include "rtl.def"
};
#undef DEF_RTL_EXPR
#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
const char * const rtx_name[NUM_RTX_CODE] = {
#include "rtl.def"
};
#undef DEF_RTL_EXPR
#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) NAME,
const char * const mode_name[NUM_MACHINE_MODES] = {
#include "machmode.def"
};
#undef DEF_MACHMODE
#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) CLASS,
const enum mode_class mode_class[NUM_MACHINE_MODES] = {
#include "machmode.def"
};
#undef DEF_MACHMODE
#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) BITSIZE,
const unsigned short mode_bitsize[NUM_MACHINE_MODES] = {
#include "machmode.def"
};
#undef DEF_MACHMODE
#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) SIZE,
const unsigned char mode_size[NUM_MACHINE_MODES] = {
#include "machmode.def"
};
#undef DEF_MACHMODE
#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) UNIT,
const unsigned char mode_unit_size[NUM_MACHINE_MODES] = {
#include "machmode.def"
};
#undef DEF_MACHMODE
#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \
(unsigned char) WIDER,
const unsigned char mode_wider_mode[NUM_MACHINE_MODES] = {
#include "machmode.def"
};
#undef DEF_MACHMODE
#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) \
((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT) 0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES] = {
#include "machmode.def"
};
#undef DEF_MACHMODE
#define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) INNER,
const enum machine_mode inner_mode_array[NUM_MACHINE_MODES] = {
#include "machmode.def"
};
const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
VOIDmode,
QImode,
QFmode,
PQImode,
CCmode,
CQImode,
QCmode,
V1DImode,
V2SFmode
};
const char * const rtx_format[NUM_RTX_CODE] = {
#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
#include "rtl.def"
#undef DEF_RTL_EXPR
};
const char rtx_class[NUM_RTX_CODE] = {
#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
#include "rtl.def"
#undef DEF_RTL_EXPR
};
const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] =
{
"", "NOTE_INSN_DELETED",
"NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
"NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
"NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
"NOTE_INSN_LOOP_END_TOP_COND", "NOTE_INSN_FUNCTION_END",
"NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
"NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
"NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
"NOTE_INSN_REPEATED_LINE_NUMBER",
"NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE",
"NOTE_INSN_PREDICTION",
"NOTE_INSN_UNLIKELY_EXECUTED_CODE",
"NOTE_INSN_DONT_SHORTEN_BRANCH"
};
const char * const reg_note_name[] =
{
"", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
"REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
"REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
"REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
"REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
"REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
"REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
"REG_NON_LOCAL_GOTO", "REG_SETJMP", "REG_ALWAYS_RETURN",
"REG_ABSCALL",
"REG_VTABLE_REF"
};
rtvec
rtvec_alloc (n)
int n;
{
rtvec rt;
rt = ggc_alloc_rtvec (n);
memset (&rt->elem[0], 0, n * sizeof (rtx));
PUT_NUM_ELEM (rt, n);
return rt;
}
rtx
rtx_alloc (code)
RTX_CODE code;
{
rtx rt;
int n = GET_RTX_LENGTH (code);
rt = ggc_alloc_rtx (n);
memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
PUT_CODE (rt, code);
return rt;
}
rtx
copy_rtx (orig)
rtx orig;
{
rtx copy;
int i, j;
RTX_CODE code;
const char *format_ptr;
code = GET_CODE (orig);
switch (code)
{
case REG:
case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
case SYMBOL_REF:
case CODE_LABEL:
case PC:
case CC0:
case SCRATCH:
case ADDRESSOF:
return orig;
case CONST:
if (GET_CODE (XEXP (orig, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
&& GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
return orig;
break;
default:
break;
}
copy = rtx_alloc (code);
memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
RTX_FLAG (copy, used) = 0;
if (GET_RTX_CLASS (code) == 'i')
RTX_FLAG (copy, frame_related) = 0;
RTX_FLAG (copy, jump) = RTX_FLAG (orig, jump);
RTX_FLAG (copy, call) = RTX_FLAG (orig, call);
format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
{
copy->fld[i] = orig->fld[i];
switch (*format_ptr++)
{
case 'e':
if (XEXP (orig, i) != NULL)
XEXP (copy, i) = copy_rtx (XEXP (orig, i));
break;
case 'E':
case 'V':
if (XVEC (orig, i) != NULL)
{
XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
for (j = 0; j < XVECLEN (copy, i); j++)
XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
}
break;
case 't':
case 'w':
case 'i':
case 's':
case 'S':
case 'T':
case 'u':
case 'B':
case '0':
break;
default:
abort ();
}
}
return copy;
}
rtx
shallow_copy_rtx (orig)
rtx orig;
{
RTX_CODE code = GET_CODE (orig);
size_t n = GET_RTX_LENGTH (code);
rtx copy = ggc_alloc_rtx (n);
memcpy (copy, orig,
sizeof (struct rtx_def) + sizeof (rtunion) * (n - 1));
return copy;
}
int rtx_equal_function_value_matters;
int generating_concat_p;
int
rtx_equal_p (x, y)
rtx x, y;
{
int i;
int j;
enum rtx_code code;
const char *fmt;
if (x == y)
return 1;
if (x == 0 || y == 0)
return 0;
code = GET_CODE (x);
if (code != GET_CODE (y))
return 0;
if (GET_MODE (x) != GET_MODE (y))
return 0;
switch (code)
{
case REG:
return (REGNO (x) == REGNO (y)
&& (! rtx_equal_function_value_matters
|| REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
case LABEL_REF:
return XEXP (x, 0) == XEXP (y, 0);
case SYMBOL_REF:
return XSTR (x, 0) == XSTR (y, 0);
case SCRATCH:
case CONST_DOUBLE:
case CONST_INT:
case CONST_VECTOR:
return 0;
default:
break;
}
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
switch (fmt[i])
{
case 'w':
if (XWINT (x, i) != XWINT (y, i))
return 0;
break;
case 'n':
case 'i':
if (XINT (x, i) != XINT (y, i))
return 0;
break;
case 'V':
case 'E':
if (XVECLEN (x, i) != XVECLEN (y, i))
return 0;
for (j = 0; j < XVECLEN (x, i); j++)
if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
return 0;
break;
case 'e':
if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
return 0;
break;
case 'S':
case 's':
if ((XSTR (x, i) || XSTR (y, i))
&& (! XSTR (x, i) || ! XSTR (y, i)
|| strcmp (XSTR (x, i), XSTR (y, i))))
return 0;
break;
case 'u':
break;
case '0':
case 't':
break;
default:
abort ();
}
}
return 1;
}
#if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
void
rtl_check_failed_bounds (r, n, file, line, func)
rtx r;
int n;
const char *file;
int line;
const char *func;
{
internal_error
("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
func, trim_filename (file), line);
}
void
rtl_check_failed_type1 (r, n, c1, file, line, func)
rtx r;
int n;
int c1;
const char *file;
int line;
const char *func;
{
internal_error
("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
func, trim_filename (file), line);
}
void
rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
rtx r;
int n;
int c1;
int c2;
const char *file;
int line;
const char *func;
{
internal_error
("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
func, trim_filename (file), line);
}
void
rtl_check_failed_code1 (r, code, file, line, func)
rtx r;
enum rtx_code code;
const char *file;
int line;
const char *func;
{
internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
trim_filename (file), line);
}
void
rtl_check_failed_code2 (r, code1, code2, file, line, func)
rtx r;
enum rtx_code code1, code2;
const char *file;
int line;
const char *func;
{
internal_error
("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
func, trim_filename (file), line);
}
void
rtvec_check_failed_bounds (r, n, file, line, func)
rtvec r;
int n;
const char *file;
int line;
const char *func;
{
internal_error
("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
}
#endif
#if defined ENABLE_RTL_FLAG_CHECKING
void
rtl_check_failed_flag (name, r, file, line, func)
const char *name;
rtx r;
const char *file;
int line;
const char *func;
{
internal_error
("RTL flag check: %s used with unexpected rtx code `%s' in %s, at %s:%d",
name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
}
#endif