* c-ubsan.c (ubsan_instrument_bounds): Don't skip instrumenting
[official-gcc.git] / libjava / defineclass.cc
blobc7a32ccd919211b2862764627f42fc54e4f6f37f
1 // defineclass.cc - defining a class from .class format.
3 /* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2012
4 Free Software Foundation
6 This file is part of libgcj.
8 This software is copyrighted work licensed under the terms of the
9 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
10 details. */
12 /*
13 Author: Kresten Krab Thorup <krab@gnu.org>
15 Written using the online versions of Java Language Specification (1st
16 ed.) and The Java Virtual Machine Specification (2nd ed.).
18 Future work may include reading (and handling) attributes which are
19 currently being ignored ("InnerClasses", "LineNumber", etc...).
22 #include <config.h>
24 #include <java-interp.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <java-cpool.h>
29 #include <gcj/cni.h>
30 #include <execution.h>
32 #include <java/lang/Class.h>
33 #include <java/lang/Float.h>
34 #include <java/lang/Double.h>
35 #include <java/lang/Character.h>
36 #include <java/lang/LinkageError.h>
37 #include <java/lang/InternalError.h>
38 #include <java/lang/ClassFormatError.h>
39 #include <java/lang/NoClassDefFoundError.h>
40 #include <java/lang/ClassCircularityError.h>
41 #include <java/lang/IncompatibleClassChangeError.h>
42 #include <java/lang/reflect/Modifier.h>
43 #include <java/lang/reflect/Field.h>
44 #include <java/lang/reflect/Method.h>
45 #include <java/security/ProtectionDomain.h>
46 #include <java/io/DataOutputStream.h>
47 #include <java/io/ByteArrayOutputStream.h>
49 using namespace gcj;
51 #ifdef INTERPRETER
53 // these go in some separate functions, to avoid having _Jv_InitClass
54 // inserted all over the place.
55 static void throw_internal_error (const 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 (const char *msg)
60 __attribute__ ((__noreturn__));
61 static void throw_class_format_error (jstring msg)
62 __attribute__ ((__noreturn__));
63 static void throw_incompatible_class_change_error (jstring msg)
64 __attribute__ ((__noreturn__));
65 static void throw_class_circularity_error (jstring msg)
66 __attribute__ ((__noreturn__));
68 /**
69 * We define class reading using a class. It is practical, since then
70 * the entire class-reader can be a friend of class Class (it needs to
71 * write all it's different structures); but also because this makes it
72 * easy to make class definition reentrant, and thus two threads can be
73 * defining classes at the same time. This class (_Jv_ClassReader) is
74 * never exposed outside this file, so we don't have to worry about
75 * public or private members here.
78 struct _Jv_ClassReader
81 // do verification? Currently, there is no option to disable this.
82 // This flag just controls the verificaiton done by the class loader;
83 // i.e., checking the integrity of the constant pool; and it is
84 // allways on. You always want this as far as I can see, but it also
85 // controls weither identifiers and type descriptors/signatures are
86 // verified as legal. This could be somewhat more expensive since it
87 // will call Character.isJavaIdentifier{Start,Part} for each character
88 // in any identifier (field name or method name) it comes by. Thus,
89 // it might be useful to turn off this verification for classes that
90 // come from a trusted source. However, for GCJ, trusted classes are
91 // most likely to be linked in.
93 bool verify;
95 // original input data.
96 jbyteArray input_data;
97 jint input_offset;
99 // input data.
100 unsigned char *bytes;
101 int len;
103 // current input position
104 int pos;
106 // the constant pool data
107 int pool_count;
108 unsigned char *tags;
109 unsigned int *offsets;
111 // the class to define (see java-interp.h)
112 jclass def;
114 // the classes associated interpreter data.
115 _Jv_InterpClass *def_interp;
117 // The name we found.
118 _Jv_Utf8Const **found_name;
120 // True if this is a 1.5 class file.
121 bool is_15;
123 // Buffer holding extra reflection data.
124 ::java::io::ByteArrayOutputStream *reflection_data;
125 ::java::io::DataOutputStream *data_stream;
128 /* check that the given number of input bytes are available */
129 inline void check (int num)
131 if (pos + num > len)
132 throw_class_format_error ("Premature end of data");
135 /* skip a given number of bytes in input */
136 inline void skip (int num)
138 check (num);
139 pos += num;
142 /* read an unsigned 1-byte unit */
143 inline static jint get1u (unsigned char* bytes)
145 return bytes[0];
148 /* read an unsigned 1-byte unit */
149 inline jint read1u ()
151 skip (1);
152 return get1u (bytes+pos-1);
155 /* read an unsigned 2-byte unit */
156 inline static jint get2u (unsigned char *bytes)
158 return (((jint)bytes[0]) << 8) | ((jint)bytes[1]);
161 /* read an unsigned 2-byte unit */
162 inline jint read2u ()
164 skip (2);
165 return get2u (bytes+pos-2);
168 /* read a 4-byte unit */
169 static jint get4 (unsigned char *bytes)
171 return (((jint)bytes[0]) << 24)
172 | (((jint)bytes[1]) << 16)
173 | (((jint)bytes[2]) << 8)
174 | (((jint)bytes[3]) << 0);
177 /* read a 4-byte unit, (we don't do that quite so often) */
178 inline jint read4 ()
180 skip (4);
181 return get4 (bytes+pos-4);
184 /* read a 8-byte unit */
185 static jlong get8 (unsigned char* bytes)
187 return (((jlong)bytes[0]) << 56)
188 | (((jlong)bytes[1]) << 48)
189 | (((jlong)bytes[2]) << 40)
190 | (((jlong)bytes[3]) << 32)
191 | (((jlong)bytes[4]) << 24)
192 | (((jlong)bytes[5]) << 16)
193 | (((jlong)bytes[6]) << 8)
194 | (((jlong)bytes[7]) << 0);
197 /* read a 8-byte unit */
198 inline jlong read8 ()
200 skip (8);
201 return get8 (bytes+pos-8);
204 inline void check_tag (int index, char expected_tag)
206 if (index < 0
207 || index > pool_count
208 || tags[index] != expected_tag)
209 throw_class_format_error ("erroneous constant pool tag");
212 inline void verify_identifier (_Jv_Utf8Const* name)
214 if (! _Jv_VerifyIdentifier (name))
215 throw_class_format_error ("erroneous identifier");
218 inline void verify_classname (unsigned char* ptr, _Jv_ushort length)
220 if (! _Jv_VerifyClassName (ptr, length))
221 throw_class_format_error ("erroneous class name");
224 inline void verify_classname (_Jv_Utf8Const *name)
226 if (! _Jv_VerifyClassName (name))
227 throw_class_format_error ("erroneous class name");
230 inline void verify_field_signature (_Jv_Utf8Const *sig)
232 if (! _Jv_VerifyFieldSignature (sig))
233 throw_class_format_error ("erroneous type descriptor");
236 inline void verify_method_signature (_Jv_Utf8Const *sig)
238 if (! _Jv_VerifyMethodSignature (sig))
239 throw_class_format_error ("erroneous type descriptor");
242 ::java::io::DataOutputStream *get_reflection_stream ()
244 if (reflection_data == NULL)
246 reflection_data = new ::java::io::ByteArrayOutputStream();
247 data_stream = new ::java::io::DataOutputStream(reflection_data);
249 return data_stream;
252 _Jv_ClassReader (jclass klass, jbyteArray data, jint offset, jint length,
253 java::security::ProtectionDomain *pd,
254 _Jv_Utf8Const **name_result)
256 if (klass == 0 || length < 0 || offset+length > data->length)
257 throw_internal_error ("arguments to _Jv_DefineClass");
259 verify = true;
260 input_data = data;
261 input_offset = offset;
262 bytes = (unsigned char*) (elements (data)+offset);
263 len = length;
264 pos = 0;
265 is_15 = false;
267 def = klass;
268 found_name = name_result;
269 reflection_data = NULL;
270 data_stream = NULL;
272 def->size_in_bytes = -1;
273 def->vtable_method_count = -1;
274 def->engine = &_Jv_soleInterpreterEngine;
275 def->protectionDomain = pd;
278 /** and here goes the parser members defined out-of-line */
279 void parse ();
280 void read_constpool ();
281 void prepare_pool_entry (int index, unsigned char tag,
282 bool rewrite = true);
283 void read_fields ();
284 void read_methods ();
285 void read_one_class_attribute ();
286 void read_one_method_attribute (int method);
287 void read_one_code_attribute (int method);
288 void read_one_field_attribute (int field, bool *);
289 void throw_class_format_error (const char *msg);
291 void handleEnclosingMethod(int);
292 void handleGenericSignature(jv_attr_type, unsigned short, int);
293 void handleAnnotationElement();
294 void handleAnnotation();
295 void handleAnnotations();
296 void handleMemberAnnotations(jv_attr_type, int, int);
297 void handleAnnotationDefault(int, int);
298 void handleParameterAnnotations(int, int);
299 void finish_reflection_data ();
301 /** check an utf8 entry, without creating a Utf8Const object */
302 bool is_attribute_name (int index, const char *name);
304 /** return the value of a utf8 entry in the passed array */
305 int pool_Utf8_to_char_arr (int index, char **entry);
307 /** here goes the class-loader members defined out-of-line */
308 void handleConstantPool ();
309 void handleClassBegin (int, int, int);
310 void handleInterfacesBegin (int);
311 void handleInterface (int, int);
312 void handleFieldsBegin (int);
313 void handleField (int, int, int, int, int *);
314 void handleConstantValueAttribute (int, int, bool *);
315 void handleMethodsBegin (int);
316 void handleMethod (int, int, int, int);
317 void handleMethodsEnd ();
318 void handleCodeAttribute (int, int, int, int, int, int);
319 void handleExceptionTableEntry (int, int, int, int, int, int);
321 void checkExtends (jclass sub, jclass super);
322 void checkImplements (jclass sub, jclass super);
325 * FIXME: we should keep a hash table of utf8-strings, since many will
326 * be the same. It's a little tricky, however, because the hash table
327 * needs to interact gracefully with the garbage collector. Much
328 * memory is to be saved by this, however! perhaps the improvement
329 * could be implemented in prims.cc (_Jv_makeUtf8Const), since it
330 * computes the hash value anyway.
334 // Note that *NAME_RESULT will only be set if the class is registered
335 // with the class loader. This is how the caller can know whether
336 // unregistration is require.
337 void
338 _Jv_DefineClass (jclass klass, jbyteArray data, jint offset, jint length,
339 java::security::ProtectionDomain *pd,
340 _Jv_Utf8Const **name_result)
342 _Jv_ClassReader reader (klass, data, offset, length, pd, name_result);
343 reader.parse();
345 /* that's it! */
349 /** This section defines the parsing/scanning of the class data */
351 // Major and minor version numbers for various releases.
352 #define MAJOR_1_1 45
353 #define MINOR_1_1 3
354 #define MAJOR_1_2 46
355 #define MINOR_1_2 0
356 #define MAJOR_1_3 47
357 #define MINOR_1_3 0
358 #define MAJOR_1_4 48
359 #define MINOR_1_4 0
360 #define MAJOR_1_5 49
361 #define MINOR_1_5 0
362 #define MAJOR_1_6 50
363 #define MINOR_1_6 0
364 #define MAJOR_1_7 51
365 #define MINOR_1_7 0
367 void
368 _Jv_ClassReader::parse ()
370 int magic = read4 ();
371 if (magic != (int) 0xCAFEBABE)
372 throw_class_format_error ("bad magic number");
374 int minor_version = read2u ();
375 int major_version = read2u ();
376 if (major_version < MAJOR_1_1 || major_version > MAJOR_1_7
377 || (major_version == MAJOR_1_7 && minor_version > MINOR_1_7))
378 throw_class_format_error ("unrecognized class file version");
379 is_15 = (major_version >= MAJOR_1_5);
381 pool_count = read2u ();
383 read_constpool ();
385 int access_flags = read2u ();
386 int this_class = read2u ();
387 int super_class = read2u ();
389 check_tag (this_class, JV_CONSTANT_Class);
390 if (super_class != 0)
391 check_tag (super_class, JV_CONSTANT_Class);
393 handleClassBegin (access_flags, this_class, super_class);
395 // Allocate our aux_info here, after the name is set, to fulfill our
396 // contract with the collector interface.
397 def->aux_info = (void *) _Jv_AllocRawObj (sizeof (_Jv_InterpClass));
398 def_interp = (_Jv_InterpClass *) def->aux_info;
400 int interfaces_count = read2u ();
402 handleInterfacesBegin (interfaces_count);
404 for (int i = 0; i < interfaces_count; i++)
406 int iface = read2u ();
407 check_tag (iface, JV_CONSTANT_Class);
408 handleInterface (i, iface);
411 read_fields ();
412 read_methods ();
414 int attributes_count = read2u ();
416 for (int i = 0; i < attributes_count; i++)
418 read_one_class_attribute ();
421 if (pos != len)
422 throw_class_format_error ("unused data before end of file");
424 finish_reflection_data ();
426 // Tell everyone we're done.
427 def->state = JV_STATE_READ;
428 if (gcj::verbose_class_flag)
429 _Jv_Linker::print_class_loaded (def);
430 ++gcj::loadedClasses;
431 def->notifyAll ();
434 void
435 _Jv_ClassReader::finish_reflection_data ()
437 if (data_stream == NULL)
438 return;
439 data_stream->writeByte(JV_DONE_ATTR);
440 data_stream->flush();
441 int nbytes = reflection_data->count;
442 unsigned char *new_bytes = (unsigned char *) _Jv_AllocBytes (nbytes);
443 memcpy (new_bytes, elements (reflection_data->buf), nbytes);
444 def->reflection_data = new_bytes;
447 void
448 _Jv_ClassReader::handleEnclosingMethod (int len)
450 if (len != 4)
451 throw_class_format_error ("invalid EnclosingMethod attribute");
452 // FIXME: only allow one...
454 int class_index = read2u();
455 check_tag (class_index, JV_CONSTANT_Class);
456 prepare_pool_entry (class_index, JV_CONSTANT_Class);
458 int method_index = read2u();
459 // Zero is ok and means no enclosing method.
460 if (method_index != 0)
462 check_tag (method_index, JV_CONSTANT_NameAndType);
463 prepare_pool_entry (method_index, JV_CONSTANT_NameAndType);
466 ::java::io::DataOutputStream *stream = get_reflection_stream ();
467 stream->writeByte(JV_CLASS_ATTR);
468 stream->writeInt(5);
469 stream->writeByte(JV_ENCLOSING_METHOD_KIND);
470 stream->writeShort(class_index);
471 stream->writeShort(method_index);
474 void
475 _Jv_ClassReader::handleGenericSignature (jv_attr_type type,
476 unsigned short index,
477 int len)
479 if (len != 2)
480 throw_class_format_error ("invalid Signature attribute");
482 int cpool_idx = read2u();
483 check_tag (cpool_idx, JV_CONSTANT_Utf8);
484 prepare_pool_entry (cpool_idx, JV_CONSTANT_Utf8, false);
486 ::java::io::DataOutputStream *stream = get_reflection_stream ();
487 stream->writeByte(type);
488 int attrlen = 3;
489 if (type != JV_CLASS_ATTR)
490 attrlen += 2;
491 stream->writeInt(attrlen);
492 if (type != JV_CLASS_ATTR)
493 stream->writeShort(index);
494 stream->writeByte(JV_SIGNATURE_KIND);
495 stream->writeShort(cpool_idx);
498 void
499 _Jv_ClassReader::handleAnnotationElement()
501 int tag = read1u();
502 switch (tag)
504 case 'B':
505 case 'C':
506 case 'S':
507 case 'Z':
508 case 'I':
510 int index = read2u();
511 check_tag (index, JV_CONSTANT_Integer);
512 prepare_pool_entry (index, JV_CONSTANT_Integer);
514 break;
515 case 'D':
517 int index = read2u();
518 check_tag (index, JV_CONSTANT_Double);
519 prepare_pool_entry (index, JV_CONSTANT_Double);
521 break;
522 case 'F':
524 int index = read2u();
525 check_tag (index, JV_CONSTANT_Float);
526 prepare_pool_entry (index, JV_CONSTANT_Float);
528 break;
529 case 'J':
531 int index = read2u();
532 check_tag (index, JV_CONSTANT_Long);
533 prepare_pool_entry (index, JV_CONSTANT_Long);
535 break;
536 case 's':
538 int index = read2u();
539 // Despite what the JVM spec says, compilers generate a Utf8
540 // constant here, not a String.
541 check_tag (index, JV_CONSTANT_Utf8);
542 prepare_pool_entry (index, JV_CONSTANT_Utf8, false);
544 break;
546 case 'e':
548 int type_name_index = read2u();
549 int const_name_index = read2u ();
550 check_tag (type_name_index, JV_CONSTANT_Utf8);
551 prepare_pool_entry (type_name_index, JV_CONSTANT_Utf8);
552 check_tag (const_name_index, JV_CONSTANT_Utf8);
553 prepare_pool_entry (const_name_index, JV_CONSTANT_Utf8, false);
555 break;
556 case 'c':
558 int index = read2u();
559 check_tag (index, JV_CONSTANT_Utf8);
560 prepare_pool_entry (index, JV_CONSTANT_Utf8);
562 break;
563 case '@':
564 handleAnnotation();
565 break;
566 case '[':
568 int n_array_elts = read2u ();
569 for (int i = 0; i < n_array_elts; ++i)
570 handleAnnotationElement();
572 break;
573 default:
574 throw_class_format_error ("invalid annotation element");
578 void
579 _Jv_ClassReader::handleAnnotation()
581 int type_index = read2u();
582 check_tag (type_index, JV_CONSTANT_Utf8);
583 prepare_pool_entry (type_index, JV_CONSTANT_Utf8);
585 int npairs = read2u();
586 for (int i = 0; i < npairs; ++i)
588 int name_index = read2u();
589 check_tag (name_index, JV_CONSTANT_Utf8);
590 prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false);
591 handleAnnotationElement();
595 void
596 _Jv_ClassReader::handleAnnotations()
598 int num = read2u();
599 while (num--)
600 handleAnnotation();
603 void
604 _Jv_ClassReader::handleMemberAnnotations(jv_attr_type member_type,
605 int member_index,
606 int len)
608 // We're going to copy the bytes in verbatim. But first we want to
609 // make sure the attribute is well-formed, and we want to prepare
610 // the constant pool. So, we save our starting point.
611 int orig_pos = pos;
613 handleAnnotations();
614 // FIXME: check that we read all LEN bytes?
616 ::java::io::DataOutputStream *stream = get_reflection_stream ();
617 stream->writeByte(member_type);
618 int newLen = len + 1;
619 if (member_type != JV_CLASS_ATTR)
620 newLen += 2;
621 stream->writeInt(newLen);
622 stream->writeByte(JV_ANNOTATIONS_KIND);
623 if (member_type != JV_CLASS_ATTR)
624 stream->writeShort(member_index);
625 // Write the data as-is.
626 stream->write(input_data, input_offset + orig_pos, len);
629 void
630 _Jv_ClassReader::handleAnnotationDefault(int member_index, int len)
632 int orig_pos = pos;
633 handleAnnotationElement();
635 ::java::io::DataOutputStream *stream = get_reflection_stream ();
636 stream->writeByte(JV_METHOD_ATTR);
637 stream->writeInt(len + 3);
638 stream->writeByte(JV_ANNOTATION_DEFAULT_KIND);
639 stream->writeShort(member_index);
640 stream->write(input_data, input_offset + orig_pos, len);
643 void
644 _Jv_ClassReader::handleParameterAnnotations(int member_index, int len)
646 int orig_pos = pos;
648 int n_params = read1u();
649 for (int i = 0; i < n_params; ++i)
650 handleAnnotations();
652 ::java::io::DataOutputStream *stream = get_reflection_stream ();
653 stream->writeByte(JV_METHOD_ATTR);
654 stream->writeInt(len + 3);
655 stream->writeByte(JV_PARAMETER_ANNOTATIONS_KIND);
656 stream->writeShort(member_index);
657 stream->write(input_data, input_offset + orig_pos, len);
660 void _Jv_ClassReader::read_constpool ()
662 tags = (unsigned char*) _Jv_AllocBytes (pool_count);
663 offsets = (unsigned int *) _Jv_AllocBytes (sizeof (int) * pool_count) ;
665 /** first, we scan the constant pool, collecting tags and offsets */
666 tags[0] = JV_CONSTANT_Undefined;
667 offsets[0] = pos;
668 for (int c = 1; c < pool_count; c++)
670 tags[c] = read1u ();
671 offsets[c] = pos;
673 switch (tags[c])
675 case JV_CONSTANT_String:
676 case JV_CONSTANT_Class:
677 skip (2);
678 break;
680 case JV_CONSTANT_Fieldref:
681 case JV_CONSTANT_Methodref:
682 case JV_CONSTANT_InterfaceMethodref:
683 case JV_CONSTANT_NameAndType:
684 case JV_CONSTANT_Integer:
685 case JV_CONSTANT_Float:
686 skip (4);
687 break;
689 case JV_CONSTANT_Double:
690 case JV_CONSTANT_Long:
691 skip (8);
692 tags[++c] = JV_CONSTANT_Undefined;
693 break;
695 case JV_CONSTANT_Utf8:
697 int len = read2u ();
698 skip (len);
700 break;
702 case JV_CONSTANT_Unicode:
703 throw_class_format_error ("unicode not supported");
704 break;
706 default:
707 throw_class_format_error ("erroneous constant pool tag");
711 handleConstantPool ();
715 void _Jv_ClassReader::read_fields ()
717 int fields_count = read2u ();
718 handleFieldsBegin (fields_count);
720 // We want to sort the fields so that static fields come first,
721 // followed by instance fields. We do this before parsing the
722 // fields so that we can have the new indices available when
723 // creating the annotation data structures.
725 // Allocate this on the heap in case there are a large number of
726 // fields.
727 int *fieldmap = (int *) _Jv_AllocBytes (fields_count * sizeof (int));
728 int save_pos = pos;
729 int static_count = 0, instance_count = -1;
730 for (int i = 0; i < fields_count; ++i)
732 using namespace java::lang::reflect;
734 int access_flags = read2u ();
735 skip (4);
736 int attributes_count = read2u ();
738 if ((access_flags & Modifier::STATIC) != 0)
739 fieldmap[i] = static_count++;
740 else
741 fieldmap[i] = instance_count--;
743 for (int j = 0; j < attributes_count; ++j)
745 skip (2);
746 int length = read4 ();
747 skip (length);
750 pos = save_pos;
752 // In the loop above, instance fields are represented by negative
753 // numbers. Here we rewrite these to be proper offsets.
754 for (int i = 0; i < fields_count; ++i)
756 if (fieldmap[i] < 0)
757 fieldmap[i] = static_count - 1 - fieldmap[i];
759 def->static_field_count = static_count;
761 for (int i = 0; i < fields_count; i++)
763 int access_flags = read2u ();
764 int name_index = read2u ();
765 int descriptor_index = read2u ();
766 int attributes_count = read2u ();
768 check_tag (name_index, JV_CONSTANT_Utf8);
769 prepare_pool_entry (name_index, JV_CONSTANT_Utf8);
771 check_tag (descriptor_index, JV_CONSTANT_Utf8);
772 prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
774 handleField (i, access_flags, name_index, descriptor_index, fieldmap);
776 bool found_value = false;
777 for (int j = 0; j < attributes_count; j++)
779 read_one_field_attribute (fieldmap[i], &found_value);
784 bool
785 _Jv_ClassReader::is_attribute_name (int index, const char *name)
787 check_tag (index, JV_CONSTANT_Utf8);
788 int len = get2u (bytes+offsets[index]);
789 if (len != (int) strlen (name))
790 return false;
791 else
792 return !memcmp (bytes+offsets[index]+2, name, len);
795 // Get a UTF8 value from the constant pool and turn it into a garbage
796 // collected char array.
797 int _Jv_ClassReader::pool_Utf8_to_char_arr (int index, char** entry)
799 check_tag (index, JV_CONSTANT_Utf8);
800 int len = get2u (bytes + offsets[index]);
801 *entry = reinterpret_cast<char *> (_Jv_AllocBytes (len + 1));
802 (*entry)[len] = '\0';
803 memcpy (*entry, bytes + offsets[index] + 2, len);
804 return len + 1;
807 void _Jv_ClassReader::read_one_field_attribute (int field_index,
808 bool *found_value)
810 int name = read2u ();
811 int length = read4 ();
813 if (is_attribute_name (name, "ConstantValue"))
815 int cv = read2u ();
817 if (cv < pool_count
818 && cv > 0
819 && (tags[cv] == JV_CONSTANT_Integer
820 || tags[cv] == JV_CONSTANT_Float
821 || tags[cv] == JV_CONSTANT_Long
822 || tags[cv] == JV_CONSTANT_Double
823 || tags[cv] == JV_CONSTANT_String))
825 handleConstantValueAttribute (field_index, cv, found_value);
827 else
829 throw_class_format_error ("erroneous ConstantValue attribute");
832 if (length != 2)
833 throw_class_format_error ("erroneous ConstantValue attribute");
835 else if (is_attribute_name (name, "Signature"))
836 handleGenericSignature(JV_FIELD_ATTR, field_index, length);
837 else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
838 handleMemberAnnotations(JV_FIELD_ATTR, field_index, length);
839 else
840 skip (length);
843 void _Jv_ClassReader::read_methods ()
845 int methods_count = read2u ();
847 handleMethodsBegin (methods_count);
849 for (int i = 0; i < methods_count; i++)
851 int access_flags = read2u ();
852 int name_index = read2u ();
853 int descriptor_index = read2u ();
854 int attributes_count = read2u ();
856 check_tag (name_index, JV_CONSTANT_Utf8);
857 prepare_pool_entry (name_index, JV_CONSTANT_Utf8);
859 check_tag (descriptor_index, JV_CONSTANT_Utf8);
860 prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
862 handleMethod (i, access_flags, name_index,
863 descriptor_index);
865 for (int j = 0; j < attributes_count; j++)
867 read_one_method_attribute (i);
871 handleMethodsEnd ();
874 void _Jv_ClassReader::read_one_method_attribute (int method_index)
876 int name = read2u ();
877 int length = read4 ();
879 if (is_attribute_name (name, "Exceptions"))
881 _Jv_Method *method = reinterpret_cast<_Jv_Method *>
882 (&def->methods[method_index]);
883 if (method->throws != NULL)
884 throw_class_format_error ("only one Exceptions attribute allowed per method");
886 int num_exceptions = read2u ();
887 _Jv_Utf8Const **exceptions =
888 (_Jv_Utf8Const **) _Jv_AllocBytes ((num_exceptions + 1)
889 * sizeof (_Jv_Utf8Const *));
891 int out = 0;
892 _Jv_word *pool_data = def->constants.data;
893 for (int i = 0; i < num_exceptions; ++i)
895 int ndx = read2u ();
896 // JLS 2nd Ed. 4.7.5 requires that the tag not be 0.
897 if (ndx != 0)
899 check_tag (ndx, JV_CONSTANT_Class);
900 exceptions[out++] = pool_data[ndx].utf8;
903 exceptions[out] = NULL;
904 method->throws = exceptions;
907 else if (is_attribute_name (name, "Code"))
909 int start_off = pos;
910 int max_stack = read2u ();
911 int max_locals = read2u ();
912 int code_length = read4 ();
914 int code_start = pos;
915 skip (code_length);
916 int exception_table_length = read2u ();
918 handleCodeAttribute (method_index,
919 max_stack, max_locals,
920 code_start, code_length,
921 exception_table_length);
924 for (int i = 0; i < exception_table_length; i++)
926 int start_pc = read2u ();
927 int end_pc = read2u ();
928 int handler_pc = read2u ();
929 int catch_type = read2u ();
931 if (start_pc > end_pc
932 || start_pc < 0
933 // END_PC can be equal to CODE_LENGTH.
934 // See JVM Spec 4.7.4.
935 || end_pc > code_length
936 || handler_pc >= code_length)
937 throw_class_format_error ("erroneous exception handler info");
939 if (! (tags[catch_type] == JV_CONSTANT_Class
940 || tags[catch_type] == 0))
942 throw_class_format_error ("erroneous exception handler info");
945 handleExceptionTableEntry (method_index,
947 start_pc,
948 end_pc,
949 handler_pc,
950 catch_type);
954 int attributes_count = read2u ();
956 for (int i = 0; i < attributes_count; i++)
958 read_one_code_attribute (method_index);
961 if ((pos - start_off) != length)
962 throw_class_format_error ("code attribute too short");
964 else if (is_attribute_name (name, "Signature"))
965 handleGenericSignature(JV_METHOD_ATTR, method_index, length);
966 else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
967 handleMemberAnnotations(JV_METHOD_ATTR, method_index, length);
968 else if (is_attribute_name (name, "RuntimeVisibleParameterAnnotations"))
969 handleParameterAnnotations(method_index, length);
970 else if (is_attribute_name (name, "AnnotationDefault"))
971 handleAnnotationDefault(method_index, length);
972 else
974 /* ignore unknown attributes */
975 skip (length);
979 void _Jv_ClassReader::read_one_code_attribute (int method_index)
981 int name = read2u ();
982 int length = read4 ();
983 if (is_attribute_name (name, "LineNumberTable"))
985 _Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
986 (def_interp->interpreted_methods[method_index]);
987 if (method->line_table != NULL)
988 throw_class_format_error ("Method already has LineNumberTable");
990 int table_len = read2u ();
991 _Jv_LineTableEntry* table
992 = (_Jv_LineTableEntry *) _Jv_AllocBytes (table_len
993 * sizeof (_Jv_LineTableEntry));
994 for (int i = 0; i < table_len; i++)
996 table[i].bytecode_pc = read2u ();
997 table[i].line = read2u ();
999 method->line_table_len = table_len;
1000 method->line_table = table;
1002 else if (is_attribute_name (name, "LocalVariableTable"))
1004 _Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
1005 (def_interp->interpreted_methods[method_index]);
1006 if (method->local_var_table != NULL)
1007 throw_class_format_error ("Method already has LocalVariableTable");
1009 int table_len = read2u ();
1010 _Jv_LocalVarTableEntry *table
1011 = reinterpret_cast<_Jv_LocalVarTableEntry *>
1012 (_Jv_AllocRawObj (table_len * sizeof (_Jv_LocalVarTableEntry)));
1014 for (int i = 0; i < table_len; i++)
1016 table[i].bytecode_pc = read2u ();
1017 table[i].length = read2u ();
1018 pool_Utf8_to_char_arr (read2u (), &table[i].name);
1019 pool_Utf8_to_char_arr (read2u (), &table[i].descriptor);
1020 table[i].slot = read2u ();
1022 if (table[i].slot > method->max_locals || table[i].slot < 0)
1023 throw_class_format_error ("Malformed Local Variable Table: Invalid Slot");
1026 method->local_var_table_len = table_len;
1027 method->local_var_table = table;
1029 else
1031 /* ignore unknown code attributes */
1032 skip (length);
1036 void _Jv_ClassReader::read_one_class_attribute ()
1038 int name = read2u ();
1039 int length = read4 ();
1040 if (is_attribute_name (name, "SourceFile"))
1042 int source_index = read2u ();
1043 check_tag (source_index, JV_CONSTANT_Utf8);
1044 prepare_pool_entry (source_index, JV_CONSTANT_Utf8, false);
1045 def_interp->source_file_name = _Jv_NewStringUtf8Const
1046 (def->constants.data[source_index].utf8);
1048 else if (is_attribute_name (name, "Signature"))
1049 handleGenericSignature(JV_CLASS_ATTR, 0, length);
1050 else if (is_attribute_name (name, "EnclosingMethod"))
1051 handleEnclosingMethod(length);
1052 else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
1053 handleMemberAnnotations(JV_CLASS_ATTR, 0, length);
1054 else if (is_attribute_name (name, "InnerClasses"))
1056 ::java::io::DataOutputStream *stream = get_reflection_stream ();
1057 stream->writeByte(JV_CLASS_ATTR);
1058 stream->writeInt(length + 1);
1059 stream->writeByte(JV_INNER_CLASSES_KIND);
1060 stream->write(input_data, input_offset + pos, length);
1061 skip (length);
1063 else
1065 /* Currently, we ignore most class attributes. */
1066 skip (length);
1073 /* this section defines the semantic actions of the parser */
1075 void _Jv_ClassReader::handleConstantPool ()
1077 /** now, we actually define the class' constant pool */
1079 jbyte *pool_tags = (jbyte*) _Jv_AllocBytes (pool_count);
1080 _Jv_word *pool_data
1081 = (_Jv_word*) _Jv_AllocRawObj (pool_count * sizeof (_Jv_word));
1083 def->constants.tags = pool_tags;
1084 def->constants.data = pool_data;
1085 def->constants.size = pool_count;
1087 // Here we make a pass to collect the strings! We do this, because
1088 // internally in the GCJ runtime, classes are encoded with .'s not /'s.
1089 // Therefore, we first collect the strings, and then translate the rest
1090 // of the utf8-entries (thus not representing strings) from /-notation
1091 // to .-notation.
1092 for (int i = 1; i < pool_count; i++)
1094 if (tags[i] == JV_CONSTANT_String)
1096 unsigned char* str_data = bytes + offsets [i];
1097 int utf_index = get2u (str_data);
1098 check_tag (utf_index, JV_CONSTANT_Utf8);
1099 unsigned char *utf_data = bytes + offsets[utf_index];
1100 int len = get2u (utf_data);
1101 pool_data[i].utf8 = _Jv_makeUtf8Const ((char*)(utf_data+2), len);
1102 pool_tags[i] = JV_CONSTANT_String;
1104 else
1106 pool_tags[i] = JV_CONSTANT_Undefined;
1110 // and now, we scan everything else but strings & utf8-entries. This
1111 // leaves out those utf8-entries which are not used; which will be left
1112 // with a tag of JV_CONSTANT_Undefined in the class definition.
1113 for (int index = 1; index < pool_count; index++)
1115 switch (tags[index])
1117 case JV_CONSTANT_Undefined:
1118 case JV_CONSTANT_String:
1119 case JV_CONSTANT_Utf8:
1120 continue;
1122 default:
1123 prepare_pool_entry (index, tags[index]);
1129 /* this is a recursive procedure, which will prepare pool entries as needed.
1130 Which is how we avoid initializing those entries which go unused.
1132 REWRITE is true iff this pool entry is the Utf8 representation of a
1133 class name or a signature.
1136 void
1137 _Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag,
1138 bool rewrite)
1140 /* these two, pool_data and pool_tags, point into the class
1141 structure we are currently defining */
1143 unsigned char *pool_tags = (unsigned char*) def->constants.tags;
1144 _Jv_word *pool_data = def->constants.data;
1146 /* this entry was already prepared */
1147 if (pool_tags[index] == this_tag)
1148 return;
1150 /* this_data points to the constant-pool information for the current
1151 constant-pool entry */
1153 unsigned char *this_data = bytes + offsets[index];
1155 switch (this_tag)
1157 case JV_CONSTANT_Utf8:
1159 int len = get2u (this_data);
1160 char *s = ((char*) this_data)+2;
1161 pool_tags[index] = JV_CONSTANT_Utf8;
1163 if (! rewrite)
1165 pool_data[index].utf8 = _Jv_makeUtf8Const (s, len);
1166 break;
1169 // If REWRITE is set, it is because some other tag needs this
1170 // utf8-entry for type information: it is a class or a
1171 // signature. Thus, we translate /'s to .'s in order to
1172 // accomondate gcj's internal representation.
1173 char *buffer = (char*) __builtin_alloca (len);
1174 for (int i = 0; i < len; i++)
1176 if (s[i] == '/')
1177 buffer[i] = '.';
1178 else
1179 buffer[i] = s[i];
1181 pool_data[index].utf8 = _Jv_makeUtf8Const (buffer, len);
1183 break;
1185 case JV_CONSTANT_Class:
1187 int utf_index = get2u (this_data);
1188 check_tag (utf_index, JV_CONSTANT_Utf8);
1189 prepare_pool_entry (utf_index, JV_CONSTANT_Utf8);
1191 if (verify)
1192 verify_classname (pool_data[utf_index].utf8);
1194 pool_data[index].utf8 = pool_data[utf_index].utf8;
1195 pool_tags[index] = JV_CONSTANT_Class;
1197 break;
1199 case JV_CONSTANT_String:
1200 // already handled before...
1201 break;
1203 case JV_CONSTANT_Fieldref:
1204 case JV_CONSTANT_Methodref:
1205 case JV_CONSTANT_InterfaceMethodref:
1207 int class_index = get2u (this_data);
1208 int nat_index = get2u (this_data+2);
1210 check_tag (class_index, JV_CONSTANT_Class);
1211 prepare_pool_entry (class_index, JV_CONSTANT_Class);
1213 check_tag (nat_index, JV_CONSTANT_NameAndType);
1214 prepare_pool_entry (nat_index, JV_CONSTANT_NameAndType);
1216 // here, verify the signature and identifier name
1217 if (verify)
1219 _Jv_ushort name_index, type_index;
1220 _Jv_loadIndexes (&pool_data[nat_index],
1221 name_index, type_index);
1223 if (this_tag == JV_CONSTANT_Fieldref)
1224 verify_field_signature (pool_data[type_index].utf8);
1225 else
1226 verify_method_signature (pool_data[type_index].utf8);
1228 _Jv_Utf8Const* name = pool_data[name_index].utf8;
1230 if (this_tag != JV_CONSTANT_Fieldref
1231 && ( _Jv_equalUtf8Consts (name, clinit_name)
1232 || _Jv_equalUtf8Consts (name, init_name)))
1233 /* ignore */;
1234 else
1235 verify_identifier (pool_data[name_index].utf8);
1238 _Jv_storeIndexes (&pool_data[index], class_index, nat_index);
1239 pool_tags[index] = this_tag;
1241 break;
1243 case JV_CONSTANT_NameAndType:
1245 _Jv_ushort name_index = get2u (this_data);
1246 _Jv_ushort type_index = get2u (this_data+2);
1248 check_tag (name_index, JV_CONSTANT_Utf8);
1249 prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false);
1250 check_tag (type_index, JV_CONSTANT_Utf8);
1251 prepare_pool_entry (type_index, JV_CONSTANT_Utf8);
1253 _Jv_storeIndexes (&pool_data[index], name_index, type_index);
1254 pool_tags[index] = JV_CONSTANT_NameAndType;
1256 break;
1258 case JV_CONSTANT_Float:
1260 jfloat f = java::lang::Float::intBitsToFloat ((jint) get4 (this_data));
1261 _Jv_storeFloat (&pool_data[index], f);
1262 pool_tags[index] = JV_CONSTANT_Float;
1264 break;
1266 case JV_CONSTANT_Integer:
1268 int i = get4 (this_data);
1269 _Jv_storeInt (&pool_data[index], i);
1270 pool_tags[index] = JV_CONSTANT_Integer;
1272 break;
1274 case JV_CONSTANT_Double:
1276 jdouble d
1277 = java::lang::Double::longBitsToDouble ((jlong) get8 (this_data));
1278 _Jv_storeDouble (&pool_data[index], d);
1279 pool_tags[index] = JV_CONSTANT_Double;
1281 break;
1283 case JV_CONSTANT_Long:
1285 jlong i = get8 (this_data);
1286 _Jv_storeLong (&pool_data[index], i);
1287 pool_tags[index] = JV_CONSTANT_Long;
1289 break;
1291 default:
1292 throw_class_format_error ("erroneous constant pool tag");
1297 void
1298 _Jv_ClassReader::handleClassBegin (int access_flags, int this_class, int super_class)
1300 using namespace java::lang::reflect;
1302 unsigned char *pool_tags = (unsigned char*) def->constants.tags;
1303 _Jv_word *pool_data = def->constants.data;
1305 check_tag (this_class, JV_CONSTANT_Class);
1306 _Jv_Utf8Const *loadedName = pool_data[this_class].utf8;
1308 // was ClassLoader.defineClass called with an expected class name?
1309 if (def->name == 0)
1311 jclass orig = def->loader->findLoadedClass(loadedName->toString());
1313 if (orig == 0)
1315 def->name = loadedName;
1317 else
1319 jstring msg = JvNewStringUTF ("anonymous "
1320 "class data denotes "
1321 "existing class ");
1322 msg = msg->concat (orig->getName ());
1324 throw_no_class_def_found_error (msg);
1328 // assert that the loaded class has the expected name, 5.3.5
1329 else if (! _Jv_equalUtf8Consts (loadedName, def->name))
1331 jstring msg = JvNewStringUTF ("loaded class ");
1332 msg = msg->concat (def->getName ());
1333 msg = msg->concat (_Jv_NewStringUTF (" was in fact named "));
1334 jstring klass_name = loadedName->toString();
1335 msg = msg->concat (klass_name);
1337 throw_no_class_def_found_error (msg);
1340 def->accflags = access_flags | java::lang::reflect::Modifier::INTERPRETED;
1341 pool_data[this_class].clazz = def;
1342 pool_tags[this_class] = JV_CONSTANT_ResolvedClass;
1344 if (super_class == 0)
1346 // Note that this is ok if we are defining java.lang.Object.
1347 // But there is no way to have this class be interpreted.
1348 throw_class_format_error ("no superclass reference");
1351 def->state = JV_STATE_PRELOADING;
1353 // Register this class with its defining loader as well (despite the
1354 // name of the function we're calling), so that super class lookups
1355 // work properly. If there is an error, our caller will unregister
1356 // this class from the class loader. Also, we don't need to hold a
1357 // lock here, as our caller has acquired it.
1358 _Jv_RegisterInitiatingLoader (def, def->loader);
1360 // Note that we found a name so that unregistration can happen if
1361 // needed.
1362 *found_name = def->name;
1364 if (super_class != 0)
1366 // Load the superclass.
1367 check_tag (super_class, JV_CONSTANT_Class);
1368 _Jv_Utf8Const* super_name = pool_data[super_class].utf8;
1370 // Load the superclass using our defining loader.
1371 jclass the_super = _Jv_FindClass (super_name, def->loader);
1373 // This will establish that we are allowed to be a subclass,
1374 // and check for class circularity error.
1375 checkExtends (def, the_super);
1377 // Note: for an interface we will find Object as the
1378 // superclass. We still check it above to ensure class file
1379 // validity, but we simply assign `null' to the actual field in
1380 // this case.
1381 def->superclass = (((access_flags & Modifier::INTERFACE))
1382 ? NULL : the_super);
1383 pool_data[super_class].clazz = the_super;
1384 pool_tags[super_class] = JV_CONSTANT_ResolvedClass;
1387 // Now we've come past the circularity problem, we can
1388 // now say that we're loading.
1390 def->state = JV_STATE_LOADING;
1391 def->notifyAll ();
1394 ///// Implements the checks described in sect. 5.3.5.3
1395 void
1396 _Jv_ClassReader::checkExtends (jclass sub, jclass super)
1398 using namespace java::lang::reflect;
1400 _Jv_Linker::wait_for_state (super, JV_STATE_LOADING);
1402 // Having an interface or a final class as a superclass is no good.
1403 if ((super->accflags & (Modifier::INTERFACE | Modifier::FINAL)) != 0)
1405 throw_incompatible_class_change_error (sub->getName ());
1408 // If the super class is not public, we need to check some more.
1409 if ((super->accflags & Modifier::PUBLIC) == 0)
1411 // With package scope, the classes must have the same class
1412 // loader.
1413 if ( sub->loader != super->loader
1414 || !_Jv_ClassNameSamePackage (sub->name, super->name))
1416 throw_incompatible_class_change_error (sub->getName ());
1420 for (; super != 0; super = super->getSuperclass ())
1422 if (super == sub)
1423 throw_class_circularity_error (sub->getName ());
1429 void _Jv_ClassReader::handleInterfacesBegin (int count)
1431 def->interfaces = (jclass*) _Jv_AllocRawObj (count*sizeof (jclass));
1432 def->interface_count = count;
1435 void _Jv_ClassReader::handleInterface (int if_number, int offset)
1437 _Jv_word * pool_data = def->constants.data;
1438 unsigned char * pool_tags = (unsigned char*) def->constants.tags;
1440 jclass the_interface;
1442 if (pool_tags[offset] == JV_CONSTANT_Class)
1444 _Jv_Utf8Const* name = pool_data[offset].utf8;
1445 the_interface = _Jv_FindClass (name, def->loader);
1447 else if (pool_tags[offset] == JV_CONSTANT_ResolvedClass)
1449 the_interface = pool_data[offset].clazz;
1451 else
1453 throw_no_class_def_found_error ("erroneous constant pool tag");
1456 // checks the validity of the_interface, and that we are in fact
1457 // allowed to implement that interface.
1458 checkImplements (def, the_interface);
1460 pool_data[offset].clazz = the_interface;
1461 pool_tags[offset] = JV_CONSTANT_ResolvedClass;
1463 def->interfaces[if_number] = the_interface;
1466 void
1467 _Jv_ClassReader::checkImplements (jclass sub, jclass super)
1469 using namespace java::lang::reflect;
1471 // well, it *must* be an interface
1472 if ((super->accflags & Modifier::INTERFACE) == 0)
1474 throw_incompatible_class_change_error (sub->getName ());
1477 // if it has package scope, it must also be defined by the
1478 // same loader.
1479 if ((super->accflags & Modifier::PUBLIC) == 0)
1481 if ( sub->loader != super->loader
1482 || !_Jv_ClassNameSamePackage (sub->name, super->name))
1484 throw_incompatible_class_change_error (sub->getName ());
1488 // FIXME: add interface circularity check here
1489 if (sub == super)
1491 throw_class_circularity_error (sub->getName ());
1495 void _Jv_ClassReader::handleFieldsBegin (int count)
1497 def->fields = (_Jv_Field*) _Jv_AllocRawObj (count * sizeof (_Jv_Field));
1498 def->field_count = count;
1499 def_interp->field_initializers
1500 = (_Jv_ushort*) _Jv_AllocRawObj (count * sizeof (_Jv_ushort));
1501 for (int i = 0; i < count; i++)
1502 def_interp->field_initializers[i] = (_Jv_ushort) 0;
1505 void _Jv_ClassReader::handleField (int field_no,
1506 int flags,
1507 int name,
1508 int desc,
1509 int *fieldmap)
1511 using namespace java::lang::reflect;
1513 _Jv_word *pool_data = def->constants.data;
1515 _Jv_Field *field = &def->fields[fieldmap[field_no]];
1516 _Jv_Utf8Const *field_name = pool_data[name].utf8;
1518 field->name = field_name;
1520 // Ignore flags we don't know about.
1521 field->flags = flags & (Field::FIELD_MODIFIERS
1522 | Modifier::SYNTHETIC
1523 | Modifier::ENUM);
1525 _Jv_Utf8Const* sig = pool_data[desc].utf8;
1527 if (verify)
1529 verify_identifier (field_name);
1531 for (int i = 0; i < field_no; ++i)
1533 if (_Jv_equalUtf8Consts (field_name, def->fields[fieldmap[i]].name)
1534 && _Jv_equalUtf8Consts (sig,
1535 // We know the other fields are
1536 // unresolved.
1537 (_Jv_Utf8Const *) def->fields[i].type))
1538 throw_class_format_error ("duplicate field name");
1541 // At most one of PUBLIC, PRIVATE, or PROTECTED is allowed.
1542 if (1 < ( ((field->flags & Modifier::PUBLIC) ? 1 : 0)
1543 +((field->flags & Modifier::PRIVATE) ? 1 : 0)
1544 +((field->flags & Modifier::PROTECTED) ? 1 : 0)))
1545 throw_class_format_error ("erroneous field access flags");
1547 // FIXME: JVM spec S4.5: Verify ACC_FINAL and ACC_VOLATILE are not
1548 // both set. Verify modifiers for interface fields.
1552 if (verify)
1553 verify_field_signature (sig);
1555 // field->type is really a jclass, but while it is still
1556 // unresolved we keep an _Jv_Utf8Const* instead.
1557 field->type = (jclass) sig;
1558 field->flags |= _Jv_FIELD_UNRESOLVED_FLAG;
1559 field->u.boffset = 0;
1563 void _Jv_ClassReader::handleConstantValueAttribute (int field_index,
1564 int value,
1565 bool *found_value)
1567 using namespace java::lang::reflect;
1569 _Jv_Field *field = &def->fields[field_index];
1571 if ((field->flags & (Modifier::STATIC
1572 | Modifier::FINAL
1573 | Modifier::PRIVATE)) == 0)
1575 // Ignore, as per vmspec #4.7.2
1576 return;
1579 // do not allow multiple constant fields!
1580 if (*found_value)
1581 throw_class_format_error ("field has multiple ConstantValue attributes");
1583 *found_value = true;
1584 def_interp->field_initializers[field_index] = value;
1586 /* type check the initializer */
1588 if (value <= 0 || value >= pool_count)
1589 throw_class_format_error ("erroneous ConstantValue attribute");
1591 /* FIXME: do the rest */
1594 void
1595 _Jv_ClassReader::handleMethodsBegin (int count)
1597 def->methods = (_Jv_Method *) _Jv_AllocRawObj (sizeof (_Jv_Method) * count);
1599 def_interp->interpreted_methods
1600 = (_Jv_MethodBase **) _Jv_AllocRawObj (sizeof (_Jv_MethodBase *)
1601 * count);
1603 for (int i = 0; i < count; i++)
1605 def_interp->interpreted_methods[i] = 0;
1606 def->methods[i].index = (_Jv_ushort) -1;
1609 def->method_count = count;
1613 void _Jv_ClassReader::handleMethod
1614 (int mth_index, int accflags, int name, int desc)
1616 using namespace java::lang::reflect;
1618 _Jv_word *pool_data = def->constants.data;
1619 _Jv_Method *method = &def->methods[mth_index];
1621 check_tag (name, JV_CONSTANT_Utf8);
1622 prepare_pool_entry (name, JV_CONSTANT_Utf8, false);
1623 method->name = pool_data[name].utf8;
1625 check_tag (desc, JV_CONSTANT_Utf8);
1626 prepare_pool_entry (desc, JV_CONSTANT_Utf8);
1627 method->signature = pool_data[desc].utf8;
1629 // ignore unknown flags
1630 method->accflags = accflags & (Method::METHOD_MODIFIERS
1631 | Modifier::BRIDGE
1632 | Modifier::SYNTHETIC
1633 | Modifier::VARARGS);
1635 // Initialize...
1636 method->ncode = 0;
1637 method->throws = NULL;
1639 if (verify)
1641 if (_Jv_equalUtf8Consts (method->name, clinit_name)
1642 || _Jv_equalUtf8Consts (method->name, init_name))
1643 /* ignore */;
1644 else
1645 verify_identifier (method->name);
1647 verify_method_signature (method->signature);
1649 for (int i = 0; i < mth_index; ++i)
1651 if (_Jv_equalUtf8Consts (method->name, def->methods[i].name)
1652 && _Jv_equalUtf8Consts (method->signature,
1653 def->methods[i].signature))
1654 throw_class_format_error ("duplicate method");
1657 // At most one of PUBLIC, PRIVATE, or PROTECTED is allowed.
1658 if (1 < ( ((method->accflags & Modifier::PUBLIC) ? 1 : 0)
1659 +((method->accflags & Modifier::PRIVATE) ? 1 : 0)
1660 +((method->accflags & Modifier::PROTECTED) ? 1 : 0)))
1661 throw_class_format_error ("erroneous method access flags");
1663 // FIXME: JVM spec S4.6: if ABSTRACT modifier is set, verify other
1664 // flags are not set. Verify flags for interface methods. Verify
1665 // modifiers for initializers.
1669 void _Jv_ClassReader::handleCodeAttribute
1670 (int method_index, int max_stack, int max_locals,
1671 int code_start, int code_length, int exc_table_length)
1673 int size = _Jv_InterpMethod::size (exc_table_length, code_length);
1674 _Jv_InterpMethod *method =
1675 (_Jv_InterpMethod*) (_Jv_AllocRawObj (size));
1677 method->max_stack = max_stack;
1678 method->max_locals = max_locals;
1679 method->code_length = code_length;
1680 method->exc_count = exc_table_length;
1681 method->is_15 = is_15;
1682 method->defining_class = def;
1683 method->self = &def->methods[method_index];
1684 method->prepared = NULL;
1685 method->line_table_len = 0;
1686 method->line_table = NULL;
1687 #ifdef DIRECT_THREADED
1688 method->thread_count = 0;
1689 #endif
1691 // grab the byte code!
1692 memcpy ((void*) method->bytecode (),
1693 (void*) (bytes+code_start),
1694 code_length);
1696 def_interp->interpreted_methods[method_index] = method;
1698 if ((method->self->accflags & java::lang::reflect::Modifier::STATIC))
1700 // Precompute the ncode field for a static method. This lets us
1701 // call a static method of an interpreted class from precompiled
1702 // code without first resolving the class (that will happen
1703 // during class initialization instead).
1704 method->self->ncode = method->ncode (def);
1708 void _Jv_ClassReader::handleExceptionTableEntry
1709 (int method_index, int exc_index,
1710 int start_pc, int end_pc, int handler_pc, int catch_type)
1712 _Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
1713 (def_interp->interpreted_methods[method_index]);
1714 _Jv_InterpException *exc = method->exceptions ();
1716 exc[exc_index].start_pc.i = start_pc;
1717 exc[exc_index].end_pc.i = end_pc;
1718 exc[exc_index].handler_pc.i = handler_pc;
1719 exc[exc_index].handler_type.i = catch_type;
1722 void _Jv_ClassReader::handleMethodsEnd ()
1724 using namespace java::lang::reflect;
1726 for (int i = 0; i < def->method_count; i++)
1728 _Jv_Method *method = &def->methods[i];
1729 if ((method->accflags & Modifier::NATIVE) != 0)
1731 if (def_interp->interpreted_methods[i] != 0)
1732 throw_class_format_error ("code provided for native method");
1733 else
1735 _Jv_JNIMethod *m = (_Jv_JNIMethod *)
1736 _Jv_AllocRawObj (sizeof (_Jv_JNIMethod));
1737 m->defining_class = def;
1738 m->self = method;
1739 m->function = NULL;
1740 def_interp->interpreted_methods[i] = m;
1742 if ((method->accflags & Modifier::STATIC))
1744 // Precompute the ncode field for a static method.
1745 // This lets us call a static method of an
1746 // interpreted class from precompiled code without
1747 // first resolving the class (that will happen
1748 // during class initialization instead).
1749 method->ncode = m->ncode (def);
1753 else if ((method->accflags & Modifier::ABSTRACT) != 0)
1755 if (def_interp->interpreted_methods[i] != 0)
1756 throw_class_format_error ("code provided for abstract method");
1757 method->ncode = (void *) &_Jv_ThrowAbstractMethodError;
1759 else
1761 if (def_interp->interpreted_methods[i] == 0)
1762 throw_class_format_error ("method with no code");
1767 void _Jv_ClassReader::throw_class_format_error (const char *msg)
1769 jstring str;
1770 if (def->name != NULL)
1772 jsize mlen = strlen (msg);
1773 unsigned char* data = (unsigned char*) def->name->chars();
1774 int ulen = def->name->len();
1775 unsigned char* limit = data + ulen;
1776 jsize nlen = _Jv_strLengthUtf8 ((char *) data, ulen);
1777 jsize len = nlen + mlen + 3;
1778 str = JvAllocString(len);
1779 jchar *chrs = JvGetStringChars(str);
1780 while (data < limit)
1781 *chrs++ = UTF8_GET(data, limit);
1782 *chrs++ = ' ';
1783 *chrs++ = '(';
1784 for (;;)
1786 char c = *msg++;
1787 if (c == 0)
1788 break;
1789 *chrs++ = c & 0xFFFF;
1791 *chrs++ = ')';
1793 else
1794 str = JvNewStringLatin1 (msg);
1795 ::throw_class_format_error (str);
1798 /** Here we define the exceptions that can be thrown */
1800 static void
1801 throw_no_class_def_found_error (jstring msg)
1803 throw (msg
1804 ? new java::lang::NoClassDefFoundError (msg)
1805 : new java::lang::NoClassDefFoundError);
1808 static void
1809 throw_no_class_def_found_error (const char *msg)
1811 throw_no_class_def_found_error (JvNewStringLatin1 (msg));
1814 static void
1815 throw_class_format_error (jstring msg)
1817 throw (msg
1818 ? new java::lang::ClassFormatError (msg)
1819 : new java::lang::ClassFormatError);
1822 static void
1823 throw_internal_error (const char *msg)
1825 throw new java::lang::InternalError (JvNewStringLatin1 (msg));
1828 static void
1829 throw_incompatible_class_change_error (jstring msg)
1831 throw new java::lang::IncompatibleClassChangeError (msg);
1834 static void
1835 throw_class_circularity_error (jstring msg)
1837 throw new java::lang::ClassCircularityError (msg);
1840 #endif /* INTERPRETER */
1844 /** This section takes care of verifying integrity of identifiers,
1845 signatures, field ddescriptors, and class names */
1847 #define UTF8_PEEK(PTR, LIMIT) \
1848 ({ unsigned char* xxkeep = (PTR); \
1849 int xxch = UTF8_GET(PTR,LIMIT); \
1850 PTR = xxkeep; xxch; })
1852 /* Verify one element of a type descriptor or signature. */
1853 static unsigned char*
1854 _Jv_VerifyOne (unsigned char* ptr, unsigned char* limit, bool void_ok)
1856 if (ptr >= limit)
1857 return 0;
1859 int ch = UTF8_GET (ptr, limit);
1861 switch (ch)
1863 case 'V':
1864 if (! void_ok)
1865 return 0;
1867 case 'S': case 'B': case 'I': case 'J':
1868 case 'Z': case 'C': case 'F': case 'D':
1869 break;
1871 case 'L':
1873 unsigned char *start = ptr, *end;
1876 if (ptr > limit)
1877 return 0;
1879 end = ptr;
1881 if ((ch = UTF8_GET (ptr, limit)) == -1)
1882 return 0;
1885 while (ch != ';');
1886 if (! _Jv_VerifyClassName (start, (unsigned short) (end-start)))
1887 return 0;
1889 break;
1891 case '[':
1892 return _Jv_VerifyOne (ptr, limit, false);
1893 break;
1895 default:
1896 return 0;
1899 return ptr;
1902 /* Verification and loading procedures. */
1903 bool
1904 _Jv_VerifyFieldSignature (_Jv_Utf8Const*sig)
1906 unsigned char* ptr = (unsigned char*) sig->chars();
1907 unsigned char* limit = ptr + sig->len();
1909 ptr = _Jv_VerifyOne (ptr, limit, false);
1911 return ptr == limit;
1914 bool
1915 _Jv_VerifyMethodSignature (_Jv_Utf8Const*sig)
1917 unsigned char* ptr = (unsigned char*) sig->chars();
1918 unsigned char* limit = ptr + sig->len();
1920 if (ptr == limit || UTF8_GET(ptr,limit) != '(')
1921 return false;
1923 while (ptr && UTF8_PEEK (ptr, limit) != ')')
1924 ptr = _Jv_VerifyOne (ptr, limit, false);
1926 if (! ptr || UTF8_GET (ptr, limit) != ')')
1927 return false;
1929 // get the return type
1930 ptr = _Jv_VerifyOne (ptr, limit, true);
1932 return ptr == limit;
1935 /* We try to avoid calling the Character methods all the time, in
1936 fact, they will only be called for non-standard things. */
1937 static __inline__ int
1938 is_identifier_start (int c)
1940 unsigned int ch = (unsigned)c;
1942 if ((ch - 0x41U) < 29U) /* A ... Z */
1943 return 1;
1944 if ((ch - 0x61U) < 29U) /* a ... z */
1945 return 1;
1946 if (ch == 0x5FU) /* _ */
1947 return 1;
1949 return java::lang::Character::isJavaIdentifierStart ((jchar) ch);
1952 static __inline__ int
1953 is_identifier_part (int c)
1955 unsigned int ch = (unsigned)c;
1957 if ((ch - 0x41U) < 29U) /* A ... Z */
1958 return 1;
1959 if ((ch - 0x61U) < 29U) /* a ... z */
1960 return 1;
1961 if ((ch - 0x30) < 10U) /* 0 .. 9 */
1962 return 1;
1963 if (ch == 0x5FU || ch == 0x24U) /* _ $ */
1964 return 1;
1966 return java::lang::Character::isJavaIdentifierStart ((jchar) ch);
1969 bool
1970 _Jv_VerifyIdentifier (_Jv_Utf8Const* name)
1972 unsigned char *ptr = (unsigned char*) name->chars();
1973 unsigned char *limit = (unsigned char*) name->limit();
1974 int ch;
1976 if ((ch = UTF8_GET (ptr, limit))==-1
1977 || ! is_identifier_start (ch))
1978 return false;
1980 while (ptr != limit)
1982 if ((ch = UTF8_GET (ptr, limit))==-1
1983 || ! is_identifier_part (ch))
1984 return false;
1986 return true;
1989 bool
1990 _Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length)
1992 unsigned char *limit = ptr+length;
1993 int ch;
1995 if ('[' == UTF8_PEEK (ptr, limit))
1997 unsigned char *end = _Jv_VerifyOne (++ptr, limit, false);
1998 // _Jv_VerifyOne must leave us looking at the terminating nul
1999 // byte.
2000 if (! end || *end)
2001 return false;
2002 else
2003 return true;
2006 next_level:
2007 for (;;) {
2008 if ((ch = UTF8_GET (ptr, limit))==-1)
2009 return false;
2010 if (! is_identifier_start (ch))
2011 return false;
2012 for (;;) {
2013 if (ptr == limit)
2014 return true;
2015 else if ((ch = UTF8_GET (ptr, limit))==-1)
2016 return false;
2017 else if (ch == '.')
2018 goto next_level;
2019 else if (! is_identifier_part (ch))
2020 return false;
2025 bool
2026 _Jv_VerifyClassName (_Jv_Utf8Const *name)
2028 return _Jv_VerifyClassName ((unsigned char*)name->chars(), name->len());
2031 /* Returns true, if NAME1 and NAME2 represent classes in the same
2032 package. Neither NAME2 nor NAME2 may name an array type. */
2033 bool
2034 _Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2)
2036 unsigned char* ptr1 = (unsigned char*) name1->chars();
2037 unsigned char* limit1 = (unsigned char*) name1->limit();
2039 unsigned char* last1 = ptr1;
2041 // scan name1, and find the last occurrence of '.'
2042 while (ptr1 < limit1) {
2043 int ch1 = UTF8_GET (ptr1, limit1);
2045 if (ch1 == '.')
2046 last1 = ptr1;
2048 else if (ch1 == -1)
2049 return false;
2052 // Now the length of NAME1's package name is LEN.
2053 int len = last1 - (unsigned char*) name1->chars();
2055 // If this is longer than NAME2, then we're off.
2056 if (len > name2->len())
2057 return false;
2059 // Then compare the first len bytes for equality.
2060 if (memcmp ((void*) name1->chars(), (void*) name2->chars(), len) == 0)
2062 // Check that there are no .'s after position LEN in NAME2.
2064 unsigned char* ptr2 = (unsigned char*) name2->chars() + len;
2065 unsigned char* limit2 = (unsigned char*) name2->limit();
2067 while (ptr2 < limit2)
2069 int ch2 = UTF8_GET (ptr2, limit2);
2070 if (ch2 == -1 || ch2 == '.')
2071 return false;
2073 return true;
2075 return false;