Skip to content

R
riscv-gcc-1
Commit 984ad2c6 by Per Bothner Committed by Per Bothner
Options

Various patches to emit better messages on verification errors. 

From-SVN: r39019
parent 150d3c00
Showing with 171 additions and 78 deletions
gcc/java/ChangeLog
2001-01-14 Per Bothner <per@bothner.com>
Various patches to emit better messages on verification errors.
* expr.c (push_type_0): Return error indication on stack overflow,
instead of callinfg fatal.
(push_type): Now just call push_type_0 (nd fatal on overflow).
(pop_type_0): Return detailed error message (in a char** argument).
(pop_type): If pop_type_0 fails, print error message.
(pop_argument_types): Moved to verify.c.
* verify.c (pop_argument_types): Moved from expr.c.
Return a (possible) error message, rather than void.
(POP_TYPE, POP_TYPE_CONV, PUSH_TYPE, PUSH_PENDING): New macros.
(verify_jvm_instruction): Use new macros, improving error messages.
For case OPCODE_astore use object_ptr_type_node.
* java-tree.h (TYPE_UNDERFLOW, TYPE_UNEXPECTED): New macros.
(pop_type_0, push_type_0, pop_argument_types): Update accordingly.
* parse.y (java_complete_lhs case EXPR_WITH_FILE_LOCATION): If body is
constant, return body without wrapper. (Improves constant folding.)
* lex.c (build_wfl_node): Clear TREE_TYPE from returned node.
......
gcc/java/expr.c
......@@ -256,19 +256,31 @@ flush_quick_stack ()
}
}
void
push_type (type)
/* Push TYPE on the type stack.
Return true on success, 0 on overflow. */
int
push_type_0 (type)
tree type;
{
int n_words;
type = promote_type (type);
n_words = 1 + TYPE_IS_WIDE (type);
if (stack_pointer + n_words > DECL_MAX_STACK (current_function_decl))
fatal ("stack overflow");
return 0;
stack_type_map[stack_pointer++] = type;
n_words--;
while (--n_words >= 0)
stack_type_map[stack_pointer++] = TYPE_SECOND;
return 1;
}
void
push_type (type)
tree type;
{
if (! push_type_0 (type))
fatal ("stack overflow");
}
static void
......@@ -296,23 +308,32 @@ push_value (value)
/* Pop a type from the type stack.
TYPE is the expected type. Return the actual type, which must be
convertible to TYPE, otherwise NULL_TREE is returned. */
convertible to TYPE.
On an error, *MESSAGEP is set to a freshly malloc'd error message. */
tree
pop_type_0 (type)
pop_type_0 (type, messagep)
tree type;
char **messagep;
{
int n_words;
tree t;
*messagep = NULL;
if (TREE_CODE (type) == RECORD_TYPE)
type = promote_type (type);
n_words = 1 + TYPE_IS_WIDE (type);
if (stack_pointer < n_words)
fatal ("stack underflow");
{
*messagep = xstrdup ("stack underflow");
return type;
}
while (--n_words > 0)
{
if (stack_type_map[--stack_pointer] != void_type_node)
fatal ("Invalid multi-word value on type stack");
{
*messagep = xstrdup ("Invalid multi-word value on type stack");
return type;
}
}
t = stack_type_map[--stack_pointer];
if (type == NULL_TREE || t == type)
......@@ -334,7 +355,24 @@ pop_type_0 (type)
/* FIXME: this is worse than a kludge, probably. */
return object_ptr_type_node;
}
return NULL_TREE;
{
const char *str1 = "expected type '";
const char *str3 = "' but stack contains '";
const char *str5 = "'";
int len1 = strlen (str1);
int len2 = strlen (lang_printable_name (type, 0));
int len3 = strlen (str3);
int len4 = strlen (lang_printable_name (t, 0));
int len5 = strlen (str5);
char *msg = xmalloc (len1 + len2 + len3 + len4 + len5 + 1);
*messagep = msg;
strcpy (msg, str1); msg += len1;
strcpy (msg, lang_printable_name (type, 0)); msg += len2;
strcpy (msg, str3); msg += len3;
strcpy (msg, lang_printable_name (t, 0)); msg += len4;
strcpy (msg, str5);
return type;
}
}
/* Pop a type from the type stack.
......@@ -345,10 +383,13 @@ tree
pop_type (type)
tree type;
{
tree t = pop_type_0 (type);
if (t != NULL_TREE)
return t;
error ("unexpected type on stack");
char *message = NULL;
type = pop_type_0 (type, &message);
if (message != NULL)
{
error (message);
free (message);
}
return type;
}
......@@ -1576,23 +1617,6 @@ expand_java_ret (return_address)
}
#endif
/* Recursive helper function to pop argument types during verifiation. */
void
pop_argument_types (arg_types)
tree arg_types;
{
if (arg_types == end_params_node)
return;
if (TREE_CODE (arg_types) == TREE_LIST)
{
pop_argument_types (TREE_CHAIN (arg_types));
pop_type (TREE_VALUE (arg_types));
return;
}
abort ();
}
static tree
pop_arguments (arg_types)
tree arg_types;
......
gcc/java/java-tree.h
......@@ -978,9 +978,8 @@ extern tree build_java_array_type PARAMS ((tree, HOST_WIDE_INT));
extern int is_compiled_class PARAMS ((tree));
extern tree mangled_classname PARAMS ((const char*, tree));
extern tree lookup_label PARAMS ((int));
extern tree pop_type_0 PARAMS ((tree));
extern tree pop_type_0 PARAMS ((tree, char**));
extern tree pop_type PARAMS ((tree));
extern void pop_argument_types PARAMS ((tree));
extern tree decode_newarray_type PARAMS ((int));
extern tree lookup_field PARAMS ((tree*, tree));
extern int is_array_type_p PARAMS ((tree));
......@@ -1057,6 +1056,7 @@ extern int process_jvm_instruction PARAMS ((int, const unsigned char *, long));
extern int maybe_adjust_start_pc PARAMS ((struct JCF *, int, int, int));
extern void set_local_type PARAMS ((int, tree));
extern int merge_type_state PARAMS ((tree));
extern int push_type_0 PARAMS ((tree));
extern void push_type PARAMS ((tree));
extern void load_type_state PARAMS ((tree));
extern void add_interface PARAMS ((tree, tree));
......@@ -1244,6 +1244,12 @@ extern int linenumber_count;
used nor set in the subroutine. */
#define TYPE_UNUSED error_mark_node
/* When returned from pop_type_0, indicates stack underflow. */
#define TYPE_UNDERFLOW integer_zero_node
/* When returned from pop_type_0, indicates a type mismatch. */
#define TYPE_UNEXPECTED NULL_TREE
/* A array mapping variable/stack slot index to the type current
in that variable/stack slot.
TYPE_UNKNOWN, TYPE_SECOND, and TYPE_NULL are special cases. */
......
gcc/java/verify.c
......@@ -348,9 +348,43 @@ start_pc_cmp (xp, yp)
#define VERIFICATION_ERROR(MESSAGE) \
do { message = MESSAGE; goto verify_error; } while (0)
/* Recursive helper function to pop argument types during verifiation.
ARG_TYPES is the list of formal parameter types.
Return NULL on success and a freshly malloc'd error message on failure. */
static char *
pop_argument_types (arg_types)
tree arg_types;
{
if (arg_types == end_params_node)
return NULL;
if (TREE_CODE (arg_types) == TREE_LIST)
{
char *message = pop_argument_types (TREE_CHAIN (arg_types));
if (message == NULL)
pop_type_0 (TREE_VALUE (arg_types), &message);
return message;
}
abort ();
}
#define POP_TYPE(TYPE, MESSAGE) \
do { pmessage = NULL; pop_type_0 (TYPE, &pmessage); \
if (pmessage != NULL) goto pop_type_error; \
} while (0)
#define POP_TYPE_CONV(TYPE, POPPED_TYPE, MESSAGE) \
do { pmessage = NULL; POPPED_TYPE = pop_type_0 (TYPE, &pmessage); \
if (pmessage != NULL) goto pop_type_error; \
} while (0)
#define PUSH_TYPE(TYPE) \
do { if (! push_type_0 (TYPE)) { goto stack_overflow; }} while (0)
#define PUSH_PENDING(LABEL) \
do { if ((message = check_pending_block (LABEL)) != NULL) \
goto verify_error; } while (0)
do { tree tmplab = LABEL; \
if ((message = check_pending_block (tmplab)) != NULL) \
{ oldpc = LABEL_PC (tmplab); goto verify_error; }} while (0)
#ifdef __GNUC__
#define CHECK_PC_IN_RANGE(PC) ({if (PC < 0 || PC > length) goto bad_pc; (void)1;})
......@@ -376,6 +410,7 @@ verify_jvm_instructions (jcf, byte_ops, length)
int oldpc = 0; /* PC of start of instruction. */
int prevpc = 0; /* If >= 0, PC of previous instruction. */
const char *message;
char *pmessage;
int i;
register unsigned char *p;
struct eh_range *prev_eh_ranges = NULL_EH_RANGE;
......@@ -559,13 +594,13 @@ verify_jvm_instructions (jcf, byte_ops, length)
if (byte_ops[PC] == OPCODE_newarray
|| byte_ops[PC] == OPCODE_newarray)
int_value = i;
push_type (int_type_node); break;
PUSH_TYPE (int_type_node); break;
case OPCODE_lconst_0: case OPCODE_lconst_1:
push_type (long_type_node); break;
PUSH_TYPE (long_type_node); break;
case OPCODE_fconst_0: case OPCODE_fconst_1: case OPCODE_fconst_2:
push_type (float_type_node); break;
PUSH_TYPE (float_type_node); break;
case OPCODE_dconst_0: case OPCODE_dconst_1:
push_type (double_type_node); break;
PUSH_TYPE (double_type_node); break;
case OPCODE_bipush:
i = IMMEDIATE_s1;
goto push_int;
......@@ -616,13 +651,13 @@ verify_jvm_instructions (jcf, byte_ops, length)
? (! INTEGRAL_TYPE_P (tmp) || TYPE_PRECISION (tmp) > 32)
: type != tmp))
VERIFICATION_ERROR("invalid local variable type in load");
push_type (tmp);
PUSH_TYPE (tmp);
goto note_used;
case OPCODE_istore: type = int_type_node; goto general_store;
case OPCODE_lstore: type = long_type_node; goto general_store;
case OPCODE_fstore: type = float_type_node; goto general_store;
case OPCODE_dstore: type = double_type_node; goto general_store;
case OPCODE_astore: type = ptr_type_node; goto general_store;
case OPCODE_astore: type = object_ptr_type_node; goto general_store;
general_store:
index = wide ? IMMEDIATE_u2 : IMMEDIATE_u1;
wide = 0;
......@@ -655,7 +690,7 @@ verify_jvm_instructions (jcf, byte_ops, length)
VERIFICATION_ERROR ("invalid local variable index in store");
return 0;
}
type = pop_type (type);
POP_TYPE_CONV (type, type, NULL);
type_map[index] = type;
/* If local variable changed, we need to reconsider eh handlers. */
......@@ -723,19 +758,19 @@ verify_jvm_instructions (jcf, byte_ops, length)
type = double_type_node; goto unop;
unop:
pop_type (type);
push_type (type);
PUSH_TYPE (type);
break;
binop:
pop_type (type);
pop_type (type);
push_type (type);
PUSH_TYPE (type);
break;
case OPCODE_lshl:
case OPCODE_lshr:
case OPCODE_lushr:
pop_type (int_type_node);
pop_type (long_type_node);
push_type (long_type_node);
PUSH_TYPE (long_type_node);
break;
case OPCODE_iinc:
index = wide ? IMMEDIATE_u2 : IMMEDIATE_u1;
......@@ -744,33 +779,34 @@ verify_jvm_instructions (jcf, byte_ops, length)
if (index < 0 || index >= DECL_MAX_LOCALS (current_function_decl))
VERIFICATION_ERROR ("invalid local variable index in iinc");
tmp = type_map[index];
if (! INTEGRAL_TYPE_P (tmp) || TYPE_PRECISION (tmp) > 32)
if (tmp == NULL_TREE
|| ! INTEGRAL_TYPE_P (tmp) || TYPE_PRECISION (tmp) > 32)
VERIFICATION_ERROR ("invalid local variable type in iinc");
break;
case OPCODE_i2l:
pop_type (int_type_node); push_type (long_type_node); break;
pop_type (int_type_node); PUSH_TYPE (long_type_node); break;
case OPCODE_i2f:
pop_type (int_type_node); push_type (float_type_node); break;
pop_type (int_type_node); PUSH_TYPE (float_type_node); break;
case OPCODE_i2d:
pop_type (int_type_node); push_type (double_type_node); break;
pop_type (int_type_node); PUSH_TYPE (double_type_node); break;
case OPCODE_l2i:
pop_type (long_type_node); push_type (int_type_node); break;
pop_type (long_type_node); PUSH_TYPE (int_type_node); break;
case OPCODE_l2f:
pop_type (long_type_node); push_type (float_type_node); break;
pop_type (long_type_node); PUSH_TYPE (float_type_node); break;
case OPCODE_l2d:
pop_type (long_type_node); push_type (double_type_node); break;
pop_type (long_type_node); PUSH_TYPE (double_type_node); break;
case OPCODE_f2i:
pop_type (float_type_node); push_type (int_type_node); break;
pop_type (float_type_node); PUSH_TYPE (int_type_node); break;
case OPCODE_f2l:
pop_type (float_type_node); push_type (long_type_node); break;
pop_type (float_type_node); PUSH_TYPE (long_type_node); break;
case OPCODE_f2d:
pop_type (float_type_node); push_type (double_type_node); break;
pop_type (float_type_node); PUSH_TYPE (double_type_node); break;
case OPCODE_d2i:
pop_type (double_type_node); push_type (int_type_node); break;
pop_type (double_type_node); PUSH_TYPE (int_type_node); break;
case OPCODE_d2l:
pop_type (double_type_node); push_type (long_type_node); break;
pop_type (double_type_node); PUSH_TYPE (long_type_node); break;
case OPCODE_d2f:
pop_type (double_type_node); push_type (float_type_node); break;
pop_type (double_type_node); PUSH_TYPE (float_type_node); break;
case OPCODE_lcmp:
type = long_type_node; goto compare;
case OPCODE_fcmpl:
......@@ -781,7 +817,7 @@ verify_jvm_instructions (jcf, byte_ops, length)
type = double_type_node; goto compare;
compare:
pop_type (type); pop_type (type);
push_type (int_type_node); break;
PUSH_TYPE (int_type_node); break;
case OPCODE_ifeq:
case OPCODE_ifne:
case OPCODE_iflt:
......@@ -848,10 +884,7 @@ verify_jvm_instructions (jcf, byte_ops, length)
if (type != return_type)
VERIFICATION_ERROR ("incorrect ?return opcode");
if (type != void_type_node)
{
if (pop_type_0 (type) == NULL_TREE)
VERIFICATION_ERROR ("return value has wrong type");
}
POP_TYPE(type, "return value has wrong type");
INVALIDATE_PC;
break;
case OPCODE_getstatic: is_putting = 0; is_static = 1; goto field;
......@@ -864,22 +897,21 @@ verify_jvm_instructions (jcf, byte_ops, length)
tree field_signature = COMPONENT_REF_SIGNATURE (&current_jcf->cpool, index);
tree field_type = get_type_from_signature (field_signature);
if (is_putting)
pop_type (field_type);
POP_TYPE (field_type, "incorrect type for field");
if (! is_static)
{
int clindex = COMPONENT_REF_CLASS_INDEX (&current_jcf->cpool,
index);
tree self_type = get_class_constant (current_jcf, clindex);
/* Defer actual checking until next pass. */
if (pop_type_0 (self_type) == NULL_TREE)
VERIFICATION_ERROR ("incorrect type for field reference");
POP_TYPE(self_type, "incorrect type for field reference");
}
if (! is_putting)
push_type (field_type);
PUSH_TYPE (field_type);
break;
}
case OPCODE_new:
push_type (get_class_constant (jcf, IMMEDIATE_u2));
PUSH_TYPE (get_class_constant (jcf, IMMEDIATE_u2));
break;
case OPCODE_dup: type_stack_dup (1, 0); break;
case OPCODE_dup_x1: type_stack_dup (1, 1); break;
......@@ -934,7 +966,7 @@ verify_jvm_instructions (jcf, byte_ops, length)
i = TREE_INT_CST_LOW (get_constant (current_jcf, index));
goto push_int;
}
push_type (type);
PUSH_TYPE (type);
break;
case OPCODE_invokevirtual:
......@@ -953,7 +985,12 @@ verify_jvm_instructions (jcf, byte_ops, length)
IDENTIFIER_LENGTH (sig));
if (TREE_CODE (method_type) != FUNCTION_TYPE)
VERIFICATION_ERROR ("bad method signature");
pop_argument_types (TYPE_ARG_TYPES (method_type));
pmessage = pop_argument_types (TYPE_ARG_TYPES (method_type));
if (pmessage != NULL)
{
message = "invalid argument type";
goto pop_type_error;
}
/* Can't invoke <clinit> */
if (ID_CLINIT_P (method_name))
......@@ -963,7 +1000,8 @@ verify_jvm_instructions (jcf, byte_ops, length)
VERIFICATION_ERROR ("invoke opcode can't invoke <init>");
if (op_code != OPCODE_invokestatic)
pop_type (self_type);
POP_TYPE (self_type,
"stack type not subclass of invoked method's class");
switch (op_code)
{
......@@ -980,14 +1018,14 @@ verify_jvm_instructions (jcf, byte_ops, length)
}
if (TREE_TYPE (method_type) != void_type_node)
push_type (TREE_TYPE (method_type));
PUSH_TYPE (TREE_TYPE (method_type));
break;
}
case OPCODE_arraylength:
/* Type checking actually made during code generation */
pop_type( ptr_type_node );
push_type( int_type_node );
PUSH_TYPE( int_type_node );
break;
/* Q&D verification *or* more checking done during code generation
......@@ -1025,7 +1063,7 @@ verify_jvm_instructions (jcf, byte_ops, length)
type = TYPE_ARRAY_ELEMENT (TREE_TYPE (tmp));
else if (tmp != TYPE_NULL)
VERIFICATION_ERROR ("array load from non-array type");
push_type (type);
PUSH_TYPE (type);
break;
case OPCODE_anewarray:
......@@ -1061,7 +1099,7 @@ verify_jvm_instructions (jcf, byte_ops, length)
int_value = -1;
type = build_java_array_type (type, int_value);
pop_type (int_type_node);
push_type (type);
PUSH_TYPE (type);
break;
case OPCODE_multianewarray:
......@@ -1075,12 +1113,12 @@ verify_jvm_instructions (jcf, byte_ops, length)
for( i = 0; i < ndim; i++ )
pop_type (int_type_node);
push_type (get_class_constant (current_jcf, index));
PUSH_TYPE (get_class_constant (current_jcf, index));
break;
}
case OPCODE_aconst_null:
push_type (ptr_type_node);
PUSH_TYPE (ptr_type_node);
break;
case OPCODE_athrow:
......@@ -1092,12 +1130,12 @@ verify_jvm_instructions (jcf, byte_ops, length)
case OPCODE_checkcast:
pop_type (ptr_type_node);
type = get_class_constant (current_jcf, IMMEDIATE_u2);
push_type (type);
PUSH_TYPE (type);
break;
case OPCODE_instanceof:
pop_type (ptr_type_node);
get_class_constant (current_jcf, IMMEDIATE_u2);
push_type (int_type_node);
PUSH_TYPE (int_type_node);
break;
case OPCODE_tableswitch:
......@@ -1170,7 +1208,7 @@ verify_jvm_instructions (jcf, byte_ops, length)
{
tree target = lookup_label (oldpc + IMMEDIATE_s2);
tree return_label = lookup_label (PC);
push_type (return_address_type_node);
PUSH_TYPE (return_address_type_node);
/* The return label chain will be null if this is the first
time we've seen this jsr target. */
if (LABEL_RETURN_LABEL (target) == NULL_TREE)
......@@ -1358,6 +1396,16 @@ verify_jvm_instructions (jcf, byte_ops, length)
}
}
return 1;
pop_type_error:
error ("verification error at PC=%d", oldpc);
if (message != NULL)
error ("%s", message);
error ("%s", pmessage);
free (pmessage);
return 0;
stack_overflow:
message = "stack overflow";
goto verify_error;
bad_pc:
message = "program counter out of range";
goto verify_error;
......
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