1 // defineclass.cc - defining a class from .class format.
3 /* Copyright (C) 1999, 2000 Red Hat, Inc.
5 This file is part of libgcj.
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
12 Author: Kresten Krab Thorup <krab@gnu.org>
14 Written using the online versions of Java Language Specification (1st
15 ed.) and The Java Virtual Machine Specification (2nd ed.).
17 Future work may include reading (and handling) attributes which are
18 currently being ignored ("InnerClasses", "LineNumber", etc...).
23 #include <java-interp.h>
27 #include <java-cpool.h>
30 #include <java/lang/Class.h>
31 #include <java/lang/Float.h>
32 #include <java/lang/Double.h>
33 #include <java/lang/Character.h>
34 #include <java/lang/LinkageError.h>
35 #include <java/lang/InternalError.h>
36 #include <java/lang/ClassFormatError.h>
37 #include <java/lang/NoClassDefFoundError.h>
38 #include <java/lang/ClassCircularityError.h>
39 #include <java/lang/ClassNotFoundException.h>
40 #include <java/lang/IncompatibleClassChangeError.h>
41 #include <java/lang/reflect/Modifier.h>
43 #define ClassClass _CL_Q34java4lang5Class
44 extern java::lang::Class ClassClass;
45 #define ClassObject _CL_Q34java4lang6Object
46 extern java::lang::Class ClassObject;
48 // we don't verify method names that match these.
49 static _Jv_Utf8Const *clinit_name = _Jv_makeUtf8Const ("<clinit>", 8);
50 static _Jv_Utf8Const *init_name = _Jv_makeUtf8Const ("<init>", 6);
53 // these go in some seperate functions, to avoid having _Jv_InitClass
54 // inserted all over the place.
55 static void throw_internal_error (char *msg)
56 __attribute__ ((__noreturn__));
57 static void throw_no_class_def_found_error (jstring msg)
58 __attribute__ ((__noreturn__));
59 static void throw_no_class_def_found_error (char *msg)
60 __attribute__ ((__noreturn__));
61 static void throw_class_format_error (jstring msg)
62 __attribute__ ((__noreturn__));
63 static void throw_class_format_error (char *msg)
64 __attribute__ ((__noreturn__));
65 static void throw_incompatible_class_change_error (jstring msg)
66 __attribute__ ((__noreturn__));
67 static void throw_class_circularity_error (jstring msg)
68 __attribute__ ((__noreturn__));
70 static jdouble long_bits_to_double (jlong);
71 static jfloat int_bits_to_float (jint);
74 * We define class reading using a class. It is practical, since then
75 * the entire class-reader can be a friend of class Class (it needs to
76 * write all it's different structures); but also because this makes it
77 * easy to make class definition reentrant, and thus two threads can be
78 * defining classes at the same time. This class (_Jv_ClassReader) is
79 * never exposed outside this file, so we don't have to worry about
80 * public or private members here.
83 struct _Jv_ClassReader {
85 // do verification? Currently, there is no option to disable this.
86 // This flag just controls the verificaiton done by the class loader;
87 // i.e., checking the integrity of the constant pool; and it is
88 // allways on. You always want this as far as I can see, but it also
89 // controls weither identifiers and type descriptors/signatures are
90 // verified as legal. This could be somewhat more expensive since it
91 // will call Characher.isJavaIdentifier{Start,Part} for each character
92 // in any identifier (field name or method name) it comes by. Thus,
93 // it might be useful to turn off this verification for classes that
94 // come from a trusted source. However, for GCJ, trusted classes are
95 // most likely to be linked in.
100 unsigned char *bytes;
103 // current input position
106 // the constant pool data
109 unsigned int *offsets;
111 // the class to define (see java-interp.h)
112 _Jv_InterpClass *def;
114 /* check that the given number of input bytes are available */
115 inline void check (int num)
118 throw_class_format_error ("Premature end of data");
121 /* skip a given number of bytes in input */
122 inline void skip (int num)
128 /* read an unsignend 1-byte unit */
129 inline static jint get1u (unsigned char* bytes)
134 /* read an unsigned 1-byte unit */
135 inline jint read1u ()
138 return get1u (bytes+pos-1);
141 /* read an unsigned 2-byte unit */
142 inline static jint get2u (unsigned char *bytes)
144 return (((jint)bytes[0]) << 8) | ((jint)bytes[1]);
147 /* read an unsigned 2-byte unit */
148 inline jint read2u ()
151 return get2u (bytes+pos-2);
154 /* read a 4-byte unit */
155 static jint get4 (unsigned char *bytes)
157 return (((jint)bytes[0]) << 24)
158 | (((jint)bytes[1]) << 16)
159 | (((jint)bytes[2]) << 8)
160 | (((jint)bytes[3]) << 0);
163 /* read a 4-byte unit, (we don't do that quite so often) */
167 return get4 (bytes+pos-4);
170 /* read a 8-byte unit */
171 static jlong get8 (unsigned char* bytes)
173 return (((jlong)bytes[0]) << 56)
174 | (((jlong)bytes[1]) << 48)
175 | (((jlong)bytes[2]) << 40)
176 | (((jlong)bytes[3]) << 32)
177 | (((jlong)bytes[4]) << 24)
178 | (((jlong)bytes[5]) << 16)
179 | (((jlong)bytes[6]) << 8)
180 | (((jlong)bytes[7]) << 0);
183 /* read a 8-byte unit */
184 inline jlong read8 ()
187 return get8 (bytes+pos-8);
190 inline void check_tag (int index, char expected_tag)
193 || index > pool_count
194 || tags[index] != expected_tag)
195 throw_class_format_error ("erroneous constant pool tag");
198 _Jv_ClassReader (jclass klass, jbyteArray data, jint offset, jint length)
200 if (klass == 0 || length < 0 || offset+length > data->length)
201 throw_internal_error ("arguments to _Jv_DefineClass");
204 bytes = (unsigned char*) (elements (data)+offset);
207 def = (_Jv_InterpClass*) klass;
210 /** and here goes the parser members defined out-of-line */
212 void read_constpool ();
213 void prepare_pool_entry (int index, unsigned char tag);
215 void read_methods ();
216 void read_one_class_attribute ();
217 void read_one_method_attribute (int method);
218 void read_one_code_attribute (int method);
219 void read_one_field_attribute (int field);
221 /** check an utf8 entry, without creating a Utf8Const object */
222 bool is_attribute_name (int index, char *name);
224 /** here goes the class-loader members defined out-of-line */
225 void handleConstantPool ();
226 void handleClassBegin (int, int, int);
227 void handleInterfacesBegin (int);
228 void handleInterface (int, int);
229 void handleFieldsBegin (int);
230 void handleField (int, int, int, int);
231 void handleFieldsEnd ();
232 void handleConstantValueAttribute (int,int);
233 void handleMethodsBegin (int);
234 void handleMethod (int, int, int, int);
235 void handleMethodsEnd ();
236 void handleCodeAttribute (int, int, int, int, int, int);
237 void handleExceptionTableEntry (int, int, int, int, int, int);
239 void checkExtends (jclass sub, jclass super);
240 void checkImplements (jclass sub, jclass super);
243 * FIXME: we should keep a hash table of utf8-strings, since many will
244 * be the same. It's a little tricky, however, because the hash table
245 * needs to interact gracefully with the garbage collector. Much
246 * memory is to be saved by this, however! perhaps the improvement
247 * could be implemented in prims.cc (_Jv_makeUtf8Const), since it
248 * computes the hash value anyway.
252 /* This is used for the isJavaIdentifierStart & isJavaIdentifierPart
253 methods, so we avoid doing _Jv_InitClass all the time */
255 static const java::lang::Character *character = 0;
256 static void prepare_character ();
259 _Jv_DefineClass (jclass klass, jbyteArray data, jint offset, jint length)
262 prepare_character ();
264 _Jv_ClassReader reader (klass, data, offset, length);
270 /** put it after _Jv_DefineClass, so it doesn't get inlined */
271 static void prepare_character ()
273 character = new java::lang::Character ('!');
277 /** This section defines the parsing/scanning of the class data */
280 _Jv_ClassReader::parse ()
282 int magic = read4 ();
284 /* FIXME: Decide which range of version numbers to allow */
286 /* int minor_version = */ read2u ();
287 /* int major_verson = */ read2u ();
289 if (magic != (int) 0xCAFEBABE)
290 throw_class_format_error ("bad magic number");
292 pool_count = read2u ();
296 int access_flags = read2u ();
297 int this_class = read2u ();
298 int super_class = read2u ();
300 check_tag (this_class, JV_CONSTANT_Class);
301 if (super_class != 0)
302 check_tag (super_class, JV_CONSTANT_Class);
304 handleClassBegin (access_flags, this_class, super_class);
306 int interfaces_count = read2u ();
308 handleInterfacesBegin (interfaces_count);
310 for (int i = 0; i < interfaces_count; i++)
312 int iface = read2u ();
313 check_tag (iface, JV_CONSTANT_Class);
314 handleInterface (i, iface);
320 int attributes_count = read2u ();
322 for (int i = 0; i < attributes_count; i++)
324 read_one_class_attribute ();
328 throw_class_format_error ("unused data before end of file");
330 // tell everyone we're done.
331 def->state = JV_STATE_LOADED;
336 void _Jv_ClassReader::read_constpool ()
338 tags = (unsigned char*) _Jv_AllocBytesChecked (pool_count);
339 offsets = (unsigned int *) _Jv_AllocBytesChecked (sizeof (int)
342 /** first, we scan the constant pool, collecting tags and offsets */
343 tags[0] = JV_CONSTANT_Undefined;
345 for (int c = 1; c < pool_count; c++)
352 case JV_CONSTANT_String:
353 case JV_CONSTANT_Class:
357 case JV_CONSTANT_Fieldref:
358 case JV_CONSTANT_Methodref:
359 case JV_CONSTANT_InterfaceMethodref:
360 case JV_CONSTANT_NameAndType:
361 case JV_CONSTANT_Integer:
362 case JV_CONSTANT_Float:
366 case JV_CONSTANT_Double:
367 case JV_CONSTANT_Long:
369 tags[++c] = JV_CONSTANT_Undefined;
372 case JV_CONSTANT_Utf8:
379 case JV_CONSTANT_Unicode:
380 throw_class_format_error ("unicode not supported");
384 throw_class_format_error ("erroneous constant pool tag");
388 handleConstantPool ();
392 void _Jv_ClassReader::read_fields ()
394 int fields_count = read2u ();
395 handleFieldsBegin (fields_count);
397 for (int i = 0; i < fields_count; i++)
399 int access_flags = read2u ();
400 int name_index = read2u ();
401 int descriptor_index = read2u ();
402 int attributes_count = read2u ();
404 check_tag (name_index, JV_CONSTANT_Utf8);
405 prepare_pool_entry (name_index, JV_CONSTANT_Utf8);
407 check_tag (descriptor_index, JV_CONSTANT_Utf8);
408 prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
410 handleField (i, access_flags, name_index, descriptor_index);
412 for (int j = 0; j < attributes_count; j++)
414 read_one_field_attribute (i);
422 _Jv_ClassReader::is_attribute_name (int index, char *name)
424 check_tag (index, JV_CONSTANT_Utf8);
425 int len = get2u (bytes+offsets[index]);
426 if (len != (int) strlen (name))
429 return !memcmp (bytes+offsets[index]+2, name, len);
432 void _Jv_ClassReader::read_one_field_attribute (int field_index)
434 int name = read2u ();
435 int length = read4 ();
437 if (is_attribute_name (name, "ConstantValue"))
443 && (tags[cv] == JV_CONSTANT_Integer
444 || tags[cv] == JV_CONSTANT_Float
445 || tags[cv] == JV_CONSTANT_Long
446 || tags[cv] == JV_CONSTANT_Double
447 || tags[cv] == JV_CONSTANT_String))
449 handleConstantValueAttribute (field_index, cv);
453 throw_class_format_error ("erroneous ConstantValue attribute");
457 throw_class_format_error ("erroneous ConstantValue attribute");
466 void _Jv_ClassReader::read_methods ()
468 int methods_count = read2u ();
470 handleMethodsBegin (methods_count);
472 for (int i = 0; i < methods_count; i++)
474 int access_flags = read2u ();
475 int name_index = read2u ();
476 int descriptor_index = read2u ();
477 int attributes_count = read2u ();
479 check_tag (name_index, JV_CONSTANT_Utf8);
480 prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
482 check_tag (name_index, JV_CONSTANT_Utf8);
483 prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
485 handleMethod (i, access_flags, name_index,
488 for (int j = 0; j < attributes_count; j++)
490 read_one_method_attribute (i);
497 void _Jv_ClassReader::read_one_method_attribute (int method_index)
499 int name = read2u ();
500 int length = read4 ();
502 if (is_attribute_name (name, "Exceptions"))
504 /* we ignore this for now */
508 else if (is_attribute_name (name, "Code"))
511 int max_stack = read2u ();
512 int max_locals = read2u ();
513 int code_length = read4 ();
515 int code_start = pos;
517 int exception_table_length = read2u ();
519 handleCodeAttribute (method_index,
520 max_stack, max_locals,
521 code_start, code_length,
522 exception_table_length);
525 for (int i = 0; i < exception_table_length; i++)
527 int start_pc = read2u ();
528 int end_pc = read2u ();
529 int handler_pc = read2u ();
530 int catch_type = read2u ();
532 if (start_pc > end_pc
534 || end_pc >= code_length
535 || handler_pc >= code_length)
536 throw_class_format_error ("erroneous exception handler info");
538 if (! (tags[catch_type] == JV_CONSTANT_Class
539 || tags[catch_type] == 0))
541 throw_class_format_error ("erroneous exception handler info");
544 handleExceptionTableEntry (method_index,
553 int attributes_count = read2u ();
555 for (int i = 0; i < attributes_count; i++)
557 read_one_code_attribute (method_index);
560 if ((pos - start_off) != length)
561 throw_class_format_error ("code attribute too short");
566 /* ignore unknown attributes */
571 void _Jv_ClassReader::read_one_code_attribute (int /*method*/)
573 /* ignore for now, ... later we may want to pick up
574 line number information, for debugging purposes;
575 in fact, the whole debugger issue is open! */
577 /* int name = */ read2u ();
578 int length = read4 ();
583 void _Jv_ClassReader::read_one_class_attribute ()
585 /* we also ignore the class attributes, ...
586 some day we'll add inner-classes support. */
588 /* int name = */ read2u ();
589 int length = read4 ();
596 /* this section defines the semantic actions of the parser */
598 void _Jv_ClassReader::handleConstantPool ()
600 /** now, we actually define the class' constant pool */
602 // the pool is scanned explicitly by the collector
603 jbyte *pool_tags = (jbyte*) _Jv_AllocBytesChecked (pool_count);
605 = (_Jv_word*) _Jv_AllocBytesChecked (pool_count * sizeof (_Jv_word));
607 def->constants.tags = pool_tags;
608 def->constants.data = pool_data;
609 def->constants.size = pool_count;
611 // Here we make a pass to collect the strings! We do this, because
612 // internally in the GCJ runtime, classes are encoded with .'s not /'s.
613 // Therefore, we first collect the strings, and then translate the rest
614 // of the utf8-entries (thus not representing strings) from /-notation
616 for (int i = 1; i < pool_count; i++)
618 if (tags[i] == JV_CONSTANT_String)
620 unsigned char* str_data = bytes + offsets [i];
621 int utf_index = get2u (str_data);
622 check_tag (utf_index, JV_CONSTANT_Utf8);
623 unsigned char *utf_data = bytes + offsets[utf_index];
624 int len = get2u (utf_data);
625 pool_data[i].utf8 = _Jv_makeUtf8Const ((char*)(utf_data+2), len);
626 pool_tags[i] = JV_CONSTANT_String;
630 pool_tags[i] = JV_CONSTANT_Undefined;
634 // and now, we scan everything else but strings & utf8-entries. This
635 // leaves out those utf8-entries which are not used; which will be left
636 // with a tag of JV_CONSTANT_Undefined in the class definition.
637 for (int index = 1; index < pool_count; index++)
641 case JV_CONSTANT_Undefined:
642 case JV_CONSTANT_String:
643 case JV_CONSTANT_Utf8:
647 prepare_pool_entry (index, tags[index]);
653 /* this is a recursive procedure, which will prepare pool entries as needed.
654 Which is how we avoid initializing those entries which go unused. */
656 _Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag)
658 /* these two, pool_data and pool_tags, point into the class
659 structure we are currently defining */
661 unsigned char *pool_tags = (unsigned char*) def->constants.tags;
662 _Jv_word *pool_data = def->constants.data;
664 /* this entry was already prepared */
665 if (pool_tags[index] == this_tag)
668 /* this_data points to the constant-pool information for the current
669 constant-pool entry */
671 unsigned char *this_data = bytes + offsets[index];
675 case JV_CONSTANT_Utf8:
677 // If we came here, it is because some other tag needs this
678 // utf8-entry for type information! Thus, we translate /'s to .'s in
679 // order to accomondate gcj's internal representation.
681 int len = get2u (this_data);
682 char *buffer = (char*) alloca (len);
683 char *s = ((char*) this_data)+2;
685 /* FIXME: avoid using a buffer here */
686 for (int i = 0; i < len; i++)
691 buffer[i] = (char) s[i];
694 pool_data[index].utf8 = _Jv_makeUtf8Const (buffer, len);
695 pool_tags[index] = JV_CONSTANT_Utf8;
699 case JV_CONSTANT_Class:
701 int utf_index = get2u (this_data);
702 check_tag (utf_index, JV_CONSTANT_Utf8);
703 prepare_pool_entry (utf_index, JV_CONSTANT_Utf8);
706 _Jv_VerifyClassName (pool_data[utf_index].utf8);
708 pool_data[index].utf8 = pool_data[utf_index].utf8;
709 pool_tags[index] = JV_CONSTANT_Class;
713 case JV_CONSTANT_String:
714 // already handled before...
717 case JV_CONSTANT_Fieldref:
718 case JV_CONSTANT_Methodref:
719 case JV_CONSTANT_InterfaceMethodref:
721 int class_index = get2u (this_data);
722 int nat_index = get2u (this_data+2);
724 check_tag (class_index, JV_CONSTANT_Class);
725 prepare_pool_entry (class_index, JV_CONSTANT_Class);
727 check_tag (nat_index, JV_CONSTANT_NameAndType);
728 prepare_pool_entry (nat_index, JV_CONSTANT_NameAndType);
730 // here, verify the signature and identifier name
733 _Jv_ushort name_index, type_index;
734 _Jv_loadIndexes (&pool_data[nat_index],
735 name_index, type_index);
737 if (this_tag == JV_CONSTANT_Fieldref)
738 _Jv_VerifyFieldSignature (pool_data[type_index].utf8);
740 _Jv_VerifyMethodSignature (pool_data[type_index].utf8);
742 _Jv_Utf8Const* name = pool_data[name_index].utf8;
744 if (this_tag != JV_CONSTANT_Fieldref
745 && ( _Jv_equalUtf8Consts (name, clinit_name)
746 || _Jv_equalUtf8Consts (name, init_name)))
749 _Jv_VerifyIdentifier (pool_data[name_index].utf8);
752 _Jv_storeIndexes (&pool_data[index], class_index, nat_index);
753 pool_tags[index] = this_tag;
757 case JV_CONSTANT_NameAndType:
759 _Jv_ushort name_index = get2u (this_data);
760 _Jv_ushort type_index = get2u (this_data+2);
762 check_tag (name_index, JV_CONSTANT_Utf8);
763 prepare_pool_entry (name_index, JV_CONSTANT_Utf8);
765 check_tag (type_index, JV_CONSTANT_Utf8);
766 prepare_pool_entry (type_index, JV_CONSTANT_Utf8);
768 _Jv_storeIndexes (&pool_data[index], name_index, type_index);
769 pool_tags[index] = JV_CONSTANT_NameAndType;
773 case JV_CONSTANT_Float:
775 jfloat f = int_bits_to_float ((jint) get4 (this_data));
776 _Jv_storeFloat (&pool_data[index], f);
777 pool_tags[index] = JV_CONSTANT_Float;
781 case JV_CONSTANT_Integer:
783 int i = get4 (this_data);
784 _Jv_storeInt (&pool_data[index], i);
785 pool_tags[index] = JV_CONSTANT_Integer;
789 case JV_CONSTANT_Double:
791 jdouble d = long_bits_to_double ((jlong) get8 (this_data));
792 _Jv_storeDouble (&pool_data[index], d);
793 pool_tags[index] = JV_CONSTANT_Double;
797 case JV_CONSTANT_Long:
799 jlong i = get8 (this_data);
800 _Jv_storeLong (&pool_data[index], i);
801 pool_tags[index] = JV_CONSTANT_Long;
806 throw_class_format_error ("erroneous constant pool tag");
812 _Jv_ClassReader::handleClassBegin
813 (int access_flags, int this_class, int super_class)
815 using namespace java::lang::reflect;
817 unsigned char *pool_tags = (unsigned char*) def->constants.tags;
818 _Jv_word *pool_data = def->constants.data;
820 check_tag (this_class, JV_CONSTANT_Class);
821 _Jv_Utf8Const *loadedName = pool_data[this_class].utf8;
823 // was ClassLoader.defineClass called with an expected class name?
826 jclass orig = _Jv_FindClassInCache (loadedName, def->loader);
830 def->name = loadedName;
834 jstring msg = JvNewStringUTF ("anonymous "
835 "class data denotes "
837 msg = msg->concat (orig->getName ());
839 throw_no_class_def_found_error (msg);
843 // assert that the loaded class has the expected name, 5.3.5
844 else if (! _Jv_equalUtf8Consts (loadedName, def->name))
846 jstring msg = JvNewStringUTF ("loaded class ");
847 msg = msg->concat (def->getName ());
848 msg = msg->concat (_Jv_NewStringUTF (" was in fact named "));
849 jstring klass_name = _Jv_NewStringUTF (loadedName->data);
850 msg = msg->concat (klass_name);
852 throw_no_class_def_found_error (msg);
855 def->accflags = access_flags;
856 pool_data[this_class].clazz = def;
857 pool_tags[this_class] = JV_CONSTANT_ResolvedClass;
859 if (super_class == 0)
861 // interfaces have java.lang.Object as super.
862 if (access_flags & Modifier::INTERFACE)
864 def->superclass = (jclass)&ClassObject;
867 // FIXME: Consider this carefully!
868 else if (!_Jv_equalUtf8Consts (def->name, ClassObject.name))
870 throw_no_class_def_found_error ("loading java.lang.Object");
874 // In the pre-loading state, it can be looked up in the
875 // cache only by this thread! This allows the super-class
876 // to include references to this class.
878 def->state = JV_STATE_PRELOADING;
879 _Jv_RegisterClass (def);
881 if (super_class != 0)
883 // load the super class
884 check_tag (super_class, JV_CONSTANT_Class);
885 _Jv_Utf8Const* super_name = pool_data[super_class].utf8;
887 // load the super class using our defining loader
888 jclass the_super = _Jv_FindClass (super_name,
891 // This will establish that we are allowed to be a subclass,
892 // and check for class circularity error
893 checkExtends (def, the_super);
895 def->superclass = the_super;
896 pool_data[super_class].clazz = the_super;
897 pool_tags[super_class] = JV_CONSTANT_ResolvedClass;
900 // now we've come past the circularity problem, we can
901 // now say that we're loading...
903 def->state = JV_STATE_LOADING;
907 ///// implements the checks described in sect. 5.3.5.3
909 _Jv_ClassReader::checkExtends (jclass sub, jclass super)
911 using namespace java::lang::reflect;
913 // having an interface or a final class as a superclass is no good
914 if ((super->accflags & (Modifier::INTERFACE | Modifier::FINAL)) != 0)
916 throw_incompatible_class_change_error (sub->getName ());
919 // if the super class is not public, we need to check some more
920 if ((super->accflags & Modifier::PUBLIC) == 0)
922 // With package scope, the classes must have the same
924 if ( sub->loader != super->loader
925 || !_Jv_ClassNameSamePackage (sub->name, super->name))
927 throw_incompatible_class_change_error (sub->getName ());
931 for (; super != 0; super = super->superclass)
934 throw_class_circularity_error (sub->getName ());
940 void _Jv_ClassReader::handleInterfacesBegin (int count)
942 def->interfaces = (jclass*) _Jv_AllocBytesChecked (count*sizeof (jclass));
943 def->interface_count = count;
946 void _Jv_ClassReader::handleInterface (int if_number, int offset)
948 _Jv_word * pool_data = def->constants.data;
949 unsigned char * pool_tags = (unsigned char*) def->constants.tags;
951 jclass the_interface;
953 if (pool_tags[offset] == JV_CONSTANT_Class)
955 _Jv_Utf8Const* name = pool_data[offset].utf8;
956 the_interface = _Jv_FindClass (name, def->loader);
958 else if (pool_tags[offset] == JV_CONSTANT_ResolvedClass)
960 the_interface = pool_data[offset].clazz;
964 throw_no_class_def_found_error ("erroneous constant pool tag");
967 // checks the validity of the_interface, and that we are in fact
968 // allowed to implement that interface.
969 checkImplements (def, the_interface);
971 pool_data[offset].clazz = the_interface;
972 pool_tags[offset] = JV_CONSTANT_ResolvedClass;
974 def->interfaces[if_number] = the_interface;
978 _Jv_ClassReader::checkImplements (jclass sub, jclass super)
980 using namespace java::lang::reflect;
982 // well, it *must* be an interface
983 if ((super->accflags & Modifier::INTERFACE) == 0)
985 throw_incompatible_class_change_error (sub->getName ());
988 // if it has package scope, it must also be defined by the
990 if ((super->accflags & Modifier::PUBLIC) == 0)
992 if ( sub->loader != super->loader
993 || !_Jv_ClassNameSamePackage (sub->name, super->name))
995 throw_incompatible_class_change_error (sub->getName ());
999 // FIXME: add interface circularity check here
1002 throw_class_circularity_error (sub->getName ());
1006 void _Jv_ClassReader::handleFieldsBegin (int count)
1008 def->fields = (_Jv_Field*)
1009 _Jv_AllocBytesChecked (count * sizeof (_Jv_Field));
1010 def->field_count = count;
1011 def->field_initializers = (_Jv_ushort*)
1012 _Jv_AllocBytesChecked (count * sizeof (_Jv_ushort));
1013 for (int i = 0; i < count; i++)
1014 def->field_initializers[i] = (_Jv_ushort) 0;
1017 void _Jv_ClassReader::handleField (int field_no,
1022 using namespace java::lang::reflect;
1024 _Jv_word *pool_data = def->constants.data;
1026 _Jv_Field *field = &def->fields[field_no];
1027 _Jv_Utf8Const *field_name = pool_data[name].utf8;
1029 #ifndef COMPACT_FIELDS
1030 field->name = field_name;
1032 field->nameIndex = name;
1036 _Jv_VerifyIdentifier (field_name);
1038 // ignore flags we don't know about.
1039 field->flags = flags & Modifier::ALL_FLAGS;
1043 if (field->flags & (Modifier::SYNCHRONIZED
1045 | Modifier::INTERFACE
1046 | Modifier::ABSTRACT))
1047 throw_class_format_error ("erroneous field access flags");
1049 if (1 < ( ((field->flags & Modifier::PUBLIC) ? 1 : 0)
1050 +((field->flags & Modifier::PRIVATE) ? 1 : 0)
1051 +((field->flags & Modifier::PROTECTED) ? 1 : 0)))
1052 throw_class_format_error ("erroneous field access flags");
1055 _Jv_Utf8Const* sig = pool_data[desc].utf8;
1058 _Jv_VerifyFieldSignature (sig);
1060 // field->type is really a jclass, but while it is still
1061 // unresolved we keep an _Jv_Utf8Const* instead.
1062 field->type = (jclass) sig;
1063 field->flags |= _Jv_FIELD_UNRESOLVED_FLAG;
1064 field->u.boffset = 0;
1068 void _Jv_ClassReader::handleConstantValueAttribute (int field_index,
1071 using namespace java::lang::reflect;
1073 _Jv_Field *field = &def->fields[field_index];
1075 if ((field->flags & (Modifier::STATIC
1077 | Modifier::PRIVATE)) == 0)
1079 // Ignore, as per vmspec #4.7.2
1083 // do not allow multiple constant fields!
1084 if (field->flags & _Jv_FIELD_CONSTANT_VALUE)
1085 throw_class_format_error ("field has multiple ConstantValue attributes");
1087 field->flags |= _Jv_FIELD_CONSTANT_VALUE;
1088 def->field_initializers[field_index] = value;
1090 /* type check the initializer */
1092 if (value <= 0 || value >= pool_count)
1093 throw_class_format_error ("erroneous ConstantValue attribute");
1095 /* FIXME: do the rest */
1098 void _Jv_ClassReader::handleFieldsEnd ()
1100 using namespace java::lang::reflect;
1102 // We need to reorganize the fields so that the static ones are first,
1103 // to conform to GCJ class layout.
1106 int high = def->field_count-1;
1107 _Jv_Field *fields = def->fields;
1108 _Jv_ushort *inits = def->field_initializers;
1110 // this is kind of a raw version of quicksort.
1113 // go forward on low, while it's a static
1114 while (low < high && (fields[low].flags & Modifier::STATIC) != 0)
1117 // go backwards on high, while it's a non-static
1118 while (low < high && (fields[high].flags & Modifier::STATIC) == 0)
1124 _Jv_Field tmp = fields[low];
1125 _Jv_ushort itmp = inits[low];
1127 fields[low] = fields[high];
1128 inits[low] = inits[high];
1137 if ((fields[low].flags & Modifier::STATIC) != 0)
1140 def->static_field_count = low;
1145 void _Jv_ClassReader::handleMethodsBegin (int count)
1147 def->methods = (_Jv_Method*)
1148 _Jv_AllocBytesChecked (sizeof (_Jv_Method)*count);
1150 def->interpreted_methods = (_Jv_InterpMethod**)
1151 _Jv_AllocBytesChecked (sizeof (_Jv_InterpMethod*) * count);
1153 for (int i = 0; i < count; i++)
1154 def->interpreted_methods[i] = 0;
1156 def->method_count = count;
1160 void _Jv_ClassReader::handleMethod
1161 (int mth_index, int accflags, int name, int desc)
1163 using namespace java::lang::reflect;
1165 _Jv_word *pool_data = def->constants.data;
1166 _Jv_Method *method = &def->methods[mth_index];
1168 check_tag (name, JV_CONSTANT_Utf8);
1169 prepare_pool_entry (name, JV_CONSTANT_Utf8);
1170 method->name = pool_data[name].utf8;
1172 check_tag (desc, JV_CONSTANT_Utf8);
1173 prepare_pool_entry (desc, JV_CONSTANT_Utf8);
1174 method->signature = pool_data[desc].utf8;
1176 // ignore unknown flags
1177 method->accflags = accflags & Modifier::ALL_FLAGS;
1184 if (_Jv_equalUtf8Consts (method->name, clinit_name)
1185 || _Jv_equalUtf8Consts (method->name, init_name))
1188 _Jv_VerifyIdentifier (method->name);
1190 _Jv_VerifyMethodSignature (method->signature);
1192 if (method->accflags & (Modifier::VOLATILE
1193 | Modifier::TRANSIENT
1194 | Modifier::INTERFACE))
1195 throw_class_format_error ("erroneous method access flags");
1197 if (1 < ( ((method->accflags & Modifier::PUBLIC) ? 1 : 0)
1198 +((method->accflags & Modifier::PRIVATE) ? 1 : 0)
1199 +((method->accflags & Modifier::PROTECTED) ? 1 : 0)))
1200 throw_class_format_error ("erroneous method access flags");
1204 void _Jv_ClassReader::handleCodeAttribute
1205 (int method_index, int max_stack, int max_locals,
1206 int code_start, int code_length, int exc_table_length)
1208 int size = _Jv_InterpMethod::size (exc_table_length, code_length);
1209 _Jv_InterpMethod *method =
1210 (_Jv_InterpMethod*) (_Jv_AllocBytesChecked (size));
1212 method->max_stack = max_stack;
1213 method->max_locals = max_locals;
1214 method->code_length = code_length;
1215 method->exc_count = exc_table_length;
1216 method->defining_class = def;
1217 method->self = &def->methods[method_index];
1219 // grab the byte code!
1220 memcpy ((void*) method->bytecode (),
1221 (void*) (bytes+code_start),
1224 def->interpreted_methods[method_index] = method;
1226 /* that's all we do for now */
1229 void _Jv_ClassReader::handleExceptionTableEntry
1230 (int method_index, int exc_index,
1231 int start_pc, int end_pc, int handler_pc, int catch_type)
1233 _Jv_InterpMethod *method = def->interpreted_methods[method_index];
1234 _Jv_InterpException *exc = method->exceptions ();
1236 exc[exc_index].start_pc = start_pc;
1237 exc[exc_index].end_pc = end_pc;
1238 exc[exc_index].handler_pc = handler_pc;
1239 exc[exc_index].handler_type = catch_type;
1242 void _Jv_ClassReader::handleMethodsEnd ()
1244 using namespace java::lang::reflect;
1246 for (int i = 0; i < def->method_count; i++)
1248 _Jv_Method *method = &def->methods[i];
1249 if (method->accflags & (Modifier::NATIVE | Modifier::ABSTRACT))
1251 if (def->interpreted_methods[i] != 0)
1252 throw_class_format_error ("code provided "
1253 "for abstract or native method");
1257 if (def->interpreted_methods[i] == 0)
1258 throw_class_format_error ("abstract or native method "
1266 /** This section takes care of verifying integrity of identifiers,
1267 signatures, field ddescriptors, and class names */
1269 #define UTF8_PEEK(PTR, LIMIT) \
1270 ({ unsigned char* xxkeep = (PTR); \
1271 int xxch = UTF8_GET(PTR,LIMIT); \
1272 PTR = xxkeep; xxch; })
1274 /* verify one element of a type descriptor or signature */
1275 static unsigned char*
1276 _Jv_VerifyOne (unsigned char* ptr, unsigned char* limit, bool void_ok)
1281 int ch = UTF8_GET (ptr, limit);
1286 if (! void_ok) return 0;
1288 case 'S': case 'B': case 'I': case 'J':
1289 case 'Z': case 'C': case 'F': case 'D':
1294 unsigned char *start = ptr, *end;
1301 if ((ch = UTF8_GET (ptr, limit)) == -1)
1304 } while (ch != ';');
1305 _Jv_VerifyClassName (start, (unsigned short) (end-start));
1310 return _Jv_VerifyOne (ptr, limit, false);
1322 /** verification and loading procedures **/
1325 _Jv_VerifyFieldSignature (_Jv_Utf8Const*sig)
1327 unsigned char* ptr = (unsigned char*) sig->data;
1328 unsigned char* limit = ptr + sig->length;
1330 ptr = _Jv_VerifyOne (ptr, limit, false);
1333 throw_class_format_error ("erroneous type descriptor");
1337 _Jv_VerifyMethodSignature (_Jv_Utf8Const*sig)
1339 unsigned char* ptr = (unsigned char*) sig->data;
1340 unsigned char* limit = ptr + sig->length;
1343 throw_class_format_error ("erroneous type descriptor");
1345 if (UTF8_GET(ptr,limit) != '(')
1346 throw_class_format_error ("erroneous type descriptor");
1348 while (ptr && UTF8_PEEK (ptr, limit) != ')')
1349 ptr = _Jv_VerifyOne (ptr, limit, false);
1351 if (UTF8_GET (ptr, limit) != ')')
1352 throw_class_format_error ("erroneous type descriptor");
1354 // get the return type
1355 ptr = _Jv_VerifyOne (ptr, limit, true);
1358 throw_class_format_error ("erroneous type descriptor");
1364 /* we try to avoid calling the Character methods all the time,
1365 in fact, they will only be called for non-standard things */
1367 static __inline__ int
1368 is_identifier_start (int c)
1370 unsigned int ch = (unsigned)c;
1372 if ((ch - 0x41U) < 29U) /* A ... Z */
1374 if ((ch - 0x61U) < 29U) /* a ... z */
1376 if (ch == 0x5FU) /* _ */
1379 return character->isJavaIdentifierStart ((jchar) ch);
1382 static __inline__ int
1383 is_identifier_part (int c)
1385 unsigned int ch = (unsigned)c;
1387 if ((ch - 0x41U) < 29U) /* A ... Z */
1389 if ((ch - 0x61U) < 29U) /* a ... z */
1391 if ((ch - 0x30) < 10U) /* 0 .. 9 */
1393 if (ch == 0x5FU || ch == 0x24U) /* _ $ */
1396 return character->isJavaIdentifierStart ((jchar) ch);
1400 _Jv_VerifyIdentifier (_Jv_Utf8Const* name)
1402 unsigned char *ptr = (unsigned char*) name->data;
1403 unsigned char *limit = ptr + name->length;
1406 if ((ch = UTF8_GET (ptr, limit))==-1
1407 || ! is_identifier_start (ch))
1408 throw_class_format_error ("erroneous identifier");
1410 while (ptr != limit)
1412 if ((ch = UTF8_GET (ptr, limit))==-1
1413 || ! is_identifier_part (ch))
1414 throw_class_format_error ("erroneous identifier");
1420 _Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length)
1422 unsigned char *limit = ptr+length;
1425 if ('[' == UTF8_PEEK (ptr, limit))
1427 if (! _Jv_VerifyOne (++ptr, limit, false))
1428 throw_class_format_error ("erroneous class name");
1435 if ((ch = UTF8_GET (ptr, limit))==-1)
1436 throw_class_format_error ("erroneous class name");
1437 if (! is_identifier_start (ch))
1438 throw_class_format_error ("erroneous class name");
1442 else if ((ch = UTF8_GET (ptr, limit))==-1)
1443 throw_class_format_error ("erroneous class name");
1446 else if (! is_identifier_part (ch))
1447 throw_class_format_error ("erroneous class name");
1454 _Jv_VerifyClassName (_Jv_Utf8Const *name)
1456 _Jv_VerifyClassName ((unsigned char*)&name->data[0],
1457 (_Jv_ushort) name->length);
1461 /** returns true, if name1 and name2 represents classes in the same
1465 _Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2)
1467 unsigned char* ptr1 = (unsigned char*) name1->data;
1468 unsigned char* limit1 = ptr1 + name1->length;
1470 unsigned char* last1 = ptr1;
1472 // scan name1, and find the last occurrence of '.'
1473 while (ptr1 < limit1) {
1474 int ch1 = UTF8_GET (ptr1, limit1);
1483 // now the length of name1's package name is len
1484 int len = last1 - (unsigned char*) name1->data;
1486 // if this is longer than name2, then we're off
1487 if (len > name2->length)
1490 // then compare the first len bytes for equality
1491 if (memcmp ((void*) name1->data, (void*) name2->data, len) == 0)
1493 // check that there are no .'s after position len in name2
1495 unsigned char* ptr2 = (unsigned char*) name2->data + len;
1496 unsigned char* limit2 =
1497 (unsigned char*) name2->data + name2->length;
1499 while (ptr2 < limit2)
1501 int ch2 = UTF8_GET (ptr2, limit2);
1502 if (ch2 == -1 || ch2 == '.')
1512 /** Here we define the exceptions that can be thrown */
1515 throw_no_class_def_found_error (jstring msg)
1518 JvThrow (new java::lang::NoClassDefFoundError);
1520 JvThrow (new java::lang::NoClassDefFoundError (msg));
1524 throw_no_class_def_found_error (char *msg)
1526 throw_no_class_def_found_error (JvNewStringLatin1 (msg));
1530 throw_class_format_error (jstring msg)
1533 JvThrow (new java::lang::ClassFormatError);
1535 JvThrow (new java::lang::ClassFormatError (msg));
1539 throw_class_format_error (char *msg)
1541 throw_class_format_error (JvNewStringLatin1 (msg));
1545 throw_internal_error (char *msg)
1548 (new java::lang::InternalError (JvNewStringLatin1 (msg)));
1551 static jfloat int_bits_to_float (jint value)
1553 return java::lang::Float::intBitsToFloat (value);
1556 static jdouble long_bits_to_double (jlong value)
1558 return java::lang::Double::longBitsToDouble (value);
1561 static void throw_incompatible_class_change_error (jstring msg)
1563 JvThrow (new java::lang::IncompatibleClassChangeError (msg));
1566 static void throw_class_circularity_error (jstring msg)
1568 JvThrow (new java::lang::ClassCircularityError (msg));
1571 #endif /* INTERPRETER */