diff options
Diffstat (limited to 'libjava/defineclass.cc')
| -rw-r--r-- | libjava/defineclass.cc | 2074 |
1 files changed, 2074 insertions, 0 deletions
diff --git a/libjava/defineclass.cc b/libjava/defineclass.cc new file mode 100644 index 000000000..4c4e0a7f4 --- /dev/null +++ b/libjava/defineclass.cc @@ -0,0 +1,2074 @@ +// defineclass.cc - defining a class from .class format. + +/* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 + Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +/* + Author: Kresten Krab Thorup <krab@gnu.org> + + Written using the online versions of Java Language Specification (1st + ed.) and The Java Virtual Machine Specification (2nd ed.). + + Future work may include reading (and handling) attributes which are + currently being ignored ("InnerClasses", "LineNumber", etc...). +*/ + +#include <config.h> + +#include <java-interp.h> + +#include <stdlib.h> +#include <stdio.h> +#include <java-cpool.h> +#include <gcj/cni.h> +#include <execution.h> + +#include <java/lang/Class.h> +#include <java/lang/Float.h> +#include <java/lang/Double.h> +#include <java/lang/Character.h> +#include <java/lang/LinkageError.h> +#include <java/lang/InternalError.h> +#include <java/lang/ClassFormatError.h> +#include <java/lang/NoClassDefFoundError.h> +#include <java/lang/ClassCircularityError.h> +#include <java/lang/IncompatibleClassChangeError.h> +#include <java/lang/reflect/Modifier.h> +#include <java/lang/reflect/Field.h> +#include <java/lang/reflect/Method.h> +#include <java/security/ProtectionDomain.h> +#include <java/io/DataOutputStream.h> +#include <java/io/ByteArrayOutputStream.h> + +using namespace gcj; + +#ifdef INTERPRETER + +// these go in some separate functions, to avoid having _Jv_InitClass +// inserted all over the place. +static void throw_internal_error (const char *msg) + __attribute__ ((__noreturn__)); +static void throw_no_class_def_found_error (jstring msg) + __attribute__ ((__noreturn__)); +static void throw_no_class_def_found_error (const char *msg) + __attribute__ ((__noreturn__)); +static void throw_class_format_error (jstring msg) + __attribute__ ((__noreturn__)); +static void throw_incompatible_class_change_error (jstring msg) + __attribute__ ((__noreturn__)); +static void throw_class_circularity_error (jstring msg) + __attribute__ ((__noreturn__)); + +/** + * We define class reading using a class. It is practical, since then + * the entire class-reader can be a friend of class Class (it needs to + * write all it's different structures); but also because this makes it + * easy to make class definition reentrant, and thus two threads can be + * defining classes at the same time. This class (_Jv_ClassReader) is + * never exposed outside this file, so we don't have to worry about + * public or private members here. + */ + +struct _Jv_ClassReader +{ + + // do verification? Currently, there is no option to disable this. + // This flag just controls the verificaiton done by the class loader; + // i.e., checking the integrity of the constant pool; and it is + // allways on. You always want this as far as I can see, but it also + // controls weither identifiers and type descriptors/signatures are + // verified as legal. This could be somewhat more expensive since it + // will call Character.isJavaIdentifier{Start,Part} for each character + // in any identifier (field name or method name) it comes by. Thus, + // it might be useful to turn off this verification for classes that + // come from a trusted source. However, for GCJ, trusted classes are + // most likely to be linked in. + + bool verify; + + // original input data. + jbyteArray input_data; + jint input_offset; + + // input data. + unsigned char *bytes; + int len; + + // current input position + int pos; + + // the constant pool data + int pool_count; + unsigned char *tags; + unsigned int *offsets; + + // the class to define (see java-interp.h) + jclass def; + + // the classes associated interpreter data. + _Jv_InterpClass *def_interp; + + // The name we found. + _Jv_Utf8Const **found_name; + + // True if this is a 1.5 class file. + bool is_15; + + // Buffer holding extra reflection data. + ::java::io::ByteArrayOutputStream *reflection_data; + ::java::io::DataOutputStream *data_stream; + + + /* check that the given number of input bytes are available */ + inline void check (int num) + { + if (pos + num > len) + throw_class_format_error ("Premature end of data"); + } + + /* skip a given number of bytes in input */ + inline void skip (int num) + { + check (num); + pos += num; + } + + /* read an unsigned 1-byte unit */ + inline static jint get1u (unsigned char* bytes) + { + return bytes[0]; + } + + /* read an unsigned 1-byte unit */ + inline jint read1u () + { + skip (1); + return get1u (bytes+pos-1); + } + + /* read an unsigned 2-byte unit */ + inline static jint get2u (unsigned char *bytes) + { + return (((jint)bytes[0]) << 8) | ((jint)bytes[1]); + } + + /* read an unsigned 2-byte unit */ + inline jint read2u () + { + skip (2); + return get2u (bytes+pos-2); + } + + /* read a 4-byte unit */ + static jint get4 (unsigned char *bytes) + { + return (((jint)bytes[0]) << 24) + | (((jint)bytes[1]) << 16) + | (((jint)bytes[2]) << 8) + | (((jint)bytes[3]) << 0); + } + + /* read a 4-byte unit, (we don't do that quite so often) */ + inline jint read4 () + { + skip (4); + return get4 (bytes+pos-4); + } + + /* read a 8-byte unit */ + static jlong get8 (unsigned char* bytes) + { + return (((jlong)bytes[0]) << 56) + | (((jlong)bytes[1]) << 48) + | (((jlong)bytes[2]) << 40) + | (((jlong)bytes[3]) << 32) + | (((jlong)bytes[4]) << 24) + | (((jlong)bytes[5]) << 16) + | (((jlong)bytes[6]) << 8) + | (((jlong)bytes[7]) << 0); + } + + /* read a 8-byte unit */ + inline jlong read8 () + { + skip (8); + return get8 (bytes+pos-8); + } + + inline void check_tag (int index, char expected_tag) + { + if (index < 0 + || index > pool_count + || tags[index] != expected_tag) + throw_class_format_error ("erroneous constant pool tag"); + } + + inline void verify_identifier (_Jv_Utf8Const* name) + { + if (! _Jv_VerifyIdentifier (name)) + throw_class_format_error ("erroneous identifier"); + } + + inline void verify_classname (unsigned char* ptr, _Jv_ushort length) + { + if (! _Jv_VerifyClassName (ptr, length)) + throw_class_format_error ("erroneous class name"); + } + + inline void verify_classname (_Jv_Utf8Const *name) + { + if (! _Jv_VerifyClassName (name)) + throw_class_format_error ("erroneous class name"); + } + + inline void verify_field_signature (_Jv_Utf8Const *sig) + { + if (! _Jv_VerifyFieldSignature (sig)) + throw_class_format_error ("erroneous type descriptor"); + } + + inline void verify_method_signature (_Jv_Utf8Const *sig) + { + if (! _Jv_VerifyMethodSignature (sig)) + throw_class_format_error ("erroneous type descriptor"); + } + + ::java::io::DataOutputStream *get_reflection_stream () + { + if (reflection_data == NULL) + { + reflection_data = new ::java::io::ByteArrayOutputStream(); + data_stream = new ::java::io::DataOutputStream(reflection_data); + } + return data_stream; + } + + _Jv_ClassReader (jclass klass, jbyteArray data, jint offset, jint length, + java::security::ProtectionDomain *pd, + _Jv_Utf8Const **name_result) + { + if (klass == 0 || length < 0 || offset+length > data->length) + throw_internal_error ("arguments to _Jv_DefineClass"); + + verify = true; + input_data = data; + input_offset = offset; + bytes = (unsigned char*) (elements (data)+offset); + len = length; + pos = 0; + is_15 = false; + + def = klass; + found_name = name_result; + reflection_data = NULL; + data_stream = NULL; + + def->size_in_bytes = -1; + def->vtable_method_count = -1; + def->engine = &_Jv_soleInterpreterEngine; + def->protectionDomain = pd; + } + + /** and here goes the parser members defined out-of-line */ + void parse (); + void read_constpool (); + void prepare_pool_entry (int index, unsigned char tag, + bool rewrite = true); + void read_fields (); + void read_methods (); + void read_one_class_attribute (); + void read_one_method_attribute (int method); + void read_one_code_attribute (int method); + void read_one_field_attribute (int field, bool *); + void throw_class_format_error (const char *msg); + + void handleEnclosingMethod(int); + void handleGenericSignature(jv_attr_type, unsigned short, int); + void handleAnnotationElement(); + void handleAnnotation(); + void handleAnnotations(); + void handleMemberAnnotations(jv_attr_type, int, int); + void handleAnnotationDefault(int, int); + void handleParameterAnnotations(int, int); + void finish_reflection_data (); + + /** check an utf8 entry, without creating a Utf8Const object */ + bool is_attribute_name (int index, const char *name); + + /** return the value of a utf8 entry in the passed array */ + int pool_Utf8_to_char_arr (int index, char **entry); + + /** here goes the class-loader members defined out-of-line */ + void handleConstantPool (); + void handleClassBegin (int, int, int); + void handleInterfacesBegin (int); + void handleInterface (int, int); + void handleFieldsBegin (int); + void handleField (int, int, int, int, int *); + void handleConstantValueAttribute (int, int, bool *); + void handleMethodsBegin (int); + void handleMethod (int, int, int, int); + void handleMethodsEnd (); + void handleCodeAttribute (int, int, int, int, int, int); + void handleExceptionTableEntry (int, int, int, int, int, int); + + void checkExtends (jclass sub, jclass super); + void checkImplements (jclass sub, jclass super); + + /* + * FIXME: we should keep a hash table of utf8-strings, since many will + * be the same. It's a little tricky, however, because the hash table + * needs to interact gracefully with the garbage collector. Much + * memory is to be saved by this, however! perhaps the improvement + * could be implemented in prims.cc (_Jv_makeUtf8Const), since it + * computes the hash value anyway. + */ +}; + +// Note that *NAME_RESULT will only be set if the class is registered +// with the class loader. This is how the caller can know whether +// unregistration is require. +void +_Jv_DefineClass (jclass klass, jbyteArray data, jint offset, jint length, + java::security::ProtectionDomain *pd, + _Jv_Utf8Const **name_result) +{ + _Jv_ClassReader reader (klass, data, offset, length, pd, name_result); + reader.parse(); + + /* that's it! */ +} + + +/** This section defines the parsing/scanning of the class data */ + +// Major and minor version numbers for various releases. +#define MAJOR_1_1 45 +#define MINOR_1_1 3 +#define MAJOR_1_2 46 +#define MINOR_1_2 0 +#define MAJOR_1_3 47 +#define MINOR_1_3 0 +#define MAJOR_1_4 48 +#define MINOR_1_4 0 +#define MAJOR_1_5 49 +#define MINOR_1_5 0 +#define MAJOR_1_6 50 +#define MINOR_1_6 0 + +void +_Jv_ClassReader::parse () +{ + int magic = read4 (); + if (magic != (int) 0xCAFEBABE) + throw_class_format_error ("bad magic number"); + + int minor_version = read2u (); + int major_version = read2u (); + if (major_version < MAJOR_1_1 || major_version > MAJOR_1_6 + || (major_version == MAJOR_1_6 && minor_version > MINOR_1_6)) + throw_class_format_error ("unrecognized class file version"); + is_15 = (major_version >= MAJOR_1_5); + + pool_count = read2u (); + + read_constpool (); + + int access_flags = read2u (); + int this_class = read2u (); + int super_class = read2u (); + + check_tag (this_class, JV_CONSTANT_Class); + if (super_class != 0) + check_tag (super_class, JV_CONSTANT_Class); + + handleClassBegin (access_flags, this_class, super_class); + + // Allocate our aux_info here, after the name is set, to fulfill our + // contract with the collector interface. + def->aux_info = (void *) _Jv_AllocRawObj (sizeof (_Jv_InterpClass)); + def_interp = (_Jv_InterpClass *) def->aux_info; + + int interfaces_count = read2u (); + + handleInterfacesBegin (interfaces_count); + + for (int i = 0; i < interfaces_count; i++) + { + int iface = read2u (); + check_tag (iface, JV_CONSTANT_Class); + handleInterface (i, iface); + } + + read_fields (); + read_methods (); + + int attributes_count = read2u (); + + for (int i = 0; i < attributes_count; i++) + { + read_one_class_attribute (); + } + + if (pos != len) + throw_class_format_error ("unused data before end of file"); + + finish_reflection_data (); + + // Tell everyone we're done. + def->state = JV_STATE_READ; + if (gcj::verbose_class_flag) + _Jv_Linker::print_class_loaded (def); + ++gcj::loadedClasses; + def->notifyAll (); +} + +void +_Jv_ClassReader::finish_reflection_data () +{ + if (data_stream == NULL) + return; + data_stream->writeByte(JV_DONE_ATTR); + data_stream->flush(); + int nbytes = reflection_data->count; + unsigned char *new_bytes = (unsigned char *) _Jv_AllocBytes (nbytes); + memcpy (new_bytes, elements (reflection_data->buf), nbytes); + def->reflection_data = new_bytes; +} + +void +_Jv_ClassReader::handleEnclosingMethod (int len) +{ + if (len != 4) + throw_class_format_error ("invalid EnclosingMethod attribute"); + // FIXME: only allow one... + + int class_index = read2u(); + check_tag (class_index, JV_CONSTANT_Class); + prepare_pool_entry (class_index, JV_CONSTANT_Class); + + int method_index = read2u(); + // Zero is ok and means no enclosing method. + if (method_index != 0) + { + check_tag (method_index, JV_CONSTANT_NameAndType); + prepare_pool_entry (method_index, JV_CONSTANT_NameAndType); + } + + ::java::io::DataOutputStream *stream = get_reflection_stream (); + stream->writeByte(JV_CLASS_ATTR); + stream->writeInt(5); + stream->writeByte(JV_ENCLOSING_METHOD_KIND); + stream->writeShort(class_index); + stream->writeShort(method_index); +} + +void +_Jv_ClassReader::handleGenericSignature (jv_attr_type type, + unsigned short index, + int len) +{ + if (len != 2) + throw_class_format_error ("invalid Signature attribute"); + + int cpool_idx = read2u(); + check_tag (cpool_idx, JV_CONSTANT_Utf8); + prepare_pool_entry (cpool_idx, JV_CONSTANT_Utf8, false); + + ::java::io::DataOutputStream *stream = get_reflection_stream (); + stream->writeByte(type); + int attrlen = 3; + if (type != JV_CLASS_ATTR) + attrlen += 2; + stream->writeInt(attrlen); + if (type != JV_CLASS_ATTR) + stream->writeShort(index); + stream->writeByte(JV_SIGNATURE_KIND); + stream->writeShort(cpool_idx); +} + +void +_Jv_ClassReader::handleAnnotationElement() +{ + int tag = read1u(); + switch (tag) + { + case 'B': + case 'C': + case 'S': + case 'Z': + case 'I': + { + int index = read2u(); + check_tag (index, JV_CONSTANT_Integer); + prepare_pool_entry (index, JV_CONSTANT_Integer); + } + break; + case 'D': + { + int index = read2u(); + check_tag (index, JV_CONSTANT_Double); + prepare_pool_entry (index, JV_CONSTANT_Double); + } + break; + case 'F': + { + int index = read2u(); + check_tag (index, JV_CONSTANT_Float); + prepare_pool_entry (index, JV_CONSTANT_Float); + } + break; + case 'J': + { + int index = read2u(); + check_tag (index, JV_CONSTANT_Long); + prepare_pool_entry (index, JV_CONSTANT_Long); + } + break; + case 's': + { + int index = read2u(); + // Despite what the JVM spec says, compilers generate a Utf8 + // constant here, not a String. + check_tag (index, JV_CONSTANT_Utf8); + prepare_pool_entry (index, JV_CONSTANT_Utf8, false); + } + break; + + case 'e': + { + int type_name_index = read2u(); + int const_name_index = read2u (); + check_tag (type_name_index, JV_CONSTANT_Utf8); + prepare_pool_entry (type_name_index, JV_CONSTANT_Utf8); + check_tag (const_name_index, JV_CONSTANT_Utf8); + prepare_pool_entry (const_name_index, JV_CONSTANT_Utf8, false); + } + break; + case 'c': + { + int index = read2u(); + check_tag (index, JV_CONSTANT_Utf8); + prepare_pool_entry (index, JV_CONSTANT_Utf8); + } + break; + case '@': + handleAnnotation(); + break; + case '[': + { + int n_array_elts = read2u (); + for (int i = 0; i < n_array_elts; ++i) + handleAnnotationElement(); + } + break; + default: + throw_class_format_error ("invalid annotation element"); + } +} + +void +_Jv_ClassReader::handleAnnotation() +{ + int type_index = read2u(); + check_tag (type_index, JV_CONSTANT_Utf8); + prepare_pool_entry (type_index, JV_CONSTANT_Utf8); + + int npairs = read2u(); + for (int i = 0; i < npairs; ++i) + { + int name_index = read2u(); + check_tag (name_index, JV_CONSTANT_Utf8); + prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false); + handleAnnotationElement(); + } +} + +void +_Jv_ClassReader::handleAnnotations() +{ + int num = read2u(); + while (num--) + handleAnnotation(); +} + +void +_Jv_ClassReader::handleMemberAnnotations(jv_attr_type member_type, + int member_index, + int len) +{ + // We're going to copy the bytes in verbatim. But first we want to + // make sure the attribute is well-formed, and we want to prepare + // the constant pool. So, we save our starting point. + int orig_pos = pos; + + handleAnnotations(); + // FIXME: check that we read all LEN bytes? + + ::java::io::DataOutputStream *stream = get_reflection_stream (); + stream->writeByte(member_type); + int newLen = len + 1; + if (member_type != JV_CLASS_ATTR) + newLen += 2; + stream->writeInt(newLen); + stream->writeByte(JV_ANNOTATIONS_KIND); + if (member_type != JV_CLASS_ATTR) + stream->writeShort(member_index); + // Write the data as-is. + stream->write(input_data, input_offset + orig_pos, len); +} + +void +_Jv_ClassReader::handleAnnotationDefault(int member_index, int len) +{ + int orig_pos = pos; + handleAnnotationElement(); + + ::java::io::DataOutputStream *stream = get_reflection_stream (); + stream->writeByte(JV_METHOD_ATTR); + stream->writeInt(len + 3); + stream->writeByte(JV_ANNOTATION_DEFAULT_KIND); + stream->writeShort(member_index); + stream->write(input_data, input_offset + orig_pos, len); +} + +void +_Jv_ClassReader::handleParameterAnnotations(int member_index, int len) +{ + int orig_pos = pos; + + int n_params = read1u(); + for (int i = 0; i < n_params; ++i) + handleAnnotations(); + + ::java::io::DataOutputStream *stream = get_reflection_stream (); + stream->writeByte(JV_METHOD_ATTR); + stream->writeInt(len + 3); + stream->writeByte(JV_PARAMETER_ANNOTATIONS_KIND); + stream->writeShort(member_index); + stream->write(input_data, input_offset + orig_pos, len); +} + +void _Jv_ClassReader::read_constpool () +{ + tags = (unsigned char*) _Jv_AllocBytes (pool_count); + offsets = (unsigned int *) _Jv_AllocBytes (sizeof (int) * pool_count) ; + + /** first, we scan the constant pool, collecting tags and offsets */ + tags[0] = JV_CONSTANT_Undefined; + offsets[0] = pos; + for (int c = 1; c < pool_count; c++) + { + tags[c] = read1u (); + offsets[c] = pos; + + switch (tags[c]) + { + case JV_CONSTANT_String: + case JV_CONSTANT_Class: + skip (2); + break; + + case JV_CONSTANT_Fieldref: + case JV_CONSTANT_Methodref: + case JV_CONSTANT_InterfaceMethodref: + case JV_CONSTANT_NameAndType: + case JV_CONSTANT_Integer: + case JV_CONSTANT_Float: + skip (4); + break; + + case JV_CONSTANT_Double: + case JV_CONSTANT_Long: + skip (8); + tags[++c] = JV_CONSTANT_Undefined; + break; + + case JV_CONSTANT_Utf8: + { + int len = read2u (); + skip (len); + } + break; + + case JV_CONSTANT_Unicode: + throw_class_format_error ("unicode not supported"); + break; + + default: + throw_class_format_error ("erroneous constant pool tag"); + } + } + + handleConstantPool (); +} + + +void _Jv_ClassReader::read_fields () +{ + int fields_count = read2u (); + handleFieldsBegin (fields_count); + + // We want to sort the fields so that static fields come first, + // followed by instance fields. We do this before parsing the + // fields so that we can have the new indices available when + // creating the annotation data structures. + + // Allocate this on the heap in case there are a large number of + // fields. + int *fieldmap = (int *) _Jv_AllocBytes (fields_count * sizeof (int)); + int save_pos = pos; + int static_count = 0, instance_count = -1; + for (int i = 0; i < fields_count; ++i) + { + using namespace java::lang::reflect; + + int access_flags = read2u (); + skip (4); + int attributes_count = read2u (); + + if ((access_flags & Modifier::STATIC) != 0) + fieldmap[i] = static_count++; + else + fieldmap[i] = instance_count--; + + for (int j = 0; j < attributes_count; ++j) + { + skip (2); + int length = read4 (); + skip (length); + } + } + pos = save_pos; + + // In the loop above, instance fields are represented by negative + // numbers. Here we rewrite these to be proper offsets. + for (int i = 0; i < fields_count; ++i) + { + if (fieldmap[i] < 0) + fieldmap[i] = static_count - 1 - fieldmap[i]; + } + def->static_field_count = static_count; + + for (int i = 0; i < fields_count; i++) + { + int access_flags = read2u (); + int name_index = read2u (); + int descriptor_index = read2u (); + int attributes_count = read2u (); + + check_tag (name_index, JV_CONSTANT_Utf8); + prepare_pool_entry (name_index, JV_CONSTANT_Utf8); + + check_tag (descriptor_index, JV_CONSTANT_Utf8); + prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8); + + handleField (i, access_flags, name_index, descriptor_index, fieldmap); + + bool found_value = false; + for (int j = 0; j < attributes_count; j++) + { + read_one_field_attribute (fieldmap[i], &found_value); + } + } +} + +bool +_Jv_ClassReader::is_attribute_name (int index, const char *name) +{ + check_tag (index, JV_CONSTANT_Utf8); + int len = get2u (bytes+offsets[index]); + if (len != (int) strlen (name)) + return false; + else + return !memcmp (bytes+offsets[index]+2, name, len); +} + +// Get a UTF8 value from the constant pool and turn it into a garbage +// collected char array. +int _Jv_ClassReader::pool_Utf8_to_char_arr (int index, char** entry) +{ + check_tag (index, JV_CONSTANT_Utf8); + int len = get2u (bytes + offsets[index]); + *entry = reinterpret_cast<char *> (_Jv_AllocBytes (len + 1)); + (*entry)[len] = '\0'; + memcpy (*entry, bytes + offsets[index] + 2, len); + return len + 1; +} + +void _Jv_ClassReader::read_one_field_attribute (int field_index, + bool *found_value) +{ + int name = read2u (); + int length = read4 (); + + if (is_attribute_name (name, "ConstantValue")) + { + int cv = read2u (); + + if (cv < pool_count + && cv > 0 + && (tags[cv] == JV_CONSTANT_Integer + || tags[cv] == JV_CONSTANT_Float + || tags[cv] == JV_CONSTANT_Long + || tags[cv] == JV_CONSTANT_Double + || tags[cv] == JV_CONSTANT_String)) + { + handleConstantValueAttribute (field_index, cv, found_value); + } + else + { + throw_class_format_error ("erroneous ConstantValue attribute"); + } + + if (length != 2) + throw_class_format_error ("erroneous ConstantValue attribute"); + } + else if (is_attribute_name (name, "Signature")) + handleGenericSignature(JV_FIELD_ATTR, field_index, length); + else if (is_attribute_name (name, "RuntimeVisibleAnnotations")) + handleMemberAnnotations(JV_FIELD_ATTR, field_index, length); + else + skip (length); +} + +void _Jv_ClassReader::read_methods () +{ + int methods_count = read2u (); + + handleMethodsBegin (methods_count); + + for (int i = 0; i < methods_count; i++) + { + int access_flags = read2u (); + int name_index = read2u (); + int descriptor_index = read2u (); + int attributes_count = read2u (); + + check_tag (name_index, JV_CONSTANT_Utf8); + prepare_pool_entry (name_index, JV_CONSTANT_Utf8); + + check_tag (descriptor_index, JV_CONSTANT_Utf8); + prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8); + + handleMethod (i, access_flags, name_index, + descriptor_index); + + for (int j = 0; j < attributes_count; j++) + { + read_one_method_attribute (i); + } + } + + handleMethodsEnd (); +} + +void _Jv_ClassReader::read_one_method_attribute (int method_index) +{ + int name = read2u (); + int length = read4 (); + + if (is_attribute_name (name, "Exceptions")) + { + _Jv_Method *method = reinterpret_cast<_Jv_Method *> + (&def->methods[method_index]); + if (method->throws != NULL) + throw_class_format_error ("only one Exceptions attribute allowed per method"); + + int num_exceptions = read2u (); + _Jv_Utf8Const **exceptions = + (_Jv_Utf8Const **) _Jv_AllocBytes ((num_exceptions + 1) + * sizeof (_Jv_Utf8Const *)); + + int out = 0; + _Jv_word *pool_data = def->constants.data; + for (int i = 0; i < num_exceptions; ++i) + { + int ndx = read2u (); + // JLS 2nd Ed. 4.7.5 requires that the tag not be 0. + if (ndx != 0) + { + check_tag (ndx, JV_CONSTANT_Class); + exceptions[out++] = pool_data[ndx].utf8; + } + } + exceptions[out] = NULL; + method->throws = exceptions; + } + + else if (is_attribute_name (name, "Code")) + { + int start_off = pos; + int max_stack = read2u (); + int max_locals = read2u (); + int code_length = read4 (); + + int code_start = pos; + skip (code_length); + int exception_table_length = read2u (); + + handleCodeAttribute (method_index, + max_stack, max_locals, + code_start, code_length, + exception_table_length); + + + for (int i = 0; i < exception_table_length; i++) + { + int start_pc = read2u (); + int end_pc = read2u (); + int handler_pc = read2u (); + int catch_type = read2u (); + + if (start_pc > end_pc + || start_pc < 0 + // END_PC can be equal to CODE_LENGTH. + // See JVM Spec 4.7.4. + || end_pc > code_length + || handler_pc >= code_length) + throw_class_format_error ("erroneous exception handler info"); + + if (! (tags[catch_type] == JV_CONSTANT_Class + || tags[catch_type] == 0)) + { + throw_class_format_error ("erroneous exception handler info"); + } + + handleExceptionTableEntry (method_index, + i, + start_pc, + end_pc, + handler_pc, + catch_type); + + } + + int attributes_count = read2u (); + + for (int i = 0; i < attributes_count; i++) + { + read_one_code_attribute (method_index); + } + + if ((pos - start_off) != length) + throw_class_format_error ("code attribute too short"); + } + else if (is_attribute_name (name, "Signature")) + handleGenericSignature(JV_METHOD_ATTR, method_index, length); + else if (is_attribute_name (name, "RuntimeVisibleAnnotations")) + handleMemberAnnotations(JV_METHOD_ATTR, method_index, length); + else if (is_attribute_name (name, "RuntimeVisibleParameterAnnotations")) + handleParameterAnnotations(method_index, length); + else if (is_attribute_name (name, "AnnotationDefault")) + handleAnnotationDefault(method_index, length); + else + { + /* ignore unknown attributes */ + skip (length); + } +} + +void _Jv_ClassReader::read_one_code_attribute (int method_index) +{ + int name = read2u (); + int length = read4 (); + if (is_attribute_name (name, "LineNumberTable")) + { + _Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *> + (def_interp->interpreted_methods[method_index]); + if (method->line_table != NULL) + throw_class_format_error ("Method already has LineNumberTable"); + + int table_len = read2u (); + _Jv_LineTableEntry* table + = (_Jv_LineTableEntry *) _Jv_AllocBytes (table_len + * sizeof (_Jv_LineTableEntry)); + for (int i = 0; i < table_len; i++) + { + table[i].bytecode_pc = read2u (); + table[i].line = read2u (); + } + method->line_table_len = table_len; + method->line_table = table; + } + else if (is_attribute_name (name, "LocalVariableTable")) + { + _Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *> + (def_interp->interpreted_methods[method_index]); + if (method->local_var_table != NULL) + throw_class_format_error ("Method already has LocalVariableTable"); + + int table_len = read2u (); + _Jv_LocalVarTableEntry *table + = reinterpret_cast<_Jv_LocalVarTableEntry *> + (_Jv_AllocRawObj (table_len * sizeof (_Jv_LocalVarTableEntry))); + + for (int i = 0; i < table_len; i++) + { + table[i].bytecode_pc = read2u (); + table[i].length = read2u (); + pool_Utf8_to_char_arr (read2u (), &table[i].name); + pool_Utf8_to_char_arr (read2u (), &table[i].descriptor); + table[i].slot = read2u (); + + if (table[i].slot > method->max_locals || table[i].slot < 0) + throw_class_format_error ("Malformed Local Variable Table: Invalid Slot"); + } + + method->local_var_table_len = table_len; + method->local_var_table = table; + } + else + { + /* ignore unknown code attributes */ + skip (length); + } +} + +void _Jv_ClassReader::read_one_class_attribute () +{ + int name = read2u (); + int length = read4 (); + if (is_attribute_name (name, "SourceFile")) + { + int source_index = read2u (); + check_tag (source_index, JV_CONSTANT_Utf8); + prepare_pool_entry (source_index, JV_CONSTANT_Utf8, false); + def_interp->source_file_name = _Jv_NewStringUtf8Const + (def->constants.data[source_index].utf8); + } + else if (is_attribute_name (name, "Signature")) + handleGenericSignature(JV_CLASS_ATTR, 0, length); + else if (is_attribute_name (name, "EnclosingMethod")) + handleEnclosingMethod(length); + else if (is_attribute_name (name, "RuntimeVisibleAnnotations")) + handleMemberAnnotations(JV_CLASS_ATTR, 0, length); + else if (is_attribute_name (name, "InnerClasses")) + { + ::java::io::DataOutputStream *stream = get_reflection_stream (); + stream->writeByte(JV_CLASS_ATTR); + stream->writeInt(length + 1); + stream->writeByte(JV_INNER_CLASSES_KIND); + stream->write(input_data, input_offset + pos, length); + skip (length); + } + else + { + /* Currently, we ignore most class attributes. */ + skip (length); + } +} + + + + +/* this section defines the semantic actions of the parser */ + +void _Jv_ClassReader::handleConstantPool () +{ + /** now, we actually define the class' constant pool */ + + jbyte *pool_tags = (jbyte*) _Jv_AllocBytes (pool_count); + _Jv_word *pool_data + = (_Jv_word*) _Jv_AllocRawObj (pool_count * sizeof (_Jv_word)); + + def->constants.tags = pool_tags; + def->constants.data = pool_data; + def->constants.size = pool_count; + + // Here we make a pass to collect the strings! We do this, because + // internally in the GCJ runtime, classes are encoded with .'s not /'s. + // Therefore, we first collect the strings, and then translate the rest + // of the utf8-entries (thus not representing strings) from /-notation + // to .-notation. + for (int i = 1; i < pool_count; i++) + { + if (tags[i] == JV_CONSTANT_String) + { + unsigned char* str_data = bytes + offsets [i]; + int utf_index = get2u (str_data); + check_tag (utf_index, JV_CONSTANT_Utf8); + unsigned char *utf_data = bytes + offsets[utf_index]; + int len = get2u (utf_data); + pool_data[i].utf8 = _Jv_makeUtf8Const ((char*)(utf_data+2), len); + pool_tags[i] = JV_CONSTANT_String; + } + else + { + pool_tags[i] = JV_CONSTANT_Undefined; + } + } + + // and now, we scan everything else but strings & utf8-entries. This + // leaves out those utf8-entries which are not used; which will be left + // with a tag of JV_CONSTANT_Undefined in the class definition. + for (int index = 1; index < pool_count; index++) + { + switch (tags[index]) + { + case JV_CONSTANT_Undefined: + case JV_CONSTANT_String: + case JV_CONSTANT_Utf8: + continue; + + default: + prepare_pool_entry (index, tags[index]); + } + } + +} + +/* this is a recursive procedure, which will prepare pool entries as needed. + Which is how we avoid initializing those entries which go unused. + + REWRITE is true iff this pool entry is the Utf8 representation of a + class name or a signature. +*/ + +void +_Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag, + bool rewrite) +{ + /* these two, pool_data and pool_tags, point into the class + structure we are currently defining */ + + unsigned char *pool_tags = (unsigned char*) def->constants.tags; + _Jv_word *pool_data = def->constants.data; + + /* this entry was already prepared */ + if (pool_tags[index] == this_tag) + return; + + /* this_data points to the constant-pool information for the current + constant-pool entry */ + + unsigned char *this_data = bytes + offsets[index]; + + switch (this_tag) + { + case JV_CONSTANT_Utf8: + { + int len = get2u (this_data); + char *s = ((char*) this_data)+2; + pool_tags[index] = JV_CONSTANT_Utf8; + + if (! rewrite) + { + pool_data[index].utf8 = _Jv_makeUtf8Const (s, len); + break; + } + + // If REWRITE is set, it is because some other tag needs this + // utf8-entry for type information: it is a class or a + // signature. Thus, we translate /'s to .'s in order to + // accomondate gcj's internal representation. + char *buffer = (char*) __builtin_alloca (len); + for (int i = 0; i < len; i++) + { + if (s[i] == '/') + buffer[i] = '.'; + else + buffer[i] = s[i]; + } + pool_data[index].utf8 = _Jv_makeUtf8Const (buffer, len); + } + break; + + case JV_CONSTANT_Class: + { + int utf_index = get2u (this_data); + check_tag (utf_index, JV_CONSTANT_Utf8); + prepare_pool_entry (utf_index, JV_CONSTANT_Utf8); + + if (verify) + verify_classname (pool_data[utf_index].utf8); + + pool_data[index].utf8 = pool_data[utf_index].utf8; + pool_tags[index] = JV_CONSTANT_Class; + } + break; + + case JV_CONSTANT_String: + // already handled before... + break; + + case JV_CONSTANT_Fieldref: + case JV_CONSTANT_Methodref: + case JV_CONSTANT_InterfaceMethodref: + { + int class_index = get2u (this_data); + int nat_index = get2u (this_data+2); + + check_tag (class_index, JV_CONSTANT_Class); + prepare_pool_entry (class_index, JV_CONSTANT_Class); + + check_tag (nat_index, JV_CONSTANT_NameAndType); + prepare_pool_entry (nat_index, JV_CONSTANT_NameAndType); + + // here, verify the signature and identifier name + if (verify) + { + _Jv_ushort name_index, type_index; + _Jv_loadIndexes (&pool_data[nat_index], + name_index, type_index); + + if (this_tag == JV_CONSTANT_Fieldref) + verify_field_signature (pool_data[type_index].utf8); + else + verify_method_signature (pool_data[type_index].utf8); + + _Jv_Utf8Const* name = pool_data[name_index].utf8; + + if (this_tag != JV_CONSTANT_Fieldref + && ( _Jv_equalUtf8Consts (name, clinit_name) + || _Jv_equalUtf8Consts (name, init_name))) + /* ignore */; + else + verify_identifier (pool_data[name_index].utf8); + } + + _Jv_storeIndexes (&pool_data[index], class_index, nat_index); + pool_tags[index] = this_tag; + } + break; + + case JV_CONSTANT_NameAndType: + { + _Jv_ushort name_index = get2u (this_data); + _Jv_ushort type_index = get2u (this_data+2); + + check_tag (name_index, JV_CONSTANT_Utf8); + prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false); + check_tag (type_index, JV_CONSTANT_Utf8); + prepare_pool_entry (type_index, JV_CONSTANT_Utf8); + + _Jv_storeIndexes (&pool_data[index], name_index, type_index); + pool_tags[index] = JV_CONSTANT_NameAndType; + } + break; + + case JV_CONSTANT_Float: + { + jfloat f = java::lang::Float::intBitsToFloat ((jint) get4 (this_data)); + _Jv_storeFloat (&pool_data[index], f); + pool_tags[index] = JV_CONSTANT_Float; + } + break; + + case JV_CONSTANT_Integer: + { + int i = get4 (this_data); + _Jv_storeInt (&pool_data[index], i); + pool_tags[index] = JV_CONSTANT_Integer; + } + break; + + case JV_CONSTANT_Double: + { + jdouble d + = java::lang::Double::longBitsToDouble ((jlong) get8 (this_data)); + _Jv_storeDouble (&pool_data[index], d); + pool_tags[index] = JV_CONSTANT_Double; + } + break; + + case JV_CONSTANT_Long: + { + jlong i = get8 (this_data); + _Jv_storeLong (&pool_data[index], i); + pool_tags[index] = JV_CONSTANT_Long; + } + break; + + default: + throw_class_format_error ("erroneous constant pool tag"); + } +} + + +void +_Jv_ClassReader::handleClassBegin (int access_flags, int this_class, int super_class) +{ + using namespace java::lang::reflect; + + unsigned char *pool_tags = (unsigned char*) def->constants.tags; + _Jv_word *pool_data = def->constants.data; + + check_tag (this_class, JV_CONSTANT_Class); + _Jv_Utf8Const *loadedName = pool_data[this_class].utf8; + + // was ClassLoader.defineClass called with an expected class name? + if (def->name == 0) + { + jclass orig = def->loader->findLoadedClass(loadedName->toString()); + + if (orig == 0) + { + def->name = loadedName; + } + else + { + jstring msg = JvNewStringUTF ("anonymous " + "class data denotes " + "existing class "); + msg = msg->concat (orig->getName ()); + + throw_no_class_def_found_error (msg); + } + } + + // assert that the loaded class has the expected name, 5.3.5 + else if (! _Jv_equalUtf8Consts (loadedName, def->name)) + { + jstring msg = JvNewStringUTF ("loaded class "); + msg = msg->concat (def->getName ()); + msg = msg->concat (_Jv_NewStringUTF (" was in fact named ")); + jstring klass_name = loadedName->toString(); + msg = msg->concat (klass_name); + + throw_no_class_def_found_error (msg); + } + + def->accflags = access_flags | java::lang::reflect::Modifier::INTERPRETED; + pool_data[this_class].clazz = def; + pool_tags[this_class] = JV_CONSTANT_ResolvedClass; + + if (super_class == 0) + { + // Note that this is ok if we are defining java.lang.Object. + // But there is no way to have this class be interpreted. + throw_class_format_error ("no superclass reference"); + } + + def->state = JV_STATE_PRELOADING; + + // Register this class with its defining loader as well (despite the + // name of the function we're calling), so that super class lookups + // work properly. If there is an error, our caller will unregister + // this class from the class loader. Also, we don't need to hold a + // lock here, as our caller has acquired it. + _Jv_RegisterInitiatingLoader (def, def->loader); + + // Note that we found a name so that unregistration can happen if + // needed. + *found_name = def->name; + + if (super_class != 0) + { + // Load the superclass. + check_tag (super_class, JV_CONSTANT_Class); + _Jv_Utf8Const* super_name = pool_data[super_class].utf8; + + // Load the superclass using our defining loader. + jclass the_super = _Jv_FindClass (super_name, def->loader); + + // This will establish that we are allowed to be a subclass, + // and check for class circularity error. + checkExtends (def, the_super); + + // Note: for an interface we will find Object as the + // superclass. We still check it above to ensure class file + // validity, but we simply assign `null' to the actual field in + // this case. + def->superclass = (((access_flags & Modifier::INTERFACE)) + ? NULL : the_super); + pool_data[super_class].clazz = the_super; + pool_tags[super_class] = JV_CONSTANT_ResolvedClass; + } + + // Now we've come past the circularity problem, we can + // now say that we're loading. + + def->state = JV_STATE_LOADING; + def->notifyAll (); +} + +///// Implements the checks described in sect. 5.3.5.3 +void +_Jv_ClassReader::checkExtends (jclass sub, jclass super) +{ + using namespace java::lang::reflect; + + _Jv_Linker::wait_for_state (super, JV_STATE_LOADING); + + // Having an interface or a final class as a superclass is no good. + if ((super->accflags & (Modifier::INTERFACE | Modifier::FINAL)) != 0) + { + throw_incompatible_class_change_error (sub->getName ()); + } + + // If the super class is not public, we need to check some more. + if ((super->accflags & Modifier::PUBLIC) == 0) + { + // With package scope, the classes must have the same class + // loader. + if ( sub->loader != super->loader + || !_Jv_ClassNameSamePackage (sub->name, super->name)) + { + throw_incompatible_class_change_error (sub->getName ()); + } + } + + for (; super != 0; super = super->getSuperclass ()) + { + if (super == sub) + throw_class_circularity_error (sub->getName ()); + } +} + + + +void _Jv_ClassReader::handleInterfacesBegin (int count) +{ + def->interfaces = (jclass*) _Jv_AllocRawObj (count*sizeof (jclass)); + def->interface_count = count; +} + +void _Jv_ClassReader::handleInterface (int if_number, int offset) +{ + _Jv_word * pool_data = def->constants.data; + unsigned char * pool_tags = (unsigned char*) def->constants.tags; + + jclass the_interface; + + if (pool_tags[offset] == JV_CONSTANT_Class) + { + _Jv_Utf8Const* name = pool_data[offset].utf8; + the_interface = _Jv_FindClass (name, def->loader); + } + else if (pool_tags[offset] == JV_CONSTANT_ResolvedClass) + { + the_interface = pool_data[offset].clazz; + } + else + { + throw_no_class_def_found_error ("erroneous constant pool tag"); + } + + // checks the validity of the_interface, and that we are in fact + // allowed to implement that interface. + checkImplements (def, the_interface); + + pool_data[offset].clazz = the_interface; + pool_tags[offset] = JV_CONSTANT_ResolvedClass; + + def->interfaces[if_number] = the_interface; +} + +void +_Jv_ClassReader::checkImplements (jclass sub, jclass super) +{ + using namespace java::lang::reflect; + + // well, it *must* be an interface + if ((super->accflags & Modifier::INTERFACE) == 0) + { + throw_incompatible_class_change_error (sub->getName ()); + } + + // if it has package scope, it must also be defined by the + // same loader. + if ((super->accflags & Modifier::PUBLIC) == 0) + { + if ( sub->loader != super->loader + || !_Jv_ClassNameSamePackage (sub->name, super->name)) + { + throw_incompatible_class_change_error (sub->getName ()); + } + } + + // FIXME: add interface circularity check here + if (sub == super) + { + throw_class_circularity_error (sub->getName ()); + } +} + +void _Jv_ClassReader::handleFieldsBegin (int count) +{ + def->fields = (_Jv_Field*) _Jv_AllocRawObj (count * sizeof (_Jv_Field)); + def->field_count = count; + def_interp->field_initializers + = (_Jv_ushort*) _Jv_AllocRawObj (count * sizeof (_Jv_ushort)); + for (int i = 0; i < count; i++) + def_interp->field_initializers[i] = (_Jv_ushort) 0; +} + +void _Jv_ClassReader::handleField (int field_no, + int flags, + int name, + int desc, + int *fieldmap) +{ + using namespace java::lang::reflect; + + _Jv_word *pool_data = def->constants.data; + + _Jv_Field *field = &def->fields[fieldmap[field_no]]; + _Jv_Utf8Const *field_name = pool_data[name].utf8; + + field->name = field_name; + + // Ignore flags we don't know about. + field->flags = flags & (Field::FIELD_MODIFIERS + | Modifier::SYNTHETIC + | Modifier::ENUM); + + _Jv_Utf8Const* sig = pool_data[desc].utf8; + + if (verify) + { + verify_identifier (field_name); + + for (int i = 0; i < field_no; ++i) + { + if (_Jv_equalUtf8Consts (field_name, def->fields[fieldmap[i]].name) + && _Jv_equalUtf8Consts (sig, + // We know the other fields are + // unresolved. + (_Jv_Utf8Const *) def->fields[i].type)) + throw_class_format_error ("duplicate field name"); + } + + // At most one of PUBLIC, PRIVATE, or PROTECTED is allowed. + if (1 < ( ((field->flags & Modifier::PUBLIC) ? 1 : 0) + +((field->flags & Modifier::PRIVATE) ? 1 : 0) + +((field->flags & Modifier::PROTECTED) ? 1 : 0))) + throw_class_format_error ("erroneous field access flags"); + + // FIXME: JVM spec S4.5: Verify ACC_FINAL and ACC_VOLATILE are not + // both set. Verify modifiers for interface fields. + + } + + if (verify) + verify_field_signature (sig); + + // field->type is really a jclass, but while it is still + // unresolved we keep an _Jv_Utf8Const* instead. + field->type = (jclass) sig; + field->flags |= _Jv_FIELD_UNRESOLVED_FLAG; + field->u.boffset = 0; +} + + +void _Jv_ClassReader::handleConstantValueAttribute (int field_index, + int value, + bool *found_value) +{ + using namespace java::lang::reflect; + + _Jv_Field *field = &def->fields[field_index]; + + if ((field->flags & (Modifier::STATIC + | Modifier::FINAL + | Modifier::PRIVATE)) == 0) + { + // Ignore, as per vmspec #4.7.2 + return; + } + + // do not allow multiple constant fields! + if (*found_value) + throw_class_format_error ("field has multiple ConstantValue attributes"); + + *found_value = true; + def_interp->field_initializers[field_index] = value; + + /* type check the initializer */ + + if (value <= 0 || value >= pool_count) + throw_class_format_error ("erroneous ConstantValue attribute"); + + /* FIXME: do the rest */ +} + +void +_Jv_ClassReader::handleMethodsBegin (int count) +{ + def->methods = (_Jv_Method *) _Jv_AllocRawObj (sizeof (_Jv_Method) * count); + + def_interp->interpreted_methods + = (_Jv_MethodBase **) _Jv_AllocRawObj (sizeof (_Jv_MethodBase *) + * count); + + for (int i = 0; i < count; i++) + { + def_interp->interpreted_methods[i] = 0; + def->methods[i].index = (_Jv_ushort) -1; + } + + def->method_count = count; +} + + +void _Jv_ClassReader::handleMethod + (int mth_index, int accflags, int name, int desc) +{ + using namespace java::lang::reflect; + + _Jv_word *pool_data = def->constants.data; + _Jv_Method *method = &def->methods[mth_index]; + + check_tag (name, JV_CONSTANT_Utf8); + prepare_pool_entry (name, JV_CONSTANT_Utf8, false); + method->name = pool_data[name].utf8; + + check_tag (desc, JV_CONSTANT_Utf8); + prepare_pool_entry (desc, JV_CONSTANT_Utf8); + method->signature = pool_data[desc].utf8; + + // ignore unknown flags + method->accflags = accflags & (Method::METHOD_MODIFIERS + | Modifier::BRIDGE + | Modifier::SYNTHETIC + | Modifier::VARARGS); + + // Initialize... + method->ncode = 0; + method->throws = NULL; + + if (verify) + { + if (_Jv_equalUtf8Consts (method->name, clinit_name) + || _Jv_equalUtf8Consts (method->name, init_name)) + /* ignore */; + else + verify_identifier (method->name); + + verify_method_signature (method->signature); + + for (int i = 0; i < mth_index; ++i) + { + if (_Jv_equalUtf8Consts (method->name, def->methods[i].name) + && _Jv_equalUtf8Consts (method->signature, + def->methods[i].signature)) + throw_class_format_error ("duplicate method"); + } + + // At most one of PUBLIC, PRIVATE, or PROTECTED is allowed. + if (1 < ( ((method->accflags & Modifier::PUBLIC) ? 1 : 0) + +((method->accflags & Modifier::PRIVATE) ? 1 : 0) + +((method->accflags & Modifier::PROTECTED) ? 1 : 0))) + throw_class_format_error ("erroneous method access flags"); + + // FIXME: JVM spec S4.6: if ABSTRACT modifier is set, verify other + // flags are not set. Verify flags for interface methods. Verify + // modifiers for initializers. + } +} + +void _Jv_ClassReader::handleCodeAttribute + (int method_index, int max_stack, int max_locals, + int code_start, int code_length, int exc_table_length) +{ + int size = _Jv_InterpMethod::size (exc_table_length, code_length); + _Jv_InterpMethod *method = + (_Jv_InterpMethod*) (_Jv_AllocRawObj (size)); + + method->max_stack = max_stack; + method->max_locals = max_locals; + method->code_length = code_length; + method->exc_count = exc_table_length; + method->is_15 = is_15; + method->defining_class = def; + method->self = &def->methods[method_index]; + method->prepared = NULL; + method->line_table_len = 0; + method->line_table = NULL; +#ifdef DIRECT_THREADED + method->thread_count = 0; +#endif + + // grab the byte code! + memcpy ((void*) method->bytecode (), + (void*) (bytes+code_start), + code_length); + + def_interp->interpreted_methods[method_index] = method; + + if ((method->self->accflags & java::lang::reflect::Modifier::STATIC)) + { + // Precompute the ncode field for a static method. This lets us + // call a static method of an interpreted class from precompiled + // code without first resolving the class (that will happen + // during class initialization instead). + method->self->ncode = method->ncode (def); + } +} + +void _Jv_ClassReader::handleExceptionTableEntry + (int method_index, int exc_index, + int start_pc, int end_pc, int handler_pc, int catch_type) +{ + _Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *> + (def_interp->interpreted_methods[method_index]); + _Jv_InterpException *exc = method->exceptions (); + + exc[exc_index].start_pc.i = start_pc; + exc[exc_index].end_pc.i = end_pc; + exc[exc_index].handler_pc.i = handler_pc; + exc[exc_index].handler_type.i = catch_type; +} + +void _Jv_ClassReader::handleMethodsEnd () +{ + using namespace java::lang::reflect; + + for (int i = 0; i < def->method_count; i++) + { + _Jv_Method *method = &def->methods[i]; + if ((method->accflags & Modifier::NATIVE) != 0) + { + if (def_interp->interpreted_methods[i] != 0) + throw_class_format_error ("code provided for native method"); + else + { + _Jv_JNIMethod *m = (_Jv_JNIMethod *) + _Jv_AllocRawObj (sizeof (_Jv_JNIMethod)); + m->defining_class = def; + m->self = method; + m->function = NULL; + def_interp->interpreted_methods[i] = m; + + if ((method->accflags & Modifier::STATIC)) + { + // Precompute the ncode field for a static method. + // This lets us call a static method of an + // interpreted class from precompiled code without + // first resolving the class (that will happen + // during class initialization instead). + method->ncode = m->ncode (def); + } + } + } + else if ((method->accflags & Modifier::ABSTRACT) != 0) + { + if (def_interp->interpreted_methods[i] != 0) + throw_class_format_error ("code provided for abstract method"); + method->ncode = (void *) &_Jv_ThrowAbstractMethodError; + } + else + { + if (def_interp->interpreted_methods[i] == 0) + throw_class_format_error ("method with no code"); + } + } +} + +void _Jv_ClassReader::throw_class_format_error (const char *msg) +{ + jstring str; + if (def->name != NULL) + { + jsize mlen = strlen (msg); + unsigned char* data = (unsigned char*) def->name->chars(); + int ulen = def->name->len(); + unsigned char* limit = data + ulen; + jsize nlen = _Jv_strLengthUtf8 ((char *) data, ulen); + jsize len = nlen + mlen + 3; + str = JvAllocString(len); + jchar *chrs = JvGetStringChars(str); + while (data < limit) + *chrs++ = UTF8_GET(data, limit); + *chrs++ = ' '; + *chrs++ = '('; + for (;;) + { + char c = *msg++; + if (c == 0) + break; + *chrs++ = c & 0xFFFF; + } + *chrs++ = ')'; + } + else + str = JvNewStringLatin1 (msg); + ::throw_class_format_error (str); +} + +/** Here we define the exceptions that can be thrown */ + +static void +throw_no_class_def_found_error (jstring msg) +{ + throw (msg + ? new java::lang::NoClassDefFoundError (msg) + : new java::lang::NoClassDefFoundError); +} + +static void +throw_no_class_def_found_error (const char *msg) +{ + throw_no_class_def_found_error (JvNewStringLatin1 (msg)); +} + +static void +throw_class_format_error (jstring msg) +{ + throw (msg + ? new java::lang::ClassFormatError (msg) + : new java::lang::ClassFormatError); +} + +static void +throw_internal_error (const char *msg) +{ + throw new java::lang::InternalError (JvNewStringLatin1 (msg)); +} + +static void +throw_incompatible_class_change_error (jstring msg) +{ + throw new java::lang::IncompatibleClassChangeError (msg); +} + +static void +throw_class_circularity_error (jstring msg) +{ + throw new java::lang::ClassCircularityError (msg); +} + +#endif /* INTERPRETER */ + + + +/** This section takes care of verifying integrity of identifiers, + signatures, field ddescriptors, and class names */ + +#define UTF8_PEEK(PTR, LIMIT) \ + ({ unsigned char* xxkeep = (PTR); \ + int xxch = UTF8_GET(PTR,LIMIT); \ + PTR = xxkeep; xxch; }) + +/* Verify one element of a type descriptor or signature. */ +static unsigned char* +_Jv_VerifyOne (unsigned char* ptr, unsigned char* limit, bool void_ok) +{ + if (ptr >= limit) + return 0; + + int ch = UTF8_GET (ptr, limit); + + switch (ch) + { + case 'V': + if (! void_ok) + return 0; + + case 'S': case 'B': case 'I': case 'J': + case 'Z': case 'C': case 'F': case 'D': + break; + + case 'L': + { + unsigned char *start = ptr, *end; + do + { + if (ptr > limit) + return 0; + + end = ptr; + + if ((ch = UTF8_GET (ptr, limit)) == -1) + return 0; + + } + while (ch != ';'); + if (! _Jv_VerifyClassName (start, (unsigned short) (end-start))) + return 0; + } + break; + + case '[': + return _Jv_VerifyOne (ptr, limit, false); + break; + + default: + return 0; + } + + return ptr; +} + +/* Verification and loading procedures. */ +bool +_Jv_VerifyFieldSignature (_Jv_Utf8Const*sig) +{ + unsigned char* ptr = (unsigned char*) sig->chars(); + unsigned char* limit = ptr + sig->len(); + + ptr = _Jv_VerifyOne (ptr, limit, false); + + return ptr == limit; +} + +bool +_Jv_VerifyMethodSignature (_Jv_Utf8Const*sig) +{ + unsigned char* ptr = (unsigned char*) sig->chars(); + unsigned char* limit = ptr + sig->len(); + + if (ptr == limit || UTF8_GET(ptr,limit) != '(') + return false; + + while (ptr && UTF8_PEEK (ptr, limit) != ')') + ptr = _Jv_VerifyOne (ptr, limit, false); + + if (! ptr || UTF8_GET (ptr, limit) != ')') + return false; + + // get the return type + ptr = _Jv_VerifyOne (ptr, limit, true); + + return ptr == limit; +} + +/* We try to avoid calling the Character methods all the time, in + fact, they will only be called for non-standard things. */ +static __inline__ int +is_identifier_start (int c) +{ + unsigned int ch = (unsigned)c; + + if ((ch - 0x41U) < 29U) /* A ... Z */ + return 1; + if ((ch - 0x61U) < 29U) /* a ... z */ + return 1; + if (ch == 0x5FU) /* _ */ + return 1; + + return java::lang::Character::isJavaIdentifierStart ((jchar) ch); +} + +static __inline__ int +is_identifier_part (int c) +{ + unsigned int ch = (unsigned)c; + + if ((ch - 0x41U) < 29U) /* A ... Z */ + return 1; + if ((ch - 0x61U) < 29U) /* a ... z */ + return 1; + if ((ch - 0x30) < 10U) /* 0 .. 9 */ + return 1; + if (ch == 0x5FU || ch == 0x24U) /* _ $ */ + return 1; + + return java::lang::Character::isJavaIdentifierStart ((jchar) ch); +} + +bool +_Jv_VerifyIdentifier (_Jv_Utf8Const* name) +{ + unsigned char *ptr = (unsigned char*) name->chars(); + unsigned char *limit = (unsigned char*) name->limit(); + int ch; + + if ((ch = UTF8_GET (ptr, limit))==-1 + || ! is_identifier_start (ch)) + return false; + + while (ptr != limit) + { + if ((ch = UTF8_GET (ptr, limit))==-1 + || ! is_identifier_part (ch)) + return false; + } + return true; +} + +bool +_Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length) +{ + unsigned char *limit = ptr+length; + int ch; + + if ('[' == UTF8_PEEK (ptr, limit)) + { + unsigned char *end = _Jv_VerifyOne (++ptr, limit, false); + // _Jv_VerifyOne must leave us looking at the terminating nul + // byte. + if (! end || *end) + return false; + else + return true; + } + + next_level: + for (;;) { + if ((ch = UTF8_GET (ptr, limit))==-1) + return false; + if (! is_identifier_start (ch)) + return false; + for (;;) { + if (ptr == limit) + return true; + else if ((ch = UTF8_GET (ptr, limit))==-1) + return false; + else if (ch == '.') + goto next_level; + else if (! is_identifier_part (ch)) + return false; + } + } +} + +bool +_Jv_VerifyClassName (_Jv_Utf8Const *name) +{ + return _Jv_VerifyClassName ((unsigned char*)name->chars(), name->len()); +} + +/* Returns true, if NAME1 and NAME2 represent classes in the same + package. Neither NAME2 nor NAME2 may name an array type. */ +bool +_Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2) +{ + unsigned char* ptr1 = (unsigned char*) name1->chars(); + unsigned char* limit1 = (unsigned char*) name1->limit(); + + unsigned char* last1 = ptr1; + + // scan name1, and find the last occurrence of '.' + while (ptr1 < limit1) { + int ch1 = UTF8_GET (ptr1, limit1); + + if (ch1 == '.') + last1 = ptr1; + + else if (ch1 == -1) + return false; + } + + // Now the length of NAME1's package name is LEN. + int len = last1 - (unsigned char*) name1->chars(); + + // If this is longer than NAME2, then we're off. + if (len > name2->len()) + return false; + + // Then compare the first len bytes for equality. + if (memcmp ((void*) name1->chars(), (void*) name2->chars(), len) == 0) + { + // Check that there are no .'s after position LEN in NAME2. + + unsigned char* ptr2 = (unsigned char*) name2->chars() + len; + unsigned char* limit2 = (unsigned char*) name2->limit(); + + while (ptr2 < limit2) + { + int ch2 = UTF8_GET (ptr2, limit2); + if (ch2 == -1 || ch2 == '.') + return false; + } + return true; + } + return false; +} |