/* Abort after printing out a specific insn. */
static void
abort_with_insn (rtx insn, const char *reason)
{
error (reason);
debug_rtx (insn);
abort ();
}
void
debug_rtx_range (rtx start, rtx end)
{
while (1)
{
debug_rtx (start);
fprintf (stderr, "\n");
if (!start || start == end)
break;
start = NEXT_INSN (start);
}
}
DEBUG_FUNCTION void
debug_rtx_range (const_rtx start, const_rtx end)
{
while (1)
{
debug_rtx (start);
fprintf (stderr, "\n");
if (!start || start == end)
break;
start = NEXT_INSN (start);
}
}
void
_fatal_insn (const char *msgid, const_rtx insn, const char *file, int line,
const char *function)
{
error ("%s", _(msgid));
/* The above incremented error_count, but isn't an error that we want to
count, so reset it here. */
errorcount--;
debug_rtx (insn);
fancy_abort (file, line, function);
}
void
fr30_print_operand_address (FILE *stream, rtx address)
{
switch (GET_CODE (address))
{
case SYMBOL_REF:
output_addr_const (stream, address);
break;
default:
fprintf (stderr, "code = %x\n", GET_CODE (address));
debug_rtx (address);
output_operand_lossage ("fr30_print_operand_address: unhandled address");
break;
}
}
static int
crx_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
{
enum crx_addrtype addrtype;
struct crx_address address;
int cost = 2;
addrtype = crx_decompose_address (addr, &address);
gcc_assert (addrtype != CRX_INVALID);
/* An absolute address causes a 3-word instruction */
if (addrtype == CRX_ABSOLUTE)
cost+=2;
/* Post-modifying addresses are more powerful. */
if (addrtype == CRX_POST_INC)
cost-=2;
/* Attempt to minimize number of registers in the address. */
if (address.base)
cost++;
if (address.index && address.scale == 1)
cost+=5;
if (address.disp && !INT_CST4 (INTVAL (address.disp)))
cost+=2;
if (TARGET_DEBUG_ADDR)
{
fprintf (stderr, "\n======\nTARGET_ADDRESS_COST = %d\n", cost);
debug_rtx (addr);
}
return cost;
}
void
debug_rtx_list (rtx x, int n)
{
int i,count;
rtx insn;
count = n == 0 ? 1 : n < 0 ? -n : n;
/* If we are printing a window, back up to the start. */
if (n < 0)
for (i = count / 2; i > 0; i--)
{
if (PREV_INSN (x) == 0)
break;
x = PREV_INSN (x);
}
for (i = count, insn = x; i > 0 && insn != 0; i--, insn = NEXT_INSN (insn))
{
debug_rtx (insn);
fprintf (stderr, "\n");
}
}
static void
moxie_operand_lossage (const char *msgid, rtx op)
{
debug_rtx (op);
output_operand_lossage ("%s", msgid);
}
void
fr30_print_operand (FILE *file, rtx x, int code)
{
rtx x0;
switch (code)
{
case '#':
/* Output a :D if this instruction is delayed. */
if (dbr_sequence_length () != 0)
fputs (":D", file);
return;
case 'p':
/* Compute the register name of the second register in a hi/lo
register pair. */
if (GET_CODE (x) != REG)
output_operand_lossage ("fr30_print_operand: unrecognized %%p code");
else
fprintf (file, "r%d", REGNO (x) + 1);
return;
case 'b':
/* Convert GCC's comparison operators into FR30 comparison codes. */
switch (GET_CODE (x))
{
case EQ: fprintf (file, "eq"); break;
case NE: fprintf (file, "ne"); break;
case LT: fprintf (file, "lt"); break;
case LE: fprintf (file, "le"); break;
case GT: fprintf (file, "gt"); break;
case GE: fprintf (file, "ge"); break;
case LTU: fprintf (file, "c"); break;
case LEU: fprintf (file, "ls"); break;
case GTU: fprintf (file, "hi"); break;
case GEU: fprintf (file, "nc"); break;
default:
output_operand_lossage ("fr30_print_operand: unrecognized %%b code");
break;
}
return;
case 'B':
/* Convert GCC's comparison operators into the complimentary FR30
comparison codes. */
switch (GET_CODE (x))
{
case EQ: fprintf (file, "ne"); break;
case NE: fprintf (file, "eq"); break;
case LT: fprintf (file, "ge"); break;
case LE: fprintf (file, "gt"); break;
case GT: fprintf (file, "le"); break;
case GE: fprintf (file, "lt"); break;
case LTU: fprintf (file, "nc"); break;
case LEU: fprintf (file, "hi"); break;
case GTU: fprintf (file, "ls"); break;
case GEU: fprintf (file, "c"); break;
default:
output_operand_lossage ("fr30_print_operand: unrecognized %%B code");
break;
}
return;
case 'A':
/* Print a signed byte value as an unsigned value. */
if (GET_CODE (x) != CONST_INT)
output_operand_lossage ("fr30_print_operand: invalid operand to %%A code");
else
{
HOST_WIDE_INT val;
val = INTVAL (x);
val &= 0xff;
fprintf (file, HOST_WIDE_INT_PRINT_DEC, val);
}
return;
case 'x':
if (GET_CODE (x) != CONST_INT
|| INTVAL (x) < 16
|| INTVAL (x) > 32)
output_operand_lossage ("fr30_print_operand: invalid %%x code");
else
fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) - 16);
return;
case 'F':
if (GET_CODE (x) != CONST_DOUBLE)
output_operand_lossage ("fr30_print_operand: invalid %%F code");
else
{
char str[30];
real_to_decimal (str, CONST_DOUBLE_REAL_VALUE (x),
sizeof (str), 0, 1);
fputs (str, file);
}
return;
case 0:
/* Handled below. */
break;
default:
fprintf (stderr, "unknown code = %x\n", code);
output_operand_lossage ("fr30_print_operand: unknown code");
return;
}
switch (GET_CODE (x))
{
case REG:
fputs (reg_names [REGNO (x)], file);
break;
case MEM:
x0 = XEXP (x,0);
switch (GET_CODE (x0))
{
case REG:
gcc_assert ((unsigned) REGNO (x0) < ARRAY_SIZE (reg_names));
fprintf (file, "@%s", reg_names [REGNO (x0)]);
break;
case PLUS:
if (GET_CODE (XEXP (x0, 0)) != REG
|| REGNO (XEXP (x0, 0)) < FRAME_POINTER_REGNUM
|| REGNO (XEXP (x0, 0)) > STACK_POINTER_REGNUM
|| GET_CODE (XEXP (x0, 1)) != CONST_INT)
{
fprintf (stderr, "bad INDEXed address:");
debug_rtx (x);
output_operand_lossage ("fr30_print_operand: unhandled MEM");
}
else if (REGNO (XEXP (x0, 0)) == FRAME_POINTER_REGNUM)
{
HOST_WIDE_INT val = INTVAL (XEXP (x0, 1));
if (val < -(1 << 9) || val > ((1 << 9) - 4))
{
fprintf (stderr, "frame INDEX out of range:");
debug_rtx (x);
output_operand_lossage ("fr30_print_operand: unhandled MEM");
}
fprintf (file, "@(r14, #" HOST_WIDE_INT_PRINT_DEC ")", val);
}
else
{
HOST_WIDE_INT val = INTVAL (XEXP (x0, 1));
if (val < 0 || val > ((1 << 6) - 4))
{
fprintf (stderr, "stack INDEX out of range:");
debug_rtx (x);
output_operand_lossage ("fr30_print_operand: unhandled MEM");
}
fprintf (file, "@(r15, #" HOST_WIDE_INT_PRINT_DEC ")", val);
}
break;
case SYMBOL_REF:
output_address (x0);
break;
default:
fprintf (stderr, "bad MEM code = %x\n", GET_CODE (x0));
debug_rtx (x);
output_operand_lossage ("fr30_print_operand: unhandled MEM");
break;
}
break;
case CONST_DOUBLE :
/* We handle SFmode constants here as output_addr_const doesn't. */
if (GET_MODE (x) == SFmode)
{
REAL_VALUE_TYPE d;
long l;
REAL_VALUE_FROM_CONST_DOUBLE (d, x);
REAL_VALUE_TO_TARGET_SINGLE (d, l);
fprintf (file, "0x%08lx", l);
break;
}
/* Fall through. Let output_addr_const deal with it. */
default:
output_addr_const (file, x);
break;
}
return;
}
bool
crx_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
rtx addr, bool strict)
{
enum crx_addrtype addrtype;
struct crx_address address;
if (TARGET_DEBUG_ADDR)
{
fprintf (stderr,
"\n======\nGO_IF_LEGITIMATE_ADDRESS, mode = %s, strict = %d\n",
GET_MODE_NAME (mode), strict);
debug_rtx (addr);
}
addrtype = crx_decompose_address (addr, &address);
if (addrtype == CRX_POST_INC && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
return FALSE;
if (TARGET_DEBUG_ADDR)
{
const char *typestr;
switch (addrtype)
{
case CRX_INVALID:
typestr = "Invalid";
break;
case CRX_REG_REL:
typestr = "Register relative";
break;
case CRX_POST_INC:
typestr = "Post-increment";
break;
case CRX_SCALED_INDX:
typestr = "Scaled index";
break;
case CRX_ABSOLUTE:
typestr = "Absolute";
break;
default:
abort ();
}
fprintf (stderr, "CRX Address type: %s\n", typestr);
}
if (addrtype == CRX_INVALID)
return FALSE;
if (strict)
{
if (address.base && !REGNO_OK_FOR_BASE_P (REGNO (address.base)))
{
if (TARGET_DEBUG_ADDR)
fprintf (stderr, "Base register not strict\n");
return FALSE;
}
if (address.index && !REGNO_OK_FOR_INDEX_P (REGNO (address.index)))
{
if (TARGET_DEBUG_ADDR)
fprintf (stderr, "Index register not strict\n");
return FALSE;
}
}
return TRUE;
}
void
print_insn (char *buf, rtx x, int verbose)
{
char t[BUF_LEN];
rtx insn = x;
switch (GET_CODE (x))
{
case INSN:
print_pattern (t, PATTERN (x), verbose);
if (verbose)
sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
t);
else
sprintf (buf, "%-4d %s", INSN_UID (x), t);
break;
case JUMP_INSN:
print_pattern (t, PATTERN (x), verbose);
if (verbose)
sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
t);
else
sprintf (buf, "%-4d %s", INSN_UID (x), t);
break;
case CALL_INSN:
x = PATTERN (insn);
if (GET_CODE (x) == PARALLEL)
{
x = XVECEXP (x, 0, 0);
print_pattern (t, x, verbose);
}
else
strcpy (t, "call <...>");
if (verbose)
sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1), t);
else
sprintf (buf, "%-4d %s", INSN_UID (insn), t);
break;
case CODE_LABEL:
sprintf (buf, "L%d:", INSN_UID (x));
break;
case BARRIER:
sprintf (buf, "i% 4d: barrier", INSN_UID (x));
break;
case NOTE:
if (NOTE_LINE_NUMBER (x) > 0)
{
expanded_location xloc;
NOTE_EXPANDED_LOCATION (xloc, x);
sprintf (buf, "%4d note \"%s\" %d", INSN_UID (x),
xloc.file, xloc.line);
}
else
sprintf (buf, "%4d %s", INSN_UID (x),
GET_NOTE_INSN_NAME (NOTE_LINE_NUMBER (x)));
break;
default:
if (verbose)
{
sprintf (buf, "Not an INSN at all\n");
debug_rtx (x);
}
else
sprintf (buf, "i%-4d <What?>", INSN_UID (x));
}
} /* print_insn */
DEBUG_FUNCTION void
debug (const rtx_def &ref)
{
debug_rtx (&ref);
}
