// * at least one GC problem :-(
-// This is global because __attribute__ doesn't seem to work on static
-// methods.
-static void verify_fail (char *msg, jint pc = -1)
- __attribute__ ((__noreturn__));
-
static void debug_print (const char *fmt, ...)
__attribute__ ((format (printf, 1, 2)));
// Return the type_val corresponding to a primitive signature
// character. For instance `I' returns `int.class'.
- static type_val get_type_val_for_signature (jchar sig)
+ type_val get_type_val_for_signature (jchar sig)
{
type_val rt;
switch (sig)
}
// Return the type_val corresponding to a primitive class.
- static type_val get_type_val_for_signature (jclass k)
+ type_val get_type_val_for_signature (jclass k)
{
return get_type_val_for_signature ((jchar) k->method_count);
}
}
// If *THIS is an unresolved reference type, resolve it.
- void resolve ()
+ void resolve (_Jv_BytecodeVerifier *verifier)
{
if (key != unresolved_reference_type
&& key != uninitialized_unresolved_reference_type)
return;
- // FIXME: class loader
using namespace java::lang;
+ java::lang::ClassLoader *loader
+ = verifier->current_class->getClassLoader();
// We might see either kind of name. Sigh.
if (data.name->data[0] == 'L'
&& data.name->data[data.name->length - 1] == ';')
- data.klass = _Jv_FindClassFromSignature (data.name->data, NULL);
+ data.klass = _Jv_FindClassFromSignature (data.name->data, loader);
else
data.klass = Class::forName (_Jv_NewStringUtf8Const (data.name),
- false, NULL);
+ false, loader);
key = (key == unresolved_reference_type
? reference_type
: uninitialized_reference_type);
}
// Mark this type as the uninitialized result of `new'.
- void set_uninitialized (int npc)
+ void set_uninitialized (int npc, _Jv_BytecodeVerifier *verifier)
{
if (key == reference_type)
key = uninitialized_reference_type;
else if (key == unresolved_reference_type)
key = uninitialized_unresolved_reference_type;
else
- verify_fail ("internal error in type::uninitialized");
+ verifier->verify_fail ("internal error in type::uninitialized");
pc = npc;
}
// of type *THIS. Handle various special cases too. Might modify
// *THIS or K. Note however that this does not perform numeric
// promotion.
- bool compatible (type &k)
+ bool compatible (type &k, _Jv_BytecodeVerifier *verifier)
{
// Any type is compatible with the unsuitable type.
if (key == unsuitable_type)
return true;
// We must resolve both types and check assignability.
- resolve ();
- k.resolve ();
+ resolve (verifier);
+ k.resolve (verifier);
return is_assignable_from_slow (data.klass, k.data.klass);
}
return false;
}
- bool isinterface ()
+ bool isinterface (_Jv_BytecodeVerifier *verifier)
{
- resolve ();
+ resolve (verifier);
if (key != reference_type)
return false;
return data.klass->isInterface ();
}
- bool isabstract ()
+ bool isabstract (_Jv_BytecodeVerifier *verifier)
{
- resolve ();
+ resolve (verifier);
if (key != reference_type)
return false;
using namespace java::lang::reflect;
}
// Return the element type of an array.
- type element_type ()
+ type element_type (_Jv_BytecodeVerifier *verifier)
{
// FIXME: maybe should do string manipulation here.
- resolve ();
+ resolve (verifier);
if (key != reference_type)
- verify_fail ("programmer error in type::element_type()");
+ verifier->verify_fail ("programmer error in type::element_type()", -1);
jclass k = data.klass->getComponentType ();
if (k->isPrimitive ())
- return type (get_type_val_for_signature (k));
+ return type (verifier->get_type_val_for_signature (k));
return type (k);
}
// Return the array type corresponding to an initialized
// reference. We could expand this to work for other kinds of
// types, but currently we don't need to.
- type to_array ()
+ type to_array (_Jv_BytecodeVerifier *verifier)
{
// Resolving isn't ideal, because it might force us to load
// another class, but it's easy. FIXME?
if (key == unresolved_reference_type)
- resolve ();
+ resolve (verifier);
if (key == reference_type)
return type (_Jv_GetArrayClass (data.klass,
data.klass->getClassLoader ()));
else
- verify_fail ("internal error in type::to_array()");
+ verifier->verify_fail ("internal error in type::to_array()");
}
bool isreference () const
|| key == uninitialized_reference_type);
}
- void verify_dimensions (int ndims)
+ void verify_dimensions (int ndims, _Jv_BytecodeVerifier *verifier)
{
// The way this is written, we don't need to check isarray().
if (key == reference_type)
}
if (ndims > 0)
- verify_fail ("array type has fewer dimensions than required");
+ verifier->verify_fail ("array type has fewer dimensions than required");
}
// Merge OLD_TYPE into this. On error throw exception.
- bool merge (type& old_type, bool local_semantics = false)
+ bool merge (type& old_type, bool local_semantics, _Jv_BytecodeVerifier *verifier)
{
bool changed = false;
bool refo = old_type.isreference ();
changed = true;
}
else if (isinitialized () != old_type.isinitialized ())
- verify_fail ("merging initialized and uninitialized types");
+ verifier->verify_fail ("merging initialized and uninitialized types");
else
{
if (! isinitialized ())
else if (old_type.pc == UNINIT)
;
else if (pc != old_type.pc)
- verify_fail ("merging different uninitialized types");
+ verifier->verify_fail ("merging different uninitialized types");
}
if (! isresolved ()
}
else
{
- resolve ();
- old_type.resolve ();
+ resolve (verifier);
+ old_type.resolve (verifier);
jclass k = data.klass;
jclass oldk = old_type.data.klass;
}
}
else
- verify_fail ("unmergeable type");
+ verifier->verify_fail ("unmergeable type");
}
return changed;
}
// state. Returns true if the new state was in fact changed.
// Will throw an exception if the states are not mergeable.
bool merge (state *state_old, bool ret_semantics,
- int max_locals)
+ int max_locals, _Jv_BytecodeVerifier *verifier)
{
bool changed = false;
changed = true;
}
else
- verify_fail ("subroutines merged");
+ verifier->verify_fail ("subroutines merged");
// Merge stacks.
if (state_old->stacktop != stacktop)
- verify_fail ("stack sizes differ");
+ verifier->verify_fail ("stack sizes differ");
for (int i = 0; i < state_old->stacktop; ++i)
{
- if (stack[i].merge (state_old->stack[i]))
+ if (stack[i].merge (state_old->stack[i], false, verifier))
changed = true;
}
{
if (! ret_semantics || local_changed[i])
{
- if (locals[i].merge (state_old->locals[i], true))
+ if (locals[i].merge (state_old->locals[i], true, verifier))
{
changed = true;
note_variable (i);
// whether we're using backwards-branch or exception-handing
// semantics.
void check_no_uninitialized_objects (int max_locals,
+ _Jv_BytecodeVerifier *verifier,
bool exception_semantics = false)
{
if (! exception_semantics)
{
for (int i = 0; i < stacktop; ++i)
if (stack[i].isreference () && ! stack[i].isinitialized ())
- verify_fail ("uninitialized object on stack");
+ verifier->verify_fail ("uninitialized object on stack");
}
for (int i = 0; i < max_locals; ++i)
if (locals[i].isreference () && ! locals[i].isinitialized ())
- verify_fail ("uninitialized object in local variable");
+ verifier->verify_fail ("uninitialized object in local variable");
- check_this_initialized ();
+ check_this_initialized (verifier);
}
// Ensure that `this' has been initialized.
- void check_this_initialized ()
+ void check_this_initialized (_Jv_BytecodeVerifier *verifier)
{
if (this_type.isreference () && ! this_type.isinitialized ())
- verify_fail ("`this' is uninitialized");
+ verifier->verify_fail ("`this' is uninitialized");
}
// Set type of `this'.
type pop_raw ()
{
if (current_state->stacktop <= 0)
- verify_fail ("stack empty", start_PC);
+ verify_fail ("stack empty");
type r = current_state->stack[--current_state->stacktop];
current_state->stackdepth -= r.depth ();
if (current_state->stackdepth < 0)
{
type r = pop_raw ();
if (r.iswide ())
- verify_fail ("narrow pop of wide type", start_PC);
+ verify_fail ("narrow pop of wide type");
return r;
}
{
type r = pop_raw ();
if (! r.iswide ())
- verify_fail ("wide pop of narrow type", start_PC);
+ verify_fail ("wide pop of narrow type");
return r;
}
{
match.promote ();
type t = pop_raw ();
- if (! match.compatible (t))
- verify_fail ("incompatible type on stack", start_PC);
+ if (! match.compatible (t, this))
+ verify_fail ("incompatible type on stack");
return t;
}
{
type t = pop_raw ();
if (! t.isreference () && t.key != return_address_type)
- verify_fail ("expected reference or return address on stack", start_PC);
+ verify_fail ("expected reference or return address on stack");
return t;
}
{
int depth = t.depth ();
if (index > current_method->max_locals - depth)
- verify_fail ("invalid local variable", start_PC);
- if (! t.compatible (current_state->locals[index]))
- verify_fail ("incompatible type in local variable", start_PC);
+ verify_fail ("invalid local variable");
+ if (! t.compatible (current_state->locals[index], this))
+ verify_fail ("incompatible type in local variable");
if (depth == 2)
{
type t (continuation_type);
- if (! current_state->locals[index + 1].compatible (t))
- verify_fail ("invalid local variable", start_PC);
+ if (! current_state->locals[index + 1].compatible (t, this))
+ verify_fail ("invalid local variable");
}
return current_state->locals[index];
}
if (! array.isarray ())
verify_fail ("array required");
- type t = array.element_type ();
- if (! element.compatible (t))
+ type t = array.element_type (this);
+ if (! element.compatible (t, this))
{
// Special case for byte arrays, which must also be boolean
// arrays.
if (element.key == byte_type)
{
type e2 (boolean_type);
- ok = e2.compatible (t);
+ ok = e2.compatible (t, this);
}
if (! ok)
verify_fail ("incompatible array element type");
states[npc]->print (" To", npc, current_method->max_stack,
current_method->max_locals);
changed = states[npc]->merge (nstate, ret_semantics,
- current_method->max_locals);
+ current_method->max_locals, this);
states[npc]->print ("New", npc, current_method->max_stack,
current_method->max_locals);
}
{
int npc = compute_jump (offset);
if (npc < PC)
- current_state->check_no_uninitialized_objects (current_method->max_locals);
+ current_state->check_no_uninitialized_objects (current_method->max_locals, this);
push_jump_merge (npc, current_state);
}
void push_exception_jump (type t, int pc)
{
current_state->check_no_uninitialized_objects (current_method->max_locals,
- true);
+ this, true);
state s (current_state, current_method->max_stack,
current_method->max_locals);
s.set_exception (t, current_method->max_stack);
// in the enclosing context.
current_state->subroutine = get_subroutine (subr->pc);
if (subr->pc < PC)
- current_state->check_no_uninitialized_objects (current_method->max_locals);
+ current_state->check_no_uninitialized_objects (current_method->max_locals, this);
push_jump_merge (subr->pc, current_state, true);
}
int npc = compute_jump (offset);
if (npc < PC)
- current_state->check_no_uninitialized_objects (current_method->max_locals);
+ current_state->check_no_uninitialized_objects (current_method->max_locals, this);
check_nonrecursive_call (current_state->subroutine, npc);
// Temporarily modify the current state so that it looks like we are
void check_return_type (type onstack)
{
type rt = compute_return_type (current_method->self->signature);
- if (! rt.compatible (onstack))
- verify_fail ("incompatible return type", start_PC);
+ if (! rt.compatible (onstack, this))
+ verify_fail ("incompatible return type");
}
// Initialize the stack for the new method. Returns true if this
type kurr (current_class);
if (_Jv_equalUtf8Consts (current_method->self->name, gcj::init_name))
{
- kurr.set_uninitialized (type::SELF);
+ kurr.set_uninitialized (type::SELF, this);
is_init = true;
}
set_variable (0, kurr);
current_state->print ("Cur", PC, current_method->max_stack,
current_method->max_locals);
if (! current_state->merge (states[PC], false,
- current_method->max_locals)
+ current_method->max_locals, this)
&& ! states[PC]->is_unmerged_ret_state (current_method->max_locals))
{
debug_print ("== Fall through optimization\n");
// We only need to check this when the return type is
// void, because all instance initializers return void.
if (this_is_init)
- current_state->check_this_initialized ();
+ current_state->check_this_initialized (this);
check_return_type (void_type);
invalidate_pc ();
break;
// `this' has not yet been initialized.
if (! current_state->this_type.isinitialized ()
&& current_state->this_type.pc == type::SELF)
- klass.set_uninitialized (type::SELF);
+ klass.set_uninitialized (type::SELF, this);
pop_type (klass);
}
break;
{
int nargs = get_byte ();
if (nargs == 0)
- verify_fail ("too few arguments to invokeinterface",
- start_PC);
+ verify_fail ("too few arguments to invokeinterface");
if (get_byte () != 0)
- verify_fail ("invokeinterface dummy byte is wrong",
- start_PC);
+ verify_fail ("invokeinterface dummy byte is wrong");
if (nargs - 1 != arg_count)
- verify_fail ("wrong argument count for invokeinterface",
- start_PC);
+ verify_fail ("wrong argument count for invokeinterface");
}
bool is_init = false;
{
is_init = true;
if (opcode != op_invokespecial)
- verify_fail ("can't invoke <init>", start_PC);
+ verify_fail ("can't invoke <init>");
}
else if (method_name->data[0] == '<')
- verify_fail ("can't invoke method starting with `<'",
- start_PC);
+ verify_fail ("can't invoke method starting with `<'");
// Pop arguments and check types.
type arg_types[arg_count];
if (is_init)
{
// In this case the PC doesn't matter.
- t.set_uninitialized (type::UNINIT);
+ t.set_uninitialized (type::UNINIT, this);
}
t = pop_type (t);
if (is_init)
case op_new:
{
type t = check_class_constant (get_ushort ());
- if (t.isarray () || t.isinterface () || t.isabstract ())
- verify_fail ("type is array, interface, or abstract",
- start_PC);
- t.set_uninitialized (start_PC);
+ if (t.isarray () || t.isinterface (this) || t.isabstract (this))
+ verify_fail ("type is array, interface, or abstract");
+ t.set_uninitialized (start_PC, this);
push_type (t);
}
break;
break;
case op_anewarray:
pop_type (int_type);
- push_type (check_class_constant (get_ushort ()).to_array ());
+ push_type (check_class_constant (get_ushort ()).to_array (this));
break;
case op_arraylength:
{
type t = pop_type (reference_type);
if (! t.isarray ())
- verify_fail ("array type expected", start_PC);
+ verify_fail ("array type expected");
push_type (int_type);
}
break;
int dim = get_byte ();
if (dim < 1)
verify_fail ("too few dimensions to multianewarray", start_PC);
- atype.verify_dimensions (dim);
+ atype.verify_dimensions (dim, this);
for (int i = 0; i < dim; ++i)
pop_type (int_type);
push_type (atype);
}
}
+ __attribute__ ((__noreturn__)) void verify_fail (char *s, jint pc = -1)
+ {
+ using namespace java::lang;
+ StringBuffer *buf = new StringBuffer ();
+
+ buf->append (JvNewStringLatin1 ("verification failed"));
+ if (pc == -1)
+ pc = start_PC;
+ if (pc != -1)
+ {
+ buf->append (JvNewStringLatin1 (" at PC "));
+ buf->append (pc);
+ }
+
+ _Jv_InterpMethod *method = current_method;
+ buf->append (JvNewStringLatin1 (" in "));
+ buf->append (current_class->getName());
+ buf->append ((jchar) ':');
+ buf->append (JvNewStringUTF (method->get_method()->name->data));
+ buf->append ((jchar) '(');
+ buf->append (JvNewStringUTF (method->get_method()->signature->data));
+ buf->append ((jchar) ')');
+
+ buf->append (JvNewStringLatin1 (": "));
+ buf->append (JvNewStringLatin1 (s));
+ throw new java::lang::VerifyError (buf->toString ());
+ }
+
public:
void verify_instructions ()
_Jv_BytecodeVerifier v (meth);
v.verify_instructions ();
}
-
-// FIXME: add more info, like PC, when required.
-static void
-verify_fail (char *s, jint pc)
-{
- using namespace java::lang;
- StringBuffer *buf = new StringBuffer ();
-
- buf->append (JvNewStringLatin1 ("verification failed"));
- if (pc != -1)
- {
- buf->append (JvNewStringLatin1 (" at PC "));
- buf->append (pc);
- }
- buf->append (JvNewStringLatin1 (": "));
- buf->append (JvNewStringLatin1 (s));
- throw new java::lang::VerifyError (buf->toString ());
-}
-
#endif /* INTERPRETER */
OSDN Git Service
