-// defineclass.cc - defining a class from .class format.
+// verify.cc - verify bytecode
/* Copyright (C) 2001, 2002, 2003 Free Software Foundation
struct subr_info;
struct subr_entry_info;
struct linked_utf8;
+ struct ref_intersection;
// The current PC.
int PC;
// but without this our utf8 objects would be collected.
linked_utf8 *utf8_list;
+ // A linked list of all ref_intersection objects we allocate.
+ ref_intersection *isect_list;
+
struct linked_utf8
{
_Jv_Utf8Const *val;
// Everything after `reference_type' must be a reference type.
reference_type,
null_type,
- unresolved_reference_type,
- uninitialized_reference_type,
- uninitialized_unresolved_reference_type
+ uninitialized_reference_type
+ };
+
+ // This represents a merged class type. Some verifiers (including
+ // earlier versions of this one) will compute the intersection of
+ // two class types when merging states. However, this loses
+ // critical information about interfaces implemented by the various
+ // classes. So instead we keep track of all the actual classes that
+ // have been merged.
+ struct ref_intersection
+ {
+ // Whether or not this type has been resolved.
+ bool is_resolved;
+
+ // Actual type data.
+ union
+ {
+ // For a resolved reference type, this is a pointer to the class.
+ jclass klass;
+ // For other reference types, this it the name of the class.
+ _Jv_Utf8Const *name;
+ } data;
+
+ // Link to the next reference in the intersection.
+ ref_intersection *ref_next;
+
+ // This is used to keep track of all the allocated
+ // ref_intersection objects, so we can free them.
+ // FIXME: we should allocate these in chunks.
+ ref_intersection *alloc_next;
+
+ ref_intersection (jclass klass, _Jv_BytecodeVerifier *verifier)
+ : ref_next (NULL)
+ {
+ is_resolved = true;
+ data.klass = klass;
+ alloc_next = verifier->isect_list;
+ verifier->isect_list = this;
+ }
+
+ ref_intersection (_Jv_Utf8Const *name, _Jv_BytecodeVerifier *verifier)
+ : ref_next (NULL)
+ {
+ is_resolved = false;
+ data.name = name;
+ alloc_next = verifier->isect_list;
+ verifier->isect_list = this;
+ }
+
+ ref_intersection (ref_intersection *dup, ref_intersection *tail,
+ _Jv_BytecodeVerifier *verifier)
+ : ref_next (tail)
+ {
+ is_resolved = dup->is_resolved;
+ data = dup->data;
+ alloc_next = verifier->isect_list;
+ verifier->isect_list = this;
+ }
+
+ bool equals (ref_intersection *other, _Jv_BytecodeVerifier *verifier)
+ {
+ if (! is_resolved && ! other->is_resolved
+ && _Jv_equalUtf8Consts (data.name, other->data.name))
+ return true;
+ if (! is_resolved)
+ resolve (verifier);
+ if (! other->is_resolved)
+ other->resolve (verifier);
+ return data.klass == other->data.klass;
+ }
+
+ // Merge THIS type into OTHER, returning the result. This will
+ // return OTHER if all the classes in THIS already appear in
+ // OTHER.
+ ref_intersection *merge (ref_intersection *other,
+ _Jv_BytecodeVerifier *verifier)
+ {
+ ref_intersection *tail = other;
+ for (ref_intersection *self = this; self != NULL; self = self->ref_next)
+ {
+ bool add = true;
+ for (ref_intersection *iter = other; iter != NULL;
+ iter = iter->ref_next)
+ {
+ if (iter->equals (self, verifier))
+ {
+ add = false;
+ break;
+ }
+ }
+
+ if (add)
+ tail = new ref_intersection (self, tail, verifier);
+ }
+ return tail;
+ }
+
+ void resolve (_Jv_BytecodeVerifier *verifier)
+ {
+ if (is_resolved)
+ return;
+
+ using namespace java::lang;
+ java::lang::ClassLoader *loader
+ = verifier->current_class->getClassLoaderInternal();
+ // 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, loader);
+ else
+ data.klass = Class::forName (_Jv_NewStringUtf8Const (data.name),
+ false, loader);
+ is_resolved = true;
+ }
+
+ // See if an object of type OTHER can be assigned to an object of
+ // type *THIS. This might resolve classes in one chain or the
+ // other.
+ bool compatible (ref_intersection *other,
+ _Jv_BytecodeVerifier *verifier)
+ {
+ ref_intersection *self = this;
+
+ for (; self != NULL; self = self->ref_next)
+ {
+ ref_intersection *other_iter = other;
+
+ for (; other_iter != NULL; other_iter = other_iter->ref_next)
+ {
+ // Avoid resolving if possible.
+ if (! self->is_resolved
+ && ! other_iter->is_resolved
+ && _Jv_equalUtf8Consts (self->data.name,
+ other_iter->data.name))
+ continue;
+
+ if (! self->is_resolved)
+ self->resolve(verifier);
+ if (! other_iter->is_resolved)
+ other_iter->resolve(verifier);
+
+ if (! is_assignable_from_slow (self->data.klass,
+ other_iter->data.klass))
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ bool isarray ()
+ {
+ // assert (ref_next == NULL);
+ if (is_resolved)
+ return data.klass->isArray ();
+ else
+ return data.name->data[0] == '[';
+ }
+
+ bool isinterface (_Jv_BytecodeVerifier *verifier)
+ {
+ // assert (ref_next == NULL);
+ if (! is_resolved)
+ resolve (verifier);
+ return data.klass->isInterface ();
+ }
+
+ bool isabstract (_Jv_BytecodeVerifier *verifier)
+ {
+ // assert (ref_next == NULL);
+ if (! is_resolved)
+ resolve (verifier);
+ using namespace java::lang::reflect;
+ return Modifier::isAbstract (data.klass->getModifiers ());
+ }
+
+ jclass getclass (_Jv_BytecodeVerifier *verifier)
+ {
+ if (! is_resolved)
+ resolve (verifier);
+ return data.klass;
+ }
+
+ int count_dimensions ()
+ {
+ int ndims = 0;
+ if (is_resolved)
+ {
+ jclass k = data.klass;
+ while (k->isArray ())
+ {
+ k = k->getComponentType ();
+ ++ndims;
+ }
+ }
+ else
+ {
+ char *p = data.name->data;
+ while (*p++ == '[')
+ ++ndims;
+ }
+ return ndims;
+ }
+
+ void *operator new (size_t bytes)
+ {
+ return _Jv_Malloc (bytes);
+ }
+
+ void operator delete (void *mem)
+ {
+ _Jv_Free (mem);
+ }
};
// Return the type_val corresponding to a primitive signature
// TARGET haven't been prepared.
static bool is_assignable_from_slow (jclass target, jclass source)
{
- // This will terminate when SOURCE==Object.
- while (true)
+ // First, strip arrays.
+ while (target->isArray ())
+ {
+ // If target is array, source must be as well.
+ if (! source->isArray ())
+ return false;
+ target = target->getComponentType ();
+ source = source->getComponentType ();
+ }
+
+ // Quick success.
+ if (target == &java::lang::Object::class$)
+ return true;
+
+ do
{
if (source == target)
return true;
if (target->isPrimitive () || source->isPrimitive ())
return false;
- if (target->isArray ())
- {
- if (! source->isArray ())
- return false;
- target = target->getComponentType ();
- source = source->getComponentType ();
- }
- else if (target->isInterface ())
+ if (target->isInterface ())
{
for (int i = 0; i < source->interface_count; ++i)
{
// We use a recursive call because we also need to
// check superinterfaces.
if (is_assignable_from_slow (target, source->interfaces[i]))
- return true;
- }
- source = source->getSuperclass ();
- if (source == NULL)
- return false;
- }
- // We must do this check before we check to see if SOURCE is
- // an interface. This way we know that any interface is
- // assignable to an Object.
- else if (target == &java::lang::Object::class$)
- return true;
- else if (source->isInterface ())
- {
- for (int i = 0; i < target->interface_count; ++i)
- {
- // We use a recursive call because we also need to
- // check superinterfaces.
- if (is_assignable_from_slow (target->interfaces[i], source))
return true;
}
- target = target->getSuperclass ();
- if (target == NULL)
- return false;
}
- else if (source == &java::lang::Object::class$)
- return false;
- else
- source = source->getSuperclass ();
+ source = source->getSuperclass ();
}
+ while (source != NULL);
+
+ return false;
}
// This is used to keep track of which `jsr's correspond to a given
// verifier.
struct type
{
- // The type.
+ // The type key.
type_val key;
- // Some associated data.
- union
- {
- // For a resolved reference type, this is a pointer to the class.
- jclass klass;
- // For other reference types, this it the name of the class.
- _Jv_Utf8Const *name;
- } data;
+
+ // For reference types, the representation of the type.
+ ref_intersection *klass;
+
// This is used when constructing a new object. It is the PC of the
// `new' instruction which created the object. We use the special
// value -2 to mean that this is uninitialized, and the special
type ()
{
key = unsuitable_type;
- data.klass = NULL;
+ klass = NULL;
pc = UNINIT;
}
type (type_val k)
{
key = k;
- data.klass = NULL;
- if (key == reference_type)
- data.klass = &java::lang::Object::class$;
+ // For reference_type, if KLASS==NULL then that means we are
+ // looking for a generic object of any kind, including an
+ // uninitialized reference.
+ klass = NULL;
pc = UNINIT;
}
// Make a new instance given a class.
- type (jclass klass)
+ type (jclass k, _Jv_BytecodeVerifier *verifier)
{
key = reference_type;
- data.klass = klass;
+ klass = new ref_intersection (k, verifier);
pc = UNINIT;
}
// Make a new instance given the name of a class.
- type (_Jv_Utf8Const *n)
+ type (_Jv_Utf8Const *n, _Jv_BytecodeVerifier *verifier)
{
- key = unresolved_reference_type;
- data.name = n;
+ key = reference_type;
+ klass = new ref_intersection (n, verifier);
pc = UNINIT;
}
type (const type &t)
{
key = t.key;
- data = t.data;
+ klass = t.klass;
pc = t.pc;
}
type& operator= (type_val k)
{
key = k;
- data.klass = NULL;
+ klass = NULL;
pc = UNINIT;
return *this;
}
type& operator= (const type& t)
{
key = t.key;
- data = t.data;
+ klass = t.klass;
pc = t.pc;
return *this;
}
return *this;
}
- // If *THIS is an unresolved reference type, resolve it.
- void resolve (_Jv_BytecodeVerifier *verifier)
- {
- if (key != unresolved_reference_type
- && key != uninitialized_unresolved_reference_type)
- return;
-
- using namespace java::lang;
- java::lang::ClassLoader *loader
- = verifier->current_class->getClassLoaderInternal();
- // 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, loader);
- else
- data.klass = Class::forName (_Jv_NewStringUtf8Const (data.name),
- 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, _Jv_BytecodeVerifier *verifier)
{
if (key == reference_type)
key = uninitialized_reference_type;
- else if (key == unresolved_reference_type)
- key = uninitialized_unresolved_reference_type;
else
verifier->verify_fail ("internal error in type::uninitialized");
pc = npc;
// Mark this type as now initialized.
void set_initialized (int npc)
{
- if (npc != UNINIT && pc == npc
- && (key == uninitialized_reference_type
- || key == uninitialized_unresolved_reference_type))
+ if (npc != UNINIT && pc == npc && key == uninitialized_reference_type)
{
- key = (key == uninitialized_reference_type
- ? reference_type
- : unresolved_reference_type);
+ key = reference_type;
pc = UNINIT;
}
}
// The `null' type is convertible to any initialized reference
// type.
- if (key == null_type || k.key == null_type)
- return true;
+ if (key == null_type)
+ return k.key != uninitialized_reference_type;
+ if (k.key == null_type)
+ return key != uninitialized_reference_type;
- // Any reference type is convertible to Object. This is a special
- // case so we don't need to unnecessarily resolve a class.
- if (key == reference_type
- && data.klass == &java::lang::Object::class$)
+ // A special case for a generic reference.
+ if (klass == NULL)
return true;
+ if (k.klass == NULL)
+ verifier->verify_fail ("programmer error in type::compatible");
// An initialized type and an uninitialized type are not
// compatible.
return false;
}
- // Two unresolved types are equal if their names are the same.
- if (! isresolved ()
- && ! k.isresolved ()
- && _Jv_equalUtf8Consts (data.name, k.data.name))
- return true;
-
- // We must resolve both types and check assignability.
- resolve (verifier);
- k.resolve (verifier);
- return is_assignable_from_slow (data.klass, k.data.klass);
+ return klass->compatible(k.klass, verifier);
}
bool isvoid () const
// We treat null_type as not an array. This is ok based on the
// current uses of this method.
if (key == reference_type)
- return data.klass->isArray ();
- else if (key == unresolved_reference_type)
- return data.name->data[0] == '[';
+ return klass->isarray ();
return false;
}
bool isinterface (_Jv_BytecodeVerifier *verifier)
{
- resolve (verifier);
if (key != reference_type)
return false;
- return data.klass->isInterface ();
+ return klass->isinterface (verifier);
}
bool isabstract (_Jv_BytecodeVerifier *verifier)
{
- resolve (verifier);
if (key != reference_type)
return false;
- using namespace java::lang::reflect;
- return Modifier::isAbstract (data.klass->getModifiers ());
+ return klass->isabstract (verifier);
}
// Return the element type of an array.
type element_type (_Jv_BytecodeVerifier *verifier)
{
- // FIXME: maybe should do string manipulation here.
- resolve (verifier);
if (key != reference_type)
verifier->verify_fail ("programmer error in type::element_type()", -1);
- jclass k = data.klass->getComponentType ();
+ jclass k = klass->getclass (verifier)->getComponentType ();
if (k->isPrimitive ())
return type (verifier->get_type_val_for_signature (k));
- return type (k);
+ return type (k, verifier);
}
// Return the array type corresponding to an initialized
// types, but currently we don't need to.
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 (verifier);
-
- if (key == reference_type)
- return type (_Jv_GetArrayClass (data.klass,
- data.klass->getClassLoaderInternal()));
- else
+ if (key != reference_type)
verifier->verify_fail ("internal error in type::to_array()");
+
+ jclass k = klass->getclass (verifier);
+ return type (_Jv_GetArrayClass (k, k->getClassLoaderInternal()),
+ verifier);
}
bool isreference () const
bool isinitialized () const
{
- return (key == reference_type
- || key == null_type
- || key == unresolved_reference_type);
+ return key == reference_type || key == null_type;
}
bool isresolved () const
void verify_dimensions (int ndims, _Jv_BytecodeVerifier *verifier)
{
// The way this is written, we don't need to check isarray().
- if (key == reference_type)
- {
- jclass k = data.klass;
- while (k->isArray () && ndims > 0)
- {
- k = k->getComponentType ();
- --ndims;
- }
- }
- else
- {
- // We know KEY == unresolved_reference_type.
- char *p = data.name->data;
- while (*p++ == '[' && ndims-- > 0)
- ;
- }
+ if (key != reference_type)
+ verifier->verify_fail ("internal error in verify_dimensions: not a reference type");
- if (ndims > 0)
+ if (klass->count_dimensions () < ndims)
verifier->verify_fail ("array type has fewer dimensions than required");
}
verifier->verify_fail ("merging different uninitialized types");
}
- if (! isresolved ()
- && ! old_type.isresolved ()
- && _Jv_equalUtf8Consts (data.name, old_type.data.name))
+ ref_intersection *merged = old_type.klass->merge (klass,
+ verifier);
+ if (merged != klass)
{
- // Types are identical.
- }
- else
- {
- resolve (verifier);
- old_type.resolve (verifier);
-
- jclass k = data.klass;
- jclass oldk = old_type.data.klass;
-
- int arraycount = 0;
- while (k->isArray () && oldk->isArray ())
- {
- ++arraycount;
- k = k->getComponentType ();
- oldk = oldk->getComponentType ();
- }
-
- // Ordinarily this terminates when we hit Object...
- while (k != NULL)
- {
- if (is_assignable_from_slow (k, oldk))
- break;
- k = k->getSuperclass ();
- changed = true;
- }
- // ... but K could have been an interface, in which
- // case we'll end up here. We just convert this
- // into Object.
- if (k == NULL)
- k = &java::lang::Object::class$;
-
- if (changed)
- {
- while (arraycount > 0)
- {
- java::lang::ClassLoader *loader
- = verifier->current_class->getClassLoaderInternal();
- k = _Jv_GetArrayClass (k, loader);
- --arraycount;
- }
- data.klass = k;
- }
+ klass = merged;
+ changed = true;
}
}
}
case unused_by_subroutine_type: c = '_'; break;
case reference_type: c = 'L'; break;
case null_type: c = '@'; break;
- case unresolved_reference_type: c = 'l'; break;
case uninitialized_reference_type: c = 'U'; break;
- case uninitialized_unresolved_reference_type: c = 'u'; break;
}
debug_print ("%c", c);
}
case unused_by_subroutine_type:
case reference_type:
case null_type:
- case unresolved_reference_type:
case uninitialized_reference_type:
- case uninitialized_unresolved_reference_type:
default:
verify_fail ("unknown type in construct_primitive_array_type");
}
check_pool_index (index);
_Jv_Constants *pool = ¤t_class->constants;
if (pool->tags[index] == JV_CONSTANT_ResolvedClass)
- return type (pool->data[index].clazz);
+ return type (pool->data[index].clazz, this);
else if (pool->tags[index] == JV_CONSTANT_Class)
- return type (pool->data[index].utf8);
+ return type (pool->data[index].utf8, this);
verify_fail ("expected class constant", start_PC);
}
_Jv_Constants *pool = ¤t_class->constants;
if (pool->tags[index] == JV_CONSTANT_ResolvedString
|| pool->tags[index] == JV_CONSTANT_String)
- return type (&java::lang::String::class$);
+ return type (&java::lang::String::class$, this);
else if (pool->tags[index] == JV_CONSTANT_Integer)
return type (int_type);
else if (pool->tags[index] == JV_CONSTANT_Float)
if (class_type)
*class_type = ct;
if (field_type->data[0] == '[' || field_type->data[0] == 'L')
- return type (field_type);
+ return type (field_type, this);
return get_type_val_for_signature (field_type->data[0]);
}
++p;
++p;
_Jv_Utf8Const *name = make_utf8_const (start, p - start);
- return type (name);
+ return type (name, this);
}
// Casting to jchar here is ok since we are looking at an ASCII
jclass k = construct_primitive_array_type (rt);
while (--arraycount > 0)
k = _Jv_GetArrayClass (k, NULL);
- return type (k);
+ return type (k, this);
}
void compute_argument_types (_Jv_Utf8Const *signature,
using namespace java::lang::reflect;
if (! Modifier::isStatic (current_method->self->accflags))
{
- type kurr (current_class);
+ type kurr (current_class, this);
if (is_init)
{
kurr.set_uninitialized (type::SELF, this);
{
if (PC >= exception[i].start_pc.i && PC < exception[i].end_pc.i)
{
- type handler (&java::lang::Throwable::class$);
+ type handler (&java::lang::Throwable::class$, this);
if (exception[i].handler_type.i != 0)
handler = check_class_constant (exception[i].handler_type.i);
push_exception_jump (handler, exception[i].handler_pc.i);
{
// In this case the PC doesn't matter.
t.set_uninitialized (type::UNINIT, this);
+ // FIXME: check to make sure that the <init>
+ // call is to the right class.
+ // It must either be super or an exact class
+ // match.
}
type raw = pop_raw ();
- bool ok = false;
- if (! is_init && ! raw.isinitialized ())
- {
- // This is a failure.
- }
- else if (is_init && raw.isnull ())
- {
- // Another failure.
- }
- else if (t.compatible (raw, this))
- {
- ok = true;
- }
- else if (opcode == op_invokeinterface)
- {
- // This is a hack. We might have merged two
- // items and gotten `Object'. This can happen
- // because we don't keep track of where merges
- // come from. This is safe as long as the
- // interpreter checks interfaces at runtime.
- type obj (&java::lang::Object::class$);
- ok = raw.compatible (obj, this);
- }
-
- if (! ok)
+ if (! t.compatible (raw, this))
verify_fail ("incompatible type on stack");
if (is_init)
if (atype < boolean_type || atype > long_type)
verify_fail ("type not primitive", start_PC);
pop_type (int_type);
- push_type (construct_primitive_array_type (type_val (atype)));
+ type t (construct_primitive_array_type (type_val (atype)), this);
+ push_type (t);
}
break;
case op_anewarray:
}
break;
case op_athrow:
- pop_type (type (&java::lang::Throwable::class$));
+ pop_type (type (&java::lang::Throwable::class$, this));
invalidate_pc ();
break;
case op_checkcast:
flags = NULL;
jsr_ptrs = NULL;
utf8_list = NULL;
+ isect_list = NULL;
entry_points = NULL;
}
_Jv_Free (entry_points);
entry_points = next;
}
+
+ while (isect_list != NULL)
+ {
+ ref_intersection *next = isect_list->alloc_next;
+ delete isect_list;
+ isect_list = next;
+ }
}
};
projects / platform / upstream / gcc.git / commitdiff