Skip to content

R
riscv-gcc-1
Commit 459b3825 by Michael Meissner
Options

Prevent buffer overrun in debug output; Make alloc_{INSN,EXPR}_LIST static 

From-SVN: r19503
parent 61fbdb55
Showing with 285 additions and 223 deletions
gcc/ChangeLog
Thu Apr 30 16:57:34 1998 Michael Meissner <meissner@cygnus.com>
* haifa-sched.c (print_{exp,value}): Various changes to make the
debug output easier to read. Also, use only one buffer, and make
sure the buffer we are passed in doesn't overflow.
(safe_concat): Concatenate to a buffer without overflow.
Thu Apr 30 16:57:34 1998 Kaveh R. Ghazi" <ghazi@caip.rutgers.edu>
* haifa-sched.c (alloc_{INSN,EXPR}_LIST): Make static to agree
with the prototype.
Wed Apr 29 21:45:16 1998 J"orn Rennecke <amylaar@cygnus.co.uk> Wed Apr 29 21:45:16 1998 J"orn Rennecke <amylaar@cygnus.co.uk>
* sched.c (new_insn_dead_notes): Check if the register was * sched.c (new_insn_dead_notes): Check if the register was
......
gcc/haifa-sched.c
...@@ -473,6 +473,7 @@ static void split_hard_reg_notes PROTO ((rtx, rtx, rtx)); ...@@ -473,6 +473,7 @@ static void split_hard_reg_notes PROTO ((rtx, rtx, rtx));
static void new_insn_dead_notes PROTO ((rtx, rtx, rtx, rtx)); static void new_insn_dead_notes PROTO ((rtx, rtx, rtx, rtx));
static void update_n_sets PROTO ((rtx, int)); static void update_n_sets PROTO ((rtx, int));
static void update_flow_info PROTO ((rtx, rtx, rtx, rtx)); static void update_flow_info PROTO ((rtx, rtx, rtx, rtx));
static char *safe_concat PROTO ((char *, char *, char *));
/* Main entry point of this file. */ /* Main entry point of this file. */
void schedule_insns PROTO ((FILE *)); void schedule_insns PROTO ((FILE *));
...@@ -825,7 +826,7 @@ free_list (listp, unused_listp) ...@@ -825,7 +826,7 @@ free_list (listp, unused_listp)
*listp = 0; *listp = 0;
} }
rtx static rtx
alloc_INSN_LIST (val, next) alloc_INSN_LIST (val, next)
rtx val, next; rtx val, next;
{ {
...@@ -845,7 +846,7 @@ alloc_INSN_LIST (val, next) ...@@ -845,7 +846,7 @@ alloc_INSN_LIST (val, next)
return r; return r;
} }
rtx static rtx
alloc_EXPR_LIST (kind, val, next) alloc_EXPR_LIST (kind, val, next)
int kind; int kind;
rtx val, next; rtx val, next;
...@@ -5564,6 +5565,28 @@ init_block_visualization () ...@@ -5564,6 +5565,28 @@ init_block_visualization ()
#define BUF_LEN 256 #define BUF_LEN 256
static char *
safe_concat (buf, cur, str)
char *buf;
char *cur;
char *str;
{
char *end = buf + BUF_LEN - 2; /* leave room for null */
int c;
if (cur > end)
{
*end = '\0';
return end;
}
while (cur < end && (c = *str++) != '\0')
*cur++ = c;
*cur = '\0';
return cur;
}
/* This recognizes rtx, I classified as expressions. These are always */ /* This recognizes rtx, I classified as expressions. These are always */
/* represent some action on values or results of other expression, */ /* represent some action on values or results of other expression, */
/* that may be stored in objects representing values. */ /* that may be stored in objects representing values. */
...@@ -5574,331 +5597,334 @@ print_exp (buf, x, verbose) ...@@ -5574,331 +5597,334 @@ print_exp (buf, x, verbose)
rtx x; rtx x;
int verbose; int verbose;
{ {
char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN]; char tmp[BUF_LEN];
char *st[4];
char *cur = buf;
char *fun = (char *)0;
char *sep;
rtx op[4];
int i;
for (i = 0; i < 4; i++)
{
st[i] = (char *)0;
op[i] = NULL_RTX;
}
switch (GET_CODE (x)) switch (GET_CODE (x))
{ {
case PLUS: case PLUS:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "+";
sprintf (buf, "%s+%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case LO_SUM: case LO_SUM:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "+low(";
sprintf (buf, "%sl+%s", t1, t2); op[1] = XEXP (x, 1);
st[2] = ")";
break; break;
case MINUS: case MINUS:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "-";
sprintf (buf, "%s-%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case COMPARE: case COMPARE:
print_value (t1, XEXP (x, 0), verbose); fun = "cmp";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "%s??%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case NEG: case NEG:
print_value (t1, XEXP (x, 0), verbose); st[0] = "-";
sprintf (buf, "-%s", t1); op[0] = XEXP (x, 0);
break; break;
case MULT: case MULT:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "*";
sprintf (buf, "%s*%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case DIV: case DIV:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "/";
sprintf (buf, "%s/%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case UDIV: case UDIV:
print_value (t1, XEXP (x, 0), verbose); fun = "udiv";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "%su/%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case MOD: case MOD:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "%";
sprintf (buf, "%s%%%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case UMOD: case UMOD:
print_value (t1, XEXP (x, 0), verbose); fun = "umod";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "%su%%%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case SMIN: case SMIN:
print_value (t1, XEXP (x, 0), verbose); fun = "smin";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "smin (%s, %s)", t1, t2); op[1] = XEXP (x, 1);
break; break;
case SMAX: case SMAX:
print_value (t1, XEXP (x, 0), verbose); fun = "smax";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "smax(%s,%s)", t1, t2); op[1] = XEXP (x, 1);
break; break;
case UMIN: case UMIN:
print_value (t1, XEXP (x, 0), verbose); fun = "umin";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "umin (%s, %s)", t1, t2); op[1] = XEXP (x, 1);
break; break;
case UMAX: case UMAX:
print_value (t1, XEXP (x, 0), verbose); fun = "umax";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "umax(%s,%s)", t1, t2); op[1] = XEXP (x, 1);
break; break;
case NOT: case NOT:
print_value (t1, XEXP (x, 0), verbose); st[0] = "!";
sprintf (buf, "!%s", t1); op[0] = XEXP (x, 0);
break; break;
case AND: case AND:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "&";
sprintf (buf, "%s&%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case IOR: case IOR:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "|";
sprintf (buf, "%s|%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case XOR: case XOR:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "^";
sprintf (buf, "%s^%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case ASHIFT: case ASHIFT:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "<<";
sprintf (buf, "%s<<%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case LSHIFTRT: case LSHIFTRT:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = " 0>>";
sprintf (buf, "%s0>%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case ASHIFTRT: case ASHIFTRT:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = ">>";
sprintf (buf, "%s>>%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case ROTATE: case ROTATE:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "<-<";
sprintf (buf, "%s<-<%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case ROTATERT: case ROTATERT:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = ">->";
sprintf (buf, "%s>->%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case ABS: case ABS:
print_value (t1, XEXP (x, 0), verbose); fun = "abs";
sprintf (buf, "abs(%s)", t1); op[0] = XEXP (x, 0);
break; break;
case SQRT: case SQRT:
print_value (t1, XEXP (x, 0), verbose); fun = "sqrt";
sprintf (buf, "sqrt(%s)", t1); op[0] = XEXP (x, 0);
break; break;
case FFS: case FFS:
print_value (t1, XEXP (x, 0), verbose); fun = "ffs";
sprintf (buf, "ffs(%s)", t1); op[0] = XEXP (x, 0);
break; break;
case EQ: case EQ:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "==";
sprintf (buf, "%s == %s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case NE: case NE:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "!=";
sprintf (buf, "%s!=%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case GT: case GT:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = ">";
sprintf (buf, "%s>%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case GTU: case GTU:
print_value (t1, XEXP (x, 0), verbose); fun = "gtu";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "%s>u%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case LT: case LT:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "<";
sprintf (buf, "%s<%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case LTU: case LTU:
print_value (t1, XEXP (x, 0), verbose); fun = "ltu";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "%s<u%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case GE: case GE:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = ">=";
sprintf (buf, "%s>=%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case GEU: case GEU:
print_value (t1, XEXP (x, 0), verbose); fun = "geu";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "%s>=u%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case LE: case LE:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
print_value (t2, XEXP (x, 1), verbose); st[1] = "<=";
sprintf (buf, "%s<=%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case LEU: case LEU:
print_value (t1, XEXP (x, 0), verbose); fun = "leu";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "%s<=u%s", t1, t2); op[1] = XEXP (x, 1);
break; break;
case SIGN_EXTRACT: case SIGN_EXTRACT:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "sign_extract" : "sxt";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
print_value (t3, XEXP (x, 2), verbose); op[1] = XEXP (x, 1);
if (verbose) op[2] = XEXP (x, 2);
sprintf (buf, "sign_extract(%s,%s,%s)", t1, t2, t3);
else
sprintf (buf, "sxt(%s,%s,%s)", t1, t2, t3);
break; break;
case ZERO_EXTRACT: case ZERO_EXTRACT:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "zero_extract" : "zxt";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
print_value (t3, XEXP (x, 2), verbose); op[1] = XEXP (x, 1);
if (verbose) op[2] = XEXP (x, 2);
sprintf (buf, "zero_extract(%s,%s,%s)", t1, t2, t3);
else
sprintf (buf, "zxt(%s,%s,%s)", t1, t2, t3);
break; break;
case SIGN_EXTEND: case SIGN_EXTEND:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "sign_extend" : "sxn";
if (verbose) op[0] = XEXP (x, 0);
sprintf (buf, "sign_extend(%s)", t1);
else
sprintf (buf, "sxn(%s)", t1);
break; break;
case ZERO_EXTEND: case ZERO_EXTEND:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "zero_extend" : "zxn";
if (verbose) op[0] = XEXP (x, 0);
sprintf (buf, "zero_extend(%s)", t1);
else
sprintf (buf, "zxn(%s)", t1);
break; break;
case FLOAT_EXTEND: case FLOAT_EXTEND:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "float_extend" : "fxn";
if (verbose) op[0] = XEXP (x, 0);
sprintf (buf, "float_extend(%s)", t1);
else
sprintf (buf, "fxn(%s)", t1);
break; break;
case TRUNCATE: case TRUNCATE:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "trunc" : "trn";
if (verbose) op[0] = XEXP (x, 0);
sprintf (buf, "trunc(%s)", t1);
else
sprintf (buf, "trn(%s)", t1);
break; break;
case FLOAT_TRUNCATE: case FLOAT_TRUNCATE:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "float_trunc" : "ftr";
if (verbose) op[0] = XEXP (x, 0);
sprintf (buf, "float_trunc(%s)", t1);
else
sprintf (buf, "ftr(%s)", t1);
break; break;
case FLOAT: case FLOAT:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "float" : "flt";
if (verbose) op[0] = XEXP (x, 0);
sprintf (buf, "float(%s)", t1);
else
sprintf (buf, "flt(%s)", t1);
break; break;
case UNSIGNED_FLOAT: case UNSIGNED_FLOAT:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "uns_float" : "ufl";
if (verbose) op[0] = XEXP (x, 0);
sprintf (buf, "uns_float(%s)", t1);
else
sprintf (buf, "ufl(%s)", t1);
break; break;
case FIX: case FIX:
print_value (t1, XEXP (x, 0), verbose); fun = "fix";
sprintf (buf, "fix(%s)", t1); op[0] = XEXP (x, 0);
break; break;
case UNSIGNED_FIX: case UNSIGNED_FIX:
print_value (t1, XEXP (x, 0), verbose); fun = (verbose) ? "uns_fix" : "ufx";
if (verbose) op[0] = XEXP (x, 0);
sprintf (buf, "uns_fix(%s)", t1);
else
sprintf (buf, "ufx(%s)", t1);
break; break;
case PRE_DEC: case PRE_DEC:
print_value (t1, XEXP (x, 0), verbose); st[0] = "--";
sprintf (buf, "--%s", t1); op[0] = XEXP (x, 0);
break; break;
case PRE_INC: case PRE_INC:
print_value (t1, XEXP (x, 0), verbose); st[0] = "++";
sprintf (buf, "++%s", t1); op[0] = XEXP (x, 0);
break; break;
case POST_DEC: case POST_DEC:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "%s--", t1); st[1] = "--";
break; break;
case POST_INC: case POST_INC:
print_value (t1, XEXP (x, 0), verbose); op[0] = XEXP (x, 0);
sprintf (buf, "%s++", t1); st[1] = "++";
break; break;
case CALL: case CALL:
print_value (t1, XEXP (x, 0), verbose); st[0] = "call ";
op[0] = XEXP (x, 0);
if (verbose) if (verbose)
{ {
print_value (t2, XEXP (x, 1), verbose); st[1] = " argc:";
sprintf (buf, "call %s argc:%s", t1, t2); op[1] = XEXP (x, 1);
} }
else
sprintf (buf, "call %s", t1);
break; break;
case IF_THEN_ELSE: case IF_THEN_ELSE:
print_exp (t1, XEXP (x, 0), verbose); st[0] = "{(";
print_value (t2, XEXP (x, 1), verbose); op[0] = XEXP (x, 0);
print_value (t3, XEXP (x, 2), verbose); st[1] = ")?";
sprintf (buf, "{(%s)?%s:%s}", t1, t2, t3); op[1] = XEXP (x, 1);
st[2] = ":";
op[2] = XEXP (x, 2);
st[3] = "}";
break; break;
case TRAP_IF: case TRAP_IF:
print_value (t1, TRAP_CONDITION (x), verbose); fun = "trap_if";
sprintf (buf, "trap_if %s", t1); op[0] = TRAP_CONDITION (x);
break; break;
case UNSPEC: case UNSPEC:
case UNSPEC_VOLATILE:
{ {
int i; cur = safe_concat (buf, cur, "unspec");
if (GET_CODE (x) == UNSPEC_VOLATILE)
sprintf (t1, "unspec{"); cur = safe_concat (buf, cur, "/v");
cur = safe_concat (buf, cur, "[");
sep = "";
for (i = 0; i < XVECLEN (x, 0); i++) for (i = 0; i < XVECLEN (x, 0); i++)
{ {
print_pattern (t2, XVECEXP (x, 0, i), verbose); print_pattern (tmp, XVECEXP (x, 0, i), verbose);
sprintf (t3, "%s%s;", t1, t2); cur = safe_concat (buf, cur, sep);
strcpy (t1, t3); cur = safe_concat (buf, cur, tmp);
sep = ",";
} }
sprintf (buf, "%s}", t1); cur = safe_concat (buf, cur, "] ");
sprintf (tmp, "%d", XINT (x, 1));
cur = safe_concat (buf, cur, tmp);
} }
break; break;
case UNSPEC_VOLATILE: default:
/* if (verbose) debug_rtx (x); */
st[0] = GET_RTX_NAME (x);
break;
}
/* Print this as a function? */
if (fun)
{ {
int i; cur = safe_concat (buf, cur, fun);
cur = safe_concat (buf, cur, "(");
}
sprintf (t1, "unspec/v{"); for (i = 0; i < 4; i++)
for (i = 0; i < XVECLEN (x, 0); i++)
{ {
print_pattern (t2, XVECEXP (x, 0, i), verbose); if (st[i])
sprintf (t3, "%s%s;", t1, t2); cur = safe_concat (buf, cur, st[i]);
strcpy (t1, t3);
if (op[i])
{
if (fun && i != 0)
cur = safe_concat (buf, cur, ",");
print_value (tmp, op[i], verbose);
cur = safe_concat (buf, cur, tmp);
} }
sprintf (buf, "%s}", t1);
}
break;
default:
/* if (verbose) debug_rtx (x); else sprintf (buf, "$$$"); */
sprintf (buf, "$$$");
} }
if (fun)
cur = safe_concat (buf, cur, ")");
} /* print_exp */ } /* print_exp */
/* Prints rtxes, i customly classified as values. They're constants, */ /* Prints rtxes, i customly classified as values. They're constants, */
...@@ -5911,60 +5937,84 @@ print_value (buf, x, verbose) ...@@ -5911,60 +5937,84 @@ print_value (buf, x, verbose)
int verbose; int verbose;
{ {
char t[BUF_LEN]; char t[BUF_LEN];
char *cur = buf;
switch (GET_CODE (x)) switch (GET_CODE (x))
{ {
case CONST_INT: case CONST_INT:
sprintf (buf, "%Xh", INTVAL (x)); sprintf (t, "0x%lx", (long)INTVAL (x));
cur = safe_concat (buf, cur, t);
break; break;
case CONST_DOUBLE: case CONST_DOUBLE:
print_value (t, XEXP (x, 0), verbose); sprintf (t, "<0x%lx,0x%lx>", (long)XWINT (x, 2), (long)XWINT (x, 3));
sprintf (buf, "<%s>", t); cur = safe_concat (buf, cur, t);
break; break;
case CONST_STRING: case CONST_STRING:
sprintf (buf, "\"%s\"", (char *) XEXP (x, 0)); cur = safe_concat (buf, cur, "\"");
cur = safe_concat (buf, cur, XSTR (x, 0));
cur = safe_concat (buf, cur, "\"");
break; break;
case SYMBOL_REF: case SYMBOL_REF:
sprintf (buf, "`%s'", (char *) XEXP (x, 0)); cur = safe_concat (buf, cur, "`");
cur = safe_concat (buf, cur, XSTR (x, 0));
cur = safe_concat (buf, cur, "'");
break; break;
case LABEL_REF: case LABEL_REF:
sprintf (buf, "L%d", INSN_UID (XEXP (x, 0))); sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
cur = safe_concat (buf, cur, t);
break; break;
case CONST: case CONST:
print_value (buf, XEXP (x, 0), verbose); print_value (t, XEXP (x, 0), verbose);
cur = safe_concat (buf, cur, "const(");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, ")");
break; break;
case HIGH: case HIGH:
print_value (buf, XEXP (x, 0), verbose); print_value (t, XEXP (x, 0), verbose);
cur = safe_concat (buf, cur, "high(");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, ")");
break; break;
case REG: case REG:
if (GET_MODE (x) == SFmode if (REGNO (x) < FIRST_PSEUDO_REGISTER)
|| GET_MODE (x) == DFmode {
|| GET_MODE (x) == XFmode int c = reg_names[ REGNO (x) ][0];
|| GET_MODE (x) == TFmode) if (c >= '0' && c <= '9')
strcpy (t, "fr"); cur = safe_concat (buf, cur, "%");
cur = safe_concat (buf, cur, reg_names[ REGNO (x) ]);
}
else else
strcpy (t, "r"); {
sprintf (buf, "%s%d", t, REGNO (x)); sprintf (t, "r%d", REGNO (x));
cur = safe_concat (buf, cur, t);
}
break; break;
case SUBREG: case SUBREG:
print_value (t, XEXP (x, 0), verbose); print_value (t, SUBREG_REG (x), verbose);
sprintf (buf, "%s#%d", t, SUBREG_WORD (x)); cur = safe_concat (buf, cur, t);
sprintf (t, "#%d", t, SUBREG_WORD (x));
cur = safe_concat (buf, cur, t);
break; break;
case SCRATCH: case SCRATCH:
sprintf (buf, "scratch"); cur = safe_concat (buf, cur, "scratch");
break; break;
case CC0: case CC0:
sprintf (buf, "cc0"); cur = safe_concat (buf, cur, "cc0");
break; break;
case PC: case PC:
sprintf (buf, "pc"); cur = safe_concat (buf, cur, "pc");
break; break;
case MEM: case MEM:
print_value (t, XEXP (x, 0), verbose); print_value (t, XEXP (x, 0), verbose);
sprintf (buf, "[%s]", t); cur = safe_concat (buf, cur, "[");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, "]");
break; break;
default: default:
print_exp (buf, x, verbose); print_exp (t, x, verbose);
cur = safe_concat (buf, cur, t);
break;
} }
} /* print_value */ } /* print_value */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment