Sat, 30 Oct 2010 13:08:23 -0700
6984311: JSR 292 needs optional bootstrap method parameters
Summary: Allow CONSTANT_InvokeDynamic nodes to have any number of extra operands.
Reviewed-by: twisti
1 /*
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #include "incls/_precompiled.incl"
26 #include "incls/_classFileParser.cpp.incl"
28 // We generally try to create the oops directly when parsing, rather than
29 // allocating temporary data structures and copying the bytes twice. A
30 // temporary area is only needed when parsing utf8 entries in the constant
31 // pool and when parsing line number tables.
33 // We add assert in debug mode when class format is not checked.
35 #define JAVA_CLASSFILE_MAGIC 0xCAFEBABE
36 #define JAVA_MIN_SUPPORTED_VERSION 45
37 #define JAVA_MAX_SUPPORTED_VERSION 51
38 #define JAVA_MAX_SUPPORTED_MINOR_VERSION 0
40 // Used for two backward compatibility reasons:
41 // - to check for new additions to the class file format in JDK1.5
42 // - to check for bug fixes in the format checker in JDK1.5
43 #define JAVA_1_5_VERSION 49
45 // Used for backward compatibility reasons:
46 // - to check for javac bug fixes that happened after 1.5
47 // - also used as the max version when running in jdk6
48 #define JAVA_6_VERSION 50
50 // Used for backward compatibility reasons:
51 // - to check NameAndType_info signatures more aggressively
52 #define JAVA_7_VERSION 51
55 void ClassFileParser::parse_constant_pool_entries(constantPoolHandle cp, int length, TRAPS) {
56 // Use a local copy of ClassFileStream. It helps the C++ compiler to optimize
57 // this function (_current can be allocated in a register, with scalar
58 // replacement of aggregates). The _current pointer is copied back to
59 // stream() when this function returns. DON'T call another method within
60 // this method that uses stream().
61 ClassFileStream* cfs0 = stream();
62 ClassFileStream cfs1 = *cfs0;
63 ClassFileStream* cfs = &cfs1;
64 #ifdef ASSERT
65 assert(cfs->allocated_on_stack(),"should be local");
66 u1* old_current = cfs0->current();
67 #endif
69 // Used for batching symbol allocations.
70 const char* names[SymbolTable::symbol_alloc_batch_size];
71 int lengths[SymbolTable::symbol_alloc_batch_size];
72 int indices[SymbolTable::symbol_alloc_batch_size];
73 unsigned int hashValues[SymbolTable::symbol_alloc_batch_size];
74 int names_count = 0;
76 // Side buffer for operands of variable-sized (InvokeDynamic) entries.
77 GrowableArray<int>* operands = NULL;
78 #ifdef ASSERT
79 GrowableArray<int>* indy_instructions = new GrowableArray<int>(THREAD, 10);
80 #endif
82 // parsing Index 0 is unused
83 for (int index = 1; index < length; index++) {
84 // Each of the following case guarantees one more byte in the stream
85 // for the following tag or the access_flags following constant pool,
86 // so we don't need bounds-check for reading tag.
87 u1 tag = cfs->get_u1_fast();
88 switch (tag) {
89 case JVM_CONSTANT_Class :
90 {
91 cfs->guarantee_more(3, CHECK); // name_index, tag/access_flags
92 u2 name_index = cfs->get_u2_fast();
93 cp->klass_index_at_put(index, name_index);
94 }
95 break;
96 case JVM_CONSTANT_Fieldref :
97 {
98 cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags
99 u2 class_index = cfs->get_u2_fast();
100 u2 name_and_type_index = cfs->get_u2_fast();
101 cp->field_at_put(index, class_index, name_and_type_index);
102 }
103 break;
104 case JVM_CONSTANT_Methodref :
105 {
106 cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags
107 u2 class_index = cfs->get_u2_fast();
108 u2 name_and_type_index = cfs->get_u2_fast();
109 cp->method_at_put(index, class_index, name_and_type_index);
110 }
111 break;
112 case JVM_CONSTANT_InterfaceMethodref :
113 {
114 cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags
115 u2 class_index = cfs->get_u2_fast();
116 u2 name_and_type_index = cfs->get_u2_fast();
117 cp->interface_method_at_put(index, class_index, name_and_type_index);
118 }
119 break;
120 case JVM_CONSTANT_String :
121 {
122 cfs->guarantee_more(3, CHECK); // string_index, tag/access_flags
123 u2 string_index = cfs->get_u2_fast();
124 cp->string_index_at_put(index, string_index);
125 }
126 break;
127 case JVM_CONSTANT_MethodHandle :
128 case JVM_CONSTANT_MethodType :
129 if (!EnableMethodHandles ||
130 _major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {
131 classfile_parse_error(
132 (!EnableMethodHandles ?
133 "This JVM does not support constant tag %u in class file %s" :
134 "Class file version does not support constant tag %u in class file %s"),
135 tag, CHECK);
136 }
137 if (tag == JVM_CONSTANT_MethodHandle) {
138 cfs->guarantee_more(4, CHECK); // ref_kind, method_index, tag/access_flags
139 u1 ref_kind = cfs->get_u1_fast();
140 u2 method_index = cfs->get_u2_fast();
141 cp->method_handle_index_at_put(index, ref_kind, method_index);
142 } else if (tag == JVM_CONSTANT_MethodType) {
143 cfs->guarantee_more(3, CHECK); // signature_index, tag/access_flags
144 u2 signature_index = cfs->get_u2_fast();
145 cp->method_type_index_at_put(index, signature_index);
146 } else {
147 ShouldNotReachHere();
148 }
149 break;
150 case JVM_CONSTANT_InvokeDynamicTrans : // this tag appears only in old classfiles
151 case JVM_CONSTANT_InvokeDynamic :
152 {
153 if (!EnableInvokeDynamic ||
154 _major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {
155 classfile_parse_error(
156 (!EnableInvokeDynamic ?
157 "This JVM does not support constant tag %u in class file %s" :
158 "Class file version does not support constant tag %u in class file %s"),
159 tag, CHECK);
160 }
161 if (!AllowTransitionalJSR292 && tag == JVM_CONSTANT_InvokeDynamicTrans) {
162 classfile_parse_error(
163 "This JVM does not support transitional InvokeDynamic tag %u in class file %s",
164 tag, CHECK);
165 }
166 bool trans_no_argc = AllowTransitionalJSR292 && (tag == JVM_CONSTANT_InvokeDynamicTrans);
167 cfs->guarantee_more(7, CHECK); // bsm_index, nt, argc, ..., tag/access_flags
168 u2 bootstrap_method_index = cfs->get_u2_fast();
169 u2 name_and_type_index = cfs->get_u2_fast();
170 int argument_count = trans_no_argc ? 0 : cfs->get_u2_fast();
171 cfs->guarantee_more(2*argument_count + 1, CHECK); // argv[argc]..., tag/access_flags
172 int argv_offset = constantPoolOopDesc::_indy_argv_offset;
173 int op_count = argv_offset + argument_count; // bsm, nt, argc, argv[]...
174 int op_base = start_operand_group(operands, op_count, CHECK);
175 assert(argv_offset == 3, "else adjust next 3 assignments");
176 operands->at_put(op_base + constantPoolOopDesc::_indy_bsm_offset, bootstrap_method_index);
177 operands->at_put(op_base + constantPoolOopDesc::_indy_nt_offset, name_and_type_index);
178 operands->at_put(op_base + constantPoolOopDesc::_indy_argc_offset, argument_count);
179 for (int arg_i = 0; arg_i < argument_count; arg_i++) {
180 int arg = cfs->get_u2_fast();
181 operands->at_put(op_base + constantPoolOopDesc::_indy_argv_offset + arg_i, arg);
182 }
183 cp->invoke_dynamic_at_put(index, op_base, op_count);
184 #ifdef ASSERT
185 // Record the steps just taken for later checking.
186 indy_instructions->append(index);
187 indy_instructions->append(bootstrap_method_index);
188 indy_instructions->append(name_and_type_index);
189 indy_instructions->append(argument_count);
190 #endif //ASSERT
191 }
192 break;
193 case JVM_CONSTANT_Integer :
194 {
195 cfs->guarantee_more(5, CHECK); // bytes, tag/access_flags
196 u4 bytes = cfs->get_u4_fast();
197 cp->int_at_put(index, (jint) bytes);
198 }
199 break;
200 case JVM_CONSTANT_Float :
201 {
202 cfs->guarantee_more(5, CHECK); // bytes, tag/access_flags
203 u4 bytes = cfs->get_u4_fast();
204 cp->float_at_put(index, *(jfloat*)&bytes);
205 }
206 break;
207 case JVM_CONSTANT_Long :
208 // A mangled type might cause you to overrun allocated memory
209 guarantee_property(index+1 < length,
210 "Invalid constant pool entry %u in class file %s",
211 index, CHECK);
212 {
213 cfs->guarantee_more(9, CHECK); // bytes, tag/access_flags
214 u8 bytes = cfs->get_u8_fast();
215 cp->long_at_put(index, bytes);
216 }
217 index++; // Skip entry following eigth-byte constant, see JVM book p. 98
218 break;
219 case JVM_CONSTANT_Double :
220 // A mangled type might cause you to overrun allocated memory
221 guarantee_property(index+1 < length,
222 "Invalid constant pool entry %u in class file %s",
223 index, CHECK);
224 {
225 cfs->guarantee_more(9, CHECK); // bytes, tag/access_flags
226 u8 bytes = cfs->get_u8_fast();
227 cp->double_at_put(index, *(jdouble*)&bytes);
228 }
229 index++; // Skip entry following eigth-byte constant, see JVM book p. 98
230 break;
231 case JVM_CONSTANT_NameAndType :
232 {
233 cfs->guarantee_more(5, CHECK); // name_index, signature_index, tag/access_flags
234 u2 name_index = cfs->get_u2_fast();
235 u2 signature_index = cfs->get_u2_fast();
236 cp->name_and_type_at_put(index, name_index, signature_index);
237 }
238 break;
239 case JVM_CONSTANT_Utf8 :
240 {
241 cfs->guarantee_more(2, CHECK); // utf8_length
242 u2 utf8_length = cfs->get_u2_fast();
243 u1* utf8_buffer = cfs->get_u1_buffer();
244 assert(utf8_buffer != NULL, "null utf8 buffer");
245 // Got utf8 string, guarantee utf8_length+1 bytes, set stream position forward.
246 cfs->guarantee_more(utf8_length+1, CHECK); // utf8 string, tag/access_flags
247 cfs->skip_u1_fast(utf8_length);
249 // Before storing the symbol, make sure it's legal
250 if (_need_verify) {
251 verify_legal_utf8((unsigned char*)utf8_buffer, utf8_length, CHECK);
252 }
254 if (AnonymousClasses && has_cp_patch_at(index)) {
255 Handle patch = clear_cp_patch_at(index);
256 guarantee_property(java_lang_String::is_instance(patch()),
257 "Illegal utf8 patch at %d in class file %s",
258 index, CHECK);
259 char* str = java_lang_String::as_utf8_string(patch());
260 // (could use java_lang_String::as_symbol instead, but might as well batch them)
261 utf8_buffer = (u1*) str;
262 utf8_length = (int) strlen(str);
263 }
265 unsigned int hash;
266 symbolOop result = SymbolTable::lookup_only((char*)utf8_buffer, utf8_length, hash);
267 if (result == NULL) {
268 names[names_count] = (char*)utf8_buffer;
269 lengths[names_count] = utf8_length;
270 indices[names_count] = index;
271 hashValues[names_count++] = hash;
272 if (names_count == SymbolTable::symbol_alloc_batch_size) {
273 oopFactory::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
274 names_count = 0;
275 }
276 } else {
277 cp->symbol_at_put(index, result);
278 }
279 }
280 break;
281 default:
282 classfile_parse_error(
283 "Unknown constant tag %u in class file %s", tag, CHECK);
284 break;
285 }
286 }
288 // Allocate the remaining symbols
289 if (names_count > 0) {
290 oopFactory::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
291 }
293 if (operands != NULL && operands->length() > 0) {
294 store_operand_array(operands, cp, CHECK);
295 }
296 #ifdef ASSERT
297 // Re-assert the indy structures, now that assertion checking can work.
298 for (int indy_i = 0; indy_i < indy_instructions->length(); ) {
299 int index = indy_instructions->at(indy_i++);
300 int bootstrap_method_index = indy_instructions->at(indy_i++);
301 int name_and_type_index = indy_instructions->at(indy_i++);
302 int argument_count = indy_instructions->at(indy_i++);
303 assert(cp->check_invoke_dynamic_at(index,
304 bootstrap_method_index, name_and_type_index,
305 argument_count),
306 "indy structure is OK");
307 }
308 #endif //ASSERT
310 // Copy _current pointer of local copy back to stream().
311 #ifdef ASSERT
312 assert(cfs0->current() == old_current, "non-exclusive use of stream()");
313 #endif
314 cfs0->set_current(cfs1.current());
315 }
317 int ClassFileParser::start_operand_group(GrowableArray<int>* &operands, int op_count, TRAPS) {
318 if (operands == NULL) {
319 operands = new GrowableArray<int>(THREAD, 100);
320 int fillp_offset = constantPoolOopDesc::_multi_operand_buffer_fill_pointer_offset;
321 while (operands->length() <= fillp_offset)
322 operands->append(0); // force op_base > 0, for an error check
323 DEBUG_ONLY(operands->at_put(fillp_offset, (int)badHeapWordVal));
324 }
325 int cnt_pos = operands->append(op_count);
326 int arg_pos = operands->length();
327 operands->at_grow(arg_pos + op_count - 1); // grow to include the operands
328 assert(operands->length() == arg_pos + op_count, "");
329 int op_base = cnt_pos - constantPoolOopDesc::_multi_operand_count_offset;
330 return op_base;
331 }
333 void ClassFileParser::store_operand_array(GrowableArray<int>* operands, constantPoolHandle cp, TRAPS) {
334 // Collect the buffer of operands from variable-sized entries into a permanent array.
335 int arraylen = operands->length();
336 int fillp_offset = constantPoolOopDesc::_multi_operand_buffer_fill_pointer_offset;
337 assert(operands->at(fillp_offset) == (int)badHeapWordVal, "value unused so far");
338 operands->at_put(fillp_offset, arraylen);
339 cp->multi_operand_buffer_grow(arraylen, CHECK);
340 typeArrayOop operands_oop = cp->operands();
341 assert(operands_oop->length() == arraylen, "");
342 for (int i = 0; i < arraylen; i++) {
343 operands_oop->int_at_put(i, operands->at(i));
344 }
345 cp->set_operands(operands_oop);
346 // The fill_pointer is used only by constantPoolOop::copy_entry_to and friends,
347 // when constant pools need to be merged. Make sure it is sane now.
348 assert(cp->multi_operand_buffer_fill_pointer() == arraylen, "");
349 }
352 bool inline valid_cp_range(int index, int length) { return (index > 0 && index < length); }
354 constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {
355 ClassFileStream* cfs = stream();
356 constantPoolHandle nullHandle;
358 cfs->guarantee_more(3, CHECK_(nullHandle)); // length, first cp tag
359 u2 length = cfs->get_u2_fast();
360 guarantee_property(
361 length >= 1, "Illegal constant pool size %u in class file %s",
362 length, CHECK_(nullHandle));
363 constantPoolOop constant_pool =
364 oopFactory::new_constantPool(length,
365 methodOopDesc::IsSafeConc,
366 CHECK_(nullHandle));
367 constantPoolHandle cp (THREAD, constant_pool);
369 cp->set_partially_loaded(); // Enables heap verify to work on partial constantPoolOops
371 // parsing constant pool entries
372 parse_constant_pool_entries(cp, length, CHECK_(nullHandle));
374 int index = 1; // declared outside of loops for portability
376 // first verification pass - validate cross references and fixup class and string constants
377 for (index = 1; index < length; index++) { // Index 0 is unused
378 switch (cp->tag_at(index).value()) {
379 case JVM_CONSTANT_Class :
380 ShouldNotReachHere(); // Only JVM_CONSTANT_ClassIndex should be present
381 break;
382 case JVM_CONSTANT_Fieldref :
383 // fall through
384 case JVM_CONSTANT_Methodref :
385 // fall through
386 case JVM_CONSTANT_InterfaceMethodref : {
387 if (!_need_verify) break;
388 int klass_ref_index = cp->klass_ref_index_at(index);
389 int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
390 check_property(valid_cp_range(klass_ref_index, length) &&
391 is_klass_reference(cp, klass_ref_index),
392 "Invalid constant pool index %u in class file %s",
393 klass_ref_index,
394 CHECK_(nullHandle));
395 check_property(valid_cp_range(name_and_type_ref_index, length) &&
396 cp->tag_at(name_and_type_ref_index).is_name_and_type(),
397 "Invalid constant pool index %u in class file %s",
398 name_and_type_ref_index,
399 CHECK_(nullHandle));
400 break;
401 }
402 case JVM_CONSTANT_String :
403 ShouldNotReachHere(); // Only JVM_CONSTANT_StringIndex should be present
404 break;
405 case JVM_CONSTANT_Integer :
406 break;
407 case JVM_CONSTANT_Float :
408 break;
409 case JVM_CONSTANT_Long :
410 case JVM_CONSTANT_Double :
411 index++;
412 check_property(
413 (index < length && cp->tag_at(index).is_invalid()),
414 "Improper constant pool long/double index %u in class file %s",
415 index, CHECK_(nullHandle));
416 break;
417 case JVM_CONSTANT_NameAndType : {
418 if (!_need_verify) break;
419 int name_ref_index = cp->name_ref_index_at(index);
420 int signature_ref_index = cp->signature_ref_index_at(index);
421 check_property(
422 valid_cp_range(name_ref_index, length) &&
423 cp->tag_at(name_ref_index).is_utf8(),
424 "Invalid constant pool index %u in class file %s",
425 name_ref_index, CHECK_(nullHandle));
426 check_property(
427 valid_cp_range(signature_ref_index, length) &&
428 cp->tag_at(signature_ref_index).is_utf8(),
429 "Invalid constant pool index %u in class file %s",
430 signature_ref_index, CHECK_(nullHandle));
431 break;
432 }
433 case JVM_CONSTANT_Utf8 :
434 break;
435 case JVM_CONSTANT_UnresolvedClass : // fall-through
436 case JVM_CONSTANT_UnresolvedClassInError:
437 ShouldNotReachHere(); // Only JVM_CONSTANT_ClassIndex should be present
438 break;
439 case JVM_CONSTANT_ClassIndex :
440 {
441 int class_index = cp->klass_index_at(index);
442 check_property(
443 valid_cp_range(class_index, length) &&
444 cp->tag_at(class_index).is_utf8(),
445 "Invalid constant pool index %u in class file %s",
446 class_index, CHECK_(nullHandle));
447 cp->unresolved_klass_at_put(index, cp->symbol_at(class_index));
448 }
449 break;
450 case JVM_CONSTANT_UnresolvedString :
451 ShouldNotReachHere(); // Only JVM_CONSTANT_StringIndex should be present
452 break;
453 case JVM_CONSTANT_StringIndex :
454 {
455 int string_index = cp->string_index_at(index);
456 check_property(
457 valid_cp_range(string_index, length) &&
458 cp->tag_at(string_index).is_utf8(),
459 "Invalid constant pool index %u in class file %s",
460 string_index, CHECK_(nullHandle));
461 symbolOop sym = cp->symbol_at(string_index);
462 cp->unresolved_string_at_put(index, sym);
463 }
464 break;
465 case JVM_CONSTANT_MethodHandle :
466 {
467 int ref_index = cp->method_handle_index_at(index);
468 check_property(
469 valid_cp_range(ref_index, length) &&
470 EnableMethodHandles,
471 "Invalid constant pool index %u in class file %s",
472 ref_index, CHECK_(nullHandle));
473 constantTag tag = cp->tag_at(ref_index);
474 int ref_kind = cp->method_handle_ref_kind_at(index);
475 switch (ref_kind) {
476 case JVM_REF_getField:
477 case JVM_REF_getStatic:
478 case JVM_REF_putField:
479 case JVM_REF_putStatic:
480 check_property(
481 tag.is_field(),
482 "Invalid constant pool index %u in class file %s (not a field)",
483 ref_index, CHECK_(nullHandle));
484 break;
485 case JVM_REF_invokeVirtual:
486 case JVM_REF_invokeStatic:
487 case JVM_REF_invokeSpecial:
488 case JVM_REF_newInvokeSpecial:
489 check_property(
490 tag.is_method(),
491 "Invalid constant pool index %u in class file %s (not a method)",
492 ref_index, CHECK_(nullHandle));
493 break;
494 case JVM_REF_invokeInterface:
495 check_property(
496 tag.is_interface_method(),
497 "Invalid constant pool index %u in class file %s (not an interface method)",
498 ref_index, CHECK_(nullHandle));
499 break;
500 default:
501 classfile_parse_error(
502 "Bad method handle kind at constant pool index %u in class file %s",
503 index, CHECK_(nullHandle));
504 }
505 // Keep the ref_index unchanged. It will be indirected at link-time.
506 }
507 break;
508 case JVM_CONSTANT_MethodType :
509 {
510 int ref_index = cp->method_type_index_at(index);
511 check_property(
512 valid_cp_range(ref_index, length) &&
513 cp->tag_at(ref_index).is_utf8() &&
514 EnableMethodHandles,
515 "Invalid constant pool index %u in class file %s",
516 ref_index, CHECK_(nullHandle));
517 }
518 break;
519 case JVM_CONSTANT_InvokeDynamicTrans :
520 ShouldNotReachHere(); // this tag does not appear in the heap
521 case JVM_CONSTANT_InvokeDynamic :
522 {
523 int bootstrap_method_ref_index = cp->invoke_dynamic_bootstrap_method_ref_index_at(index);
524 int name_and_type_ref_index = cp->invoke_dynamic_name_and_type_ref_index_at(index);
525 check_property((bootstrap_method_ref_index == 0 && AllowTransitionalJSR292)
526 ||
527 (valid_cp_range(bootstrap_method_ref_index, length) &&
528 (cp->tag_at(bootstrap_method_ref_index).is_method_handle())),
529 "Invalid constant pool index %u in class file %s",
530 bootstrap_method_ref_index,
531 CHECK_(nullHandle));
532 check_property(valid_cp_range(name_and_type_ref_index, length) &&
533 cp->tag_at(name_and_type_ref_index).is_name_and_type(),
534 "Invalid constant pool index %u in class file %s",
535 name_and_type_ref_index,
536 CHECK_(nullHandle));
537 int argc = cp->invoke_dynamic_argument_count_at(index);
538 for (int arg_i = 0; arg_i < argc; arg_i++) {
539 int arg = cp->invoke_dynamic_argument_index_at(index, arg_i);
540 check_property(valid_cp_range(arg, length) &&
541 cp->tag_at(arg).is_loadable_constant() ||
542 // temporary early forms of string and class:
543 cp->tag_at(arg).is_klass_index() ||
544 cp->tag_at(arg).is_string_index(),
545 "Invalid constant pool index %u in class file %s",
546 arg,
547 CHECK_(nullHandle));
548 }
549 break;
550 }
551 default:
552 fatal(err_msg("bad constant pool tag value %u",
553 cp->tag_at(index).value()));
554 ShouldNotReachHere();
555 break;
556 } // end of switch
557 } // end of for
559 if (_cp_patches != NULL) {
560 // need to treat this_class specially...
561 assert(AnonymousClasses, "");
562 int this_class_index;
563 {
564 cfs->guarantee_more(8, CHECK_(nullHandle)); // flags, this_class, super_class, infs_len
565 u1* mark = cfs->current();
566 u2 flags = cfs->get_u2_fast();
567 this_class_index = cfs->get_u2_fast();
568 cfs->set_current(mark); // revert to mark
569 }
571 for (index = 1; index < length; index++) { // Index 0 is unused
572 if (has_cp_patch_at(index)) {
573 guarantee_property(index != this_class_index,
574 "Illegal constant pool patch to self at %d in class file %s",
575 index, CHECK_(nullHandle));
576 patch_constant_pool(cp, index, cp_patch_at(index), CHECK_(nullHandle));
577 }
578 }
579 // Ensure that all the patches have been used.
580 for (index = 0; index < _cp_patches->length(); index++) {
581 guarantee_property(!has_cp_patch_at(index),
582 "Unused constant pool patch at %d in class file %s",
583 index, CHECK_(nullHandle));
584 }
585 }
587 if (!_need_verify) {
588 return cp;
589 }
591 // second verification pass - checks the strings are of the right format.
592 // but not yet to the other entries
593 for (index = 1; index < length; index++) {
594 jbyte tag = cp->tag_at(index).value();
595 switch (tag) {
596 case JVM_CONSTANT_UnresolvedClass: {
597 symbolHandle class_name(THREAD, cp->unresolved_klass_at(index));
598 // check the name, even if _cp_patches will overwrite it
599 verify_legal_class_name(class_name, CHECK_(nullHandle));
600 break;
601 }
602 case JVM_CONSTANT_NameAndType: {
603 if (_need_verify && _major_version >= JAVA_7_VERSION) {
604 int sig_index = cp->signature_ref_index_at(index);
605 int name_index = cp->name_ref_index_at(index);
606 symbolHandle name(THREAD, cp->symbol_at(name_index));
607 symbolHandle sig(THREAD, cp->symbol_at(sig_index));
608 if (sig->byte_at(0) == JVM_SIGNATURE_FUNC) {
609 verify_legal_method_signature(name, sig, CHECK_(nullHandle));
610 } else {
611 verify_legal_field_signature(name, sig, CHECK_(nullHandle));
612 }
613 }
614 break;
615 }
616 case JVM_CONSTANT_Fieldref:
617 case JVM_CONSTANT_Methodref:
618 case JVM_CONSTANT_InterfaceMethodref: {
619 int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
620 // already verified to be utf8
621 int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);
622 // already verified to be utf8
623 int signature_ref_index = cp->signature_ref_index_at(name_and_type_ref_index);
624 symbolHandle name(THREAD, cp->symbol_at(name_ref_index));
625 symbolHandle signature(THREAD, cp->symbol_at(signature_ref_index));
626 if (tag == JVM_CONSTANT_Fieldref) {
627 verify_legal_field_name(name, CHECK_(nullHandle));
628 if (_need_verify && _major_version >= JAVA_7_VERSION) {
629 // Signature is verified above, when iterating NameAndType_info.
630 // Need only to be sure it's the right type.
631 if (signature->byte_at(0) == JVM_SIGNATURE_FUNC) {
632 throwIllegalSignature(
633 "Field", name, signature, CHECK_(nullHandle));
634 }
635 } else {
636 verify_legal_field_signature(name, signature, CHECK_(nullHandle));
637 }
638 } else {
639 verify_legal_method_name(name, CHECK_(nullHandle));
640 if (_need_verify && _major_version >= JAVA_7_VERSION) {
641 // Signature is verified above, when iterating NameAndType_info.
642 // Need only to be sure it's the right type.
643 if (signature->byte_at(0) != JVM_SIGNATURE_FUNC) {
644 throwIllegalSignature(
645 "Method", name, signature, CHECK_(nullHandle));
646 }
647 } else {
648 verify_legal_method_signature(name, signature, CHECK_(nullHandle));
649 }
650 if (tag == JVM_CONSTANT_Methodref) {
651 // 4509014: If a class method name begins with '<', it must be "<init>".
652 assert(!name.is_null(), "method name in constant pool is null");
653 unsigned int name_len = name->utf8_length();
654 assert(name_len > 0, "bad method name"); // already verified as legal name
655 if (name->byte_at(0) == '<') {
656 if (name() != vmSymbols::object_initializer_name()) {
657 classfile_parse_error(
658 "Bad method name at constant pool index %u in class file %s",
659 name_ref_index, CHECK_(nullHandle));
660 }
661 }
662 }
663 }
664 break;
665 }
666 case JVM_CONSTANT_MethodHandle: {
667 int ref_index = cp->method_handle_index_at(index);
668 int ref_kind = cp->method_handle_ref_kind_at(index);
669 switch (ref_kind) {
670 case JVM_REF_invokeVirtual:
671 case JVM_REF_invokeStatic:
672 case JVM_REF_invokeSpecial:
673 case JVM_REF_newInvokeSpecial:
674 {
675 int name_and_type_ref_index = cp->name_and_type_ref_index_at(ref_index);
676 int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);
677 symbolHandle name(THREAD, cp->symbol_at(name_ref_index));
678 if (ref_kind == JVM_REF_newInvokeSpecial) {
679 if (name() != vmSymbols::object_initializer_name()) {
680 classfile_parse_error(
681 "Bad constructor name at constant pool index %u in class file %s",
682 name_ref_index, CHECK_(nullHandle));
683 }
684 } else {
685 if (name() == vmSymbols::object_initializer_name()) {
686 classfile_parse_error(
687 "Bad method name at constant pool index %u in class file %s",
688 name_ref_index, CHECK_(nullHandle));
689 }
690 }
691 }
692 break;
693 // Other ref_kinds are already fully checked in previous pass.
694 }
695 break;
696 }
697 case JVM_CONSTANT_MethodType: {
698 symbolHandle no_name = vmSymbolHandles::type_name(); // place holder
699 symbolHandle signature(THREAD, cp->method_type_signature_at(index));
700 verify_legal_method_signature(no_name, signature, CHECK_(nullHandle));
701 break;
702 }
703 } // end of switch
704 } // end of for
706 return cp;
707 }
710 void ClassFileParser::patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS) {
711 assert(AnonymousClasses, "");
712 BasicType patch_type = T_VOID;
713 switch (cp->tag_at(index).value()) {
715 case JVM_CONSTANT_UnresolvedClass :
716 // Patching a class means pre-resolving it.
717 // The name in the constant pool is ignored.
718 if (java_lang_Class::is_instance(patch())) {
719 guarantee_property(!java_lang_Class::is_primitive(patch()),
720 "Illegal class patch at %d in class file %s",
721 index, CHECK);
722 cp->klass_at_put(index, java_lang_Class::as_klassOop(patch()));
723 } else {
724 guarantee_property(java_lang_String::is_instance(patch()),
725 "Illegal class patch at %d in class file %s",
726 index, CHECK);
727 symbolHandle name = java_lang_String::as_symbol(patch(), CHECK);
728 cp->unresolved_klass_at_put(index, name());
729 }
730 break;
732 case JVM_CONSTANT_UnresolvedString :
733 // Patching a string means pre-resolving it.
734 // The spelling in the constant pool is ignored.
735 // The constant reference may be any object whatever.
736 // If it is not a real interned string, the constant is referred
737 // to as a "pseudo-string", and must be presented to the CP
738 // explicitly, because it may require scavenging.
739 cp->pseudo_string_at_put(index, patch());
740 break;
742 case JVM_CONSTANT_Integer : patch_type = T_INT; goto patch_prim;
743 case JVM_CONSTANT_Float : patch_type = T_FLOAT; goto patch_prim;
744 case JVM_CONSTANT_Long : patch_type = T_LONG; goto patch_prim;
745 case JVM_CONSTANT_Double : patch_type = T_DOUBLE; goto patch_prim;
746 patch_prim:
747 {
748 jvalue value;
749 BasicType value_type = java_lang_boxing_object::get_value(patch(), &value);
750 guarantee_property(value_type == patch_type,
751 "Illegal primitive patch at %d in class file %s",
752 index, CHECK);
753 switch (value_type) {
754 case T_INT: cp->int_at_put(index, value.i); break;
755 case T_FLOAT: cp->float_at_put(index, value.f); break;
756 case T_LONG: cp->long_at_put(index, value.j); break;
757 case T_DOUBLE: cp->double_at_put(index, value.d); break;
758 default: assert(false, "");
759 }
760 }
761 break;
763 default:
764 // %%% TODO: put method handles into CONSTANT_InterfaceMethodref, etc.
765 guarantee_property(!has_cp_patch_at(index),
766 "Illegal unexpected patch at %d in class file %s",
767 index, CHECK);
768 return;
769 }
771 // On fall-through, mark the patch as used.
772 clear_cp_patch_at(index);
773 }
777 class NameSigHash: public ResourceObj {
778 public:
779 symbolOop _name; // name
780 symbolOop _sig; // signature
781 NameSigHash* _next; // Next entry in hash table
782 };
785 #define HASH_ROW_SIZE 256
787 unsigned int hash(symbolOop name, symbolOop sig) {
788 unsigned int raw_hash = 0;
789 raw_hash += ((unsigned int)(uintptr_t)name) >> (LogHeapWordSize + 2);
790 raw_hash += ((unsigned int)(uintptr_t)sig) >> LogHeapWordSize;
792 return (raw_hash + (unsigned int)(uintptr_t)name) % HASH_ROW_SIZE;
793 }
796 void initialize_hashtable(NameSigHash** table) {
797 memset((void*)table, 0, sizeof(NameSigHash*) * HASH_ROW_SIZE);
798 }
800 // Return false if the name/sig combination is found in table.
801 // Return true if no duplicate is found. And name/sig is added as a new entry in table.
802 // The old format checker uses heap sort to find duplicates.
803 // NOTE: caller should guarantee that GC doesn't happen during the life cycle
804 // of table since we don't expect symbolOop's to move.
805 bool put_after_lookup(symbolOop name, symbolOop sig, NameSigHash** table) {
806 assert(name != NULL, "name in constant pool is NULL");
808 // First lookup for duplicates
809 int index = hash(name, sig);
810 NameSigHash* entry = table[index];
811 while (entry != NULL) {
812 if (entry->_name == name && entry->_sig == sig) {
813 return false;
814 }
815 entry = entry->_next;
816 }
818 // No duplicate is found, allocate a new entry and fill it.
819 entry = new NameSigHash();
820 entry->_name = name;
821 entry->_sig = sig;
823 // Insert into hash table
824 entry->_next = table[index];
825 table[index] = entry;
827 return true;
828 }
831 objArrayHandle ClassFileParser::parse_interfaces(constantPoolHandle cp,
832 int length,
833 Handle class_loader,
834 Handle protection_domain,
835 symbolHandle class_name,
836 TRAPS) {
837 ClassFileStream* cfs = stream();
838 assert(length > 0, "only called for length>0");
839 objArrayHandle nullHandle;
840 objArrayOop interface_oop = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
841 objArrayHandle interfaces (THREAD, interface_oop);
843 int index;
844 for (index = 0; index < length; index++) {
845 u2 interface_index = cfs->get_u2(CHECK_(nullHandle));
846 KlassHandle interf;
847 check_property(
848 valid_cp_range(interface_index, cp->length()) &&
849 is_klass_reference(cp, interface_index),
850 "Interface name has bad constant pool index %u in class file %s",
851 interface_index, CHECK_(nullHandle));
852 if (cp->tag_at(interface_index).is_klass()) {
853 interf = KlassHandle(THREAD, cp->resolved_klass_at(interface_index));
854 } else {
855 symbolHandle unresolved_klass (THREAD, cp->klass_name_at(interface_index));
857 // Don't need to check legal name because it's checked when parsing constant pool.
858 // But need to make sure it's not an array type.
859 guarantee_property(unresolved_klass->byte_at(0) != JVM_SIGNATURE_ARRAY,
860 "Bad interface name in class file %s", CHECK_(nullHandle));
862 // Call resolve_super so classcircularity is checked
863 klassOop k = SystemDictionary::resolve_super_or_fail(class_name,
864 unresolved_klass, class_loader, protection_domain,
865 false, CHECK_(nullHandle));
866 interf = KlassHandle(THREAD, k);
868 if (LinkWellKnownClasses) // my super type is well known to me
869 cp->klass_at_put(interface_index, interf()); // eagerly resolve
870 }
872 if (!Klass::cast(interf())->is_interface()) {
873 THROW_MSG_(vmSymbols::java_lang_IncompatibleClassChangeError(), "Implementing class", nullHandle);
874 }
875 interfaces->obj_at_put(index, interf());
876 }
878 if (!_need_verify || length <= 1) {
879 return interfaces;
880 }
882 // Check if there's any duplicates in interfaces
883 ResourceMark rm(THREAD);
884 NameSigHash** interface_names = NEW_RESOURCE_ARRAY_IN_THREAD(
885 THREAD, NameSigHash*, HASH_ROW_SIZE);
886 initialize_hashtable(interface_names);
887 bool dup = false;
888 {
889 debug_only(No_Safepoint_Verifier nsv;)
890 for (index = 0; index < length; index++) {
891 klassOop k = (klassOop)interfaces->obj_at(index);
892 symbolOop name = instanceKlass::cast(k)->name();
893 // If no duplicates, add (name, NULL) in hashtable interface_names.
894 if (!put_after_lookup(name, NULL, interface_names)) {
895 dup = true;
896 break;
897 }
898 }
899 }
900 if (dup) {
901 classfile_parse_error("Duplicate interface name in class file %s",
902 CHECK_(nullHandle));
903 }
905 return interfaces;
906 }
909 void ClassFileParser::verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, TRAPS) {
910 // Make sure the constant pool entry is of a type appropriate to this field
911 guarantee_property(
912 (constantvalue_index > 0 &&
913 constantvalue_index < cp->length()),
914 "Bad initial value index %u in ConstantValue attribute in class file %s",
915 constantvalue_index, CHECK);
916 constantTag value_type = cp->tag_at(constantvalue_index);
917 switch ( cp->basic_type_for_signature_at(signature_index) ) {
918 case T_LONG:
919 guarantee_property(value_type.is_long(), "Inconsistent constant value type in class file %s", CHECK);
920 break;
921 case T_FLOAT:
922 guarantee_property(value_type.is_float(), "Inconsistent constant value type in class file %s", CHECK);
923 break;
924 case T_DOUBLE:
925 guarantee_property(value_type.is_double(), "Inconsistent constant value type in class file %s", CHECK);
926 break;
927 case T_BYTE: case T_CHAR: case T_SHORT: case T_BOOLEAN: case T_INT:
928 guarantee_property(value_type.is_int(), "Inconsistent constant value type in class file %s", CHECK);
929 break;
930 case T_OBJECT:
931 guarantee_property((cp->symbol_at(signature_index)->equals("Ljava/lang/String;")
932 && (value_type.is_string() || value_type.is_unresolved_string())),
933 "Bad string initial value in class file %s", CHECK);
934 break;
935 default:
936 classfile_parse_error(
937 "Unable to set initial value %u in class file %s",
938 constantvalue_index, CHECK);
939 }
940 }
943 // Parse attributes for a field.
944 void ClassFileParser::parse_field_attributes(constantPoolHandle cp,
945 u2 attributes_count,
946 bool is_static, u2 signature_index,
947 u2* constantvalue_index_addr,
948 bool* is_synthetic_addr,
949 u2* generic_signature_index_addr,
950 typeArrayHandle* field_annotations,
951 TRAPS) {
952 ClassFileStream* cfs = stream();
953 assert(attributes_count > 0, "length should be greater than 0");
954 u2 constantvalue_index = 0;
955 u2 generic_signature_index = 0;
956 bool is_synthetic = false;
957 u1* runtime_visible_annotations = NULL;
958 int runtime_visible_annotations_length = 0;
959 u1* runtime_invisible_annotations = NULL;
960 int runtime_invisible_annotations_length = 0;
961 while (attributes_count--) {
962 cfs->guarantee_more(6, CHECK); // attribute_name_index, attribute_length
963 u2 attribute_name_index = cfs->get_u2_fast();
964 u4 attribute_length = cfs->get_u4_fast();
965 check_property(valid_cp_range(attribute_name_index, cp->length()) &&
966 cp->tag_at(attribute_name_index).is_utf8(),
967 "Invalid field attribute index %u in class file %s",
968 attribute_name_index,
969 CHECK);
970 symbolOop attribute_name = cp->symbol_at(attribute_name_index);
971 if (is_static && attribute_name == vmSymbols::tag_constant_value()) {
972 // ignore if non-static
973 if (constantvalue_index != 0) {
974 classfile_parse_error("Duplicate ConstantValue attribute in class file %s", CHECK);
975 }
976 check_property(
977 attribute_length == 2,
978 "Invalid ConstantValue field attribute length %u in class file %s",
979 attribute_length, CHECK);
980 constantvalue_index = cfs->get_u2(CHECK);
981 if (_need_verify) {
982 verify_constantvalue(constantvalue_index, signature_index, cp, CHECK);
983 }
984 } else if (attribute_name == vmSymbols::tag_synthetic()) {
985 if (attribute_length != 0) {
986 classfile_parse_error(
987 "Invalid Synthetic field attribute length %u in class file %s",
988 attribute_length, CHECK);
989 }
990 is_synthetic = true;
991 } else if (attribute_name == vmSymbols::tag_deprecated()) { // 4276120
992 if (attribute_length != 0) {
993 classfile_parse_error(
994 "Invalid Deprecated field attribute length %u in class file %s",
995 attribute_length, CHECK);
996 }
997 } else if (_major_version >= JAVA_1_5_VERSION) {
998 if (attribute_name == vmSymbols::tag_signature()) {
999 if (attribute_length != 2) {
1000 classfile_parse_error(
1001 "Wrong size %u for field's Signature attribute in class file %s",
1002 attribute_length, CHECK);
1003 }
1004 generic_signature_index = cfs->get_u2(CHECK);
1005 } else if (attribute_name == vmSymbols::tag_runtime_visible_annotations()) {
1006 runtime_visible_annotations_length = attribute_length;
1007 runtime_visible_annotations = cfs->get_u1_buffer();
1008 assert(runtime_visible_annotations != NULL, "null visible annotations");
1009 cfs->skip_u1(runtime_visible_annotations_length, CHECK);
1010 } else if (PreserveAllAnnotations && attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {
1011 runtime_invisible_annotations_length = attribute_length;
1012 runtime_invisible_annotations = cfs->get_u1_buffer();
1013 assert(runtime_invisible_annotations != NULL, "null invisible annotations");
1014 cfs->skip_u1(runtime_invisible_annotations_length, CHECK);
1015 } else {
1016 cfs->skip_u1(attribute_length, CHECK); // Skip unknown attributes
1017 }
1018 } else {
1019 cfs->skip_u1(attribute_length, CHECK); // Skip unknown attributes
1020 }
1021 }
1023 *constantvalue_index_addr = constantvalue_index;
1024 *is_synthetic_addr = is_synthetic;
1025 *generic_signature_index_addr = generic_signature_index;
1026 *field_annotations = assemble_annotations(runtime_visible_annotations,
1027 runtime_visible_annotations_length,
1028 runtime_invisible_annotations,
1029 runtime_invisible_annotations_length,
1030 CHECK);
1031 return;
1032 }
1035 // Field allocation types. Used for computing field offsets.
1037 enum FieldAllocationType {
1038 STATIC_OOP, // Oops
1039 STATIC_BYTE, // Boolean, Byte, char
1040 STATIC_SHORT, // shorts
1041 STATIC_WORD, // ints
1042 STATIC_DOUBLE, // long or double
1043 STATIC_ALIGNED_DOUBLE,// aligned long or double
1044 NONSTATIC_OOP,
1045 NONSTATIC_BYTE,
1046 NONSTATIC_SHORT,
1047 NONSTATIC_WORD,
1048 NONSTATIC_DOUBLE,
1049 NONSTATIC_ALIGNED_DOUBLE
1050 };
1053 struct FieldAllocationCount {
1054 unsigned int static_oop_count;
1055 unsigned int static_byte_count;
1056 unsigned int static_short_count;
1057 unsigned int static_word_count;
1058 unsigned int static_double_count;
1059 unsigned int nonstatic_oop_count;
1060 unsigned int nonstatic_byte_count;
1061 unsigned int nonstatic_short_count;
1062 unsigned int nonstatic_word_count;
1063 unsigned int nonstatic_double_count;
1064 };
1066 typeArrayHandle ClassFileParser::parse_fields(constantPoolHandle cp, bool is_interface,
1067 struct FieldAllocationCount *fac,
1068 objArrayHandle* fields_annotations, TRAPS) {
1069 ClassFileStream* cfs = stream();
1070 typeArrayHandle nullHandle;
1071 cfs->guarantee_more(2, CHECK_(nullHandle)); // length
1072 u2 length = cfs->get_u2_fast();
1073 // Tuples of shorts [access, name index, sig index, initial value index, byte offset, generic signature index]
1074 typeArrayOop new_fields = oopFactory::new_permanent_shortArray(length*instanceKlass::next_offset, CHECK_(nullHandle));
1075 typeArrayHandle fields(THREAD, new_fields);
1077 int index = 0;
1078 typeArrayHandle field_annotations;
1079 for (int n = 0; n < length; n++) {
1080 cfs->guarantee_more(8, CHECK_(nullHandle)); // access_flags, name_index, descriptor_index, attributes_count
1082 AccessFlags access_flags;
1083 jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_FIELD_MODIFIERS;
1084 verify_legal_field_modifiers(flags, is_interface, CHECK_(nullHandle));
1085 access_flags.set_flags(flags);
1087 u2 name_index = cfs->get_u2_fast();
1088 int cp_size = cp->length();
1089 check_property(
1090 valid_cp_range(name_index, cp_size) && cp->tag_at(name_index).is_utf8(),
1091 "Invalid constant pool index %u for field name in class file %s",
1092 name_index, CHECK_(nullHandle));
1093 symbolHandle name(THREAD, cp->symbol_at(name_index));
1094 verify_legal_field_name(name, CHECK_(nullHandle));
1096 u2 signature_index = cfs->get_u2_fast();
1097 check_property(
1098 valid_cp_range(signature_index, cp_size) &&
1099 cp->tag_at(signature_index).is_utf8(),
1100 "Invalid constant pool index %u for field signature in class file %s",
1101 signature_index, CHECK_(nullHandle));
1102 symbolHandle sig(THREAD, cp->symbol_at(signature_index));
1103 verify_legal_field_signature(name, sig, CHECK_(nullHandle));
1105 u2 constantvalue_index = 0;
1106 bool is_synthetic = false;
1107 u2 generic_signature_index = 0;
1108 bool is_static = access_flags.is_static();
1110 u2 attributes_count = cfs->get_u2_fast();
1111 if (attributes_count > 0) {
1112 parse_field_attributes(cp, attributes_count, is_static, signature_index,
1113 &constantvalue_index, &is_synthetic,
1114 &generic_signature_index, &field_annotations,
1115 CHECK_(nullHandle));
1116 if (field_annotations.not_null()) {
1117 if (fields_annotations->is_null()) {
1118 objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
1119 *fields_annotations = objArrayHandle(THREAD, md);
1120 }
1121 (*fields_annotations)->obj_at_put(n, field_annotations());
1122 }
1123 if (is_synthetic) {
1124 access_flags.set_is_synthetic();
1125 }
1126 }
1128 fields->short_at_put(index++, access_flags.as_short());
1129 fields->short_at_put(index++, name_index);
1130 fields->short_at_put(index++, signature_index);
1131 fields->short_at_put(index++, constantvalue_index);
1133 // Remember how many oops we encountered and compute allocation type
1134 BasicType type = cp->basic_type_for_signature_at(signature_index);
1135 FieldAllocationType atype;
1136 if ( is_static ) {
1137 switch ( type ) {
1138 case T_BOOLEAN:
1139 case T_BYTE:
1140 fac->static_byte_count++;
1141 atype = STATIC_BYTE;
1142 break;
1143 case T_LONG:
1144 case T_DOUBLE:
1145 if (Universe::field_type_should_be_aligned(type)) {
1146 atype = STATIC_ALIGNED_DOUBLE;
1147 } else {
1148 atype = STATIC_DOUBLE;
1149 }
1150 fac->static_double_count++;
1151 break;
1152 case T_CHAR:
1153 case T_SHORT:
1154 fac->static_short_count++;
1155 atype = STATIC_SHORT;
1156 break;
1157 case T_FLOAT:
1158 case T_INT:
1159 fac->static_word_count++;
1160 atype = STATIC_WORD;
1161 break;
1162 case T_ARRAY:
1163 case T_OBJECT:
1164 fac->static_oop_count++;
1165 atype = STATIC_OOP;
1166 break;
1167 case T_ADDRESS:
1168 case T_VOID:
1169 default:
1170 assert(0, "bad field type");
1171 }
1172 } else {
1173 switch ( type ) {
1174 case T_BOOLEAN:
1175 case T_BYTE:
1176 fac->nonstatic_byte_count++;
1177 atype = NONSTATIC_BYTE;
1178 break;
1179 case T_LONG:
1180 case T_DOUBLE:
1181 if (Universe::field_type_should_be_aligned(type)) {
1182 atype = NONSTATIC_ALIGNED_DOUBLE;
1183 } else {
1184 atype = NONSTATIC_DOUBLE;
1185 }
1186 fac->nonstatic_double_count++;
1187 break;
1188 case T_CHAR:
1189 case T_SHORT:
1190 fac->nonstatic_short_count++;
1191 atype = NONSTATIC_SHORT;
1192 break;
1193 case T_FLOAT:
1194 case T_INT:
1195 fac->nonstatic_word_count++;
1196 atype = NONSTATIC_WORD;
1197 break;
1198 case T_ARRAY:
1199 case T_OBJECT:
1200 fac->nonstatic_oop_count++;
1201 atype = NONSTATIC_OOP;
1202 break;
1203 case T_ADDRESS:
1204 case T_VOID:
1205 default:
1206 assert(0, "bad field type");
1207 }
1208 }
1210 // The correct offset is computed later (all oop fields will be located together)
1211 // We temporarily store the allocation type in the offset field
1212 fields->short_at_put(index++, atype);
1213 fields->short_at_put(index++, 0); // Clear out high word of byte offset
1214 fields->short_at_put(index++, generic_signature_index);
1215 }
1217 if (_need_verify && length > 1) {
1218 // Check duplicated fields
1219 ResourceMark rm(THREAD);
1220 NameSigHash** names_and_sigs = NEW_RESOURCE_ARRAY_IN_THREAD(
1221 THREAD, NameSigHash*, HASH_ROW_SIZE);
1222 initialize_hashtable(names_and_sigs);
1223 bool dup = false;
1224 {
1225 debug_only(No_Safepoint_Verifier nsv;)
1226 for (int i = 0; i < length*instanceKlass::next_offset; i += instanceKlass::next_offset) {
1227 int name_index = fields->ushort_at(i + instanceKlass::name_index_offset);
1228 symbolOop name = cp->symbol_at(name_index);
1229 int sig_index = fields->ushort_at(i + instanceKlass::signature_index_offset);
1230 symbolOop sig = cp->symbol_at(sig_index);
1231 // If no duplicates, add name/signature in hashtable names_and_sigs.
1232 if (!put_after_lookup(name, sig, names_and_sigs)) {
1233 dup = true;
1234 break;
1235 }
1236 }
1237 }
1238 if (dup) {
1239 classfile_parse_error("Duplicate field name&signature in class file %s",
1240 CHECK_(nullHandle));
1241 }
1242 }
1244 return fields;
1245 }
1248 static void copy_u2_with_conversion(u2* dest, u2* src, int length) {
1249 while (length-- > 0) {
1250 *dest++ = Bytes::get_Java_u2((u1*) (src++));
1251 }
1252 }
1255 typeArrayHandle ClassFileParser::parse_exception_table(u4 code_length,
1256 u4 exception_table_length,
1257 constantPoolHandle cp,
1258 TRAPS) {
1259 ClassFileStream* cfs = stream();
1260 typeArrayHandle nullHandle;
1262 // 4-tuples of ints [start_pc, end_pc, handler_pc, catch_type index]
1263 typeArrayOop eh = oopFactory::new_permanent_intArray(exception_table_length*4, CHECK_(nullHandle));
1264 typeArrayHandle exception_handlers = typeArrayHandle(THREAD, eh);
1266 int index = 0;
1267 cfs->guarantee_more(8 * exception_table_length, CHECK_(nullHandle)); // start_pc, end_pc, handler_pc, catch_type_index
1268 for (unsigned int i = 0; i < exception_table_length; i++) {
1269 u2 start_pc = cfs->get_u2_fast();
1270 u2 end_pc = cfs->get_u2_fast();
1271 u2 handler_pc = cfs->get_u2_fast();
1272 u2 catch_type_index = cfs->get_u2_fast();
1273 // Will check legal target after parsing code array in verifier.
1274 if (_need_verify) {
1275 guarantee_property((start_pc < end_pc) && (end_pc <= code_length),
1276 "Illegal exception table range in class file %s", CHECK_(nullHandle));
1277 guarantee_property(handler_pc < code_length,
1278 "Illegal exception table handler in class file %s", CHECK_(nullHandle));
1279 if (catch_type_index != 0) {
1280 guarantee_property(valid_cp_range(catch_type_index, cp->length()) &&
1281 is_klass_reference(cp, catch_type_index),
1282 "Catch type in exception table has bad constant type in class file %s", CHECK_(nullHandle));
1283 }
1284 }
1285 exception_handlers->int_at_put(index++, start_pc);
1286 exception_handlers->int_at_put(index++, end_pc);
1287 exception_handlers->int_at_put(index++, handler_pc);
1288 exception_handlers->int_at_put(index++, catch_type_index);
1289 }
1290 return exception_handlers;
1291 }
1293 void ClassFileParser::parse_linenumber_table(
1294 u4 code_attribute_length, u4 code_length,
1295 CompressedLineNumberWriteStream** write_stream, TRAPS) {
1296 ClassFileStream* cfs = stream();
1297 unsigned int num_entries = cfs->get_u2(CHECK);
1299 // Each entry is a u2 start_pc, and a u2 line_number
1300 unsigned int length_in_bytes = num_entries * (sizeof(u2) + sizeof(u2));
1302 // Verify line number attribute and table length
1303 check_property(
1304 code_attribute_length == sizeof(u2) + length_in_bytes,
1305 "LineNumberTable attribute has wrong length in class file %s", CHECK);
1307 cfs->guarantee_more(length_in_bytes, CHECK);
1309 if ((*write_stream) == NULL) {
1310 if (length_in_bytes > fixed_buffer_size) {
1311 (*write_stream) = new CompressedLineNumberWriteStream(length_in_bytes);
1312 } else {
1313 (*write_stream) = new CompressedLineNumberWriteStream(
1314 linenumbertable_buffer, fixed_buffer_size);
1315 }
1316 }
1318 while (num_entries-- > 0) {
1319 u2 bci = cfs->get_u2_fast(); // start_pc
1320 u2 line = cfs->get_u2_fast(); // line_number
1321 guarantee_property(bci < code_length,
1322 "Invalid pc in LineNumberTable in class file %s", CHECK);
1323 (*write_stream)->write_pair(bci, line);
1324 }
1325 }
1328 // Class file LocalVariableTable elements.
1329 class Classfile_LVT_Element VALUE_OBJ_CLASS_SPEC {
1330 public:
1331 u2 start_bci;
1332 u2 length;
1333 u2 name_cp_index;
1334 u2 descriptor_cp_index;
1335 u2 slot;
1336 };
1339 class LVT_Hash: public CHeapObj {
1340 public:
1341 LocalVariableTableElement *_elem; // element
1342 LVT_Hash* _next; // Next entry in hash table
1343 };
1345 unsigned int hash(LocalVariableTableElement *elem) {
1346 unsigned int raw_hash = elem->start_bci;
1348 raw_hash = elem->length + raw_hash * 37;
1349 raw_hash = elem->name_cp_index + raw_hash * 37;
1350 raw_hash = elem->slot + raw_hash * 37;
1352 return raw_hash % HASH_ROW_SIZE;
1353 }
1355 void initialize_hashtable(LVT_Hash** table) {
1356 for (int i = 0; i < HASH_ROW_SIZE; i++) {
1357 table[i] = NULL;
1358 }
1359 }
1361 void clear_hashtable(LVT_Hash** table) {
1362 for (int i = 0; i < HASH_ROW_SIZE; i++) {
1363 LVT_Hash* current = table[i];
1364 LVT_Hash* next;
1365 while (current != NULL) {
1366 next = current->_next;
1367 current->_next = NULL;
1368 delete(current);
1369 current = next;
1370 }
1371 table[i] = NULL;
1372 }
1373 }
1375 LVT_Hash* LVT_lookup(LocalVariableTableElement *elem, int index, LVT_Hash** table) {
1376 LVT_Hash* entry = table[index];
1378 /*
1379 * 3-tuple start_bci/length/slot has to be unique key,
1380 * so the following comparison seems to be redundant:
1381 * && elem->name_cp_index == entry->_elem->name_cp_index
1382 */
1383 while (entry != NULL) {
1384 if (elem->start_bci == entry->_elem->start_bci
1385 && elem->length == entry->_elem->length
1386 && elem->name_cp_index == entry->_elem->name_cp_index
1387 && elem->slot == entry->_elem->slot
1388 ) {
1389 return entry;
1390 }
1391 entry = entry->_next;
1392 }
1393 return NULL;
1394 }
1396 // Return false if the local variable is found in table.
1397 // Return true if no duplicate is found.
1398 // And local variable is added as a new entry in table.
1399 bool LVT_put_after_lookup(LocalVariableTableElement *elem, LVT_Hash** table) {
1400 // First lookup for duplicates
1401 int index = hash(elem);
1402 LVT_Hash* entry = LVT_lookup(elem, index, table);
1404 if (entry != NULL) {
1405 return false;
1406 }
1407 // No duplicate is found, allocate a new entry and fill it.
1408 if ((entry = new LVT_Hash()) == NULL) {
1409 return false;
1410 }
1411 entry->_elem = elem;
1413 // Insert into hash table
1414 entry->_next = table[index];
1415 table[index] = entry;
1417 return true;
1418 }
1420 void copy_lvt_element(Classfile_LVT_Element *src, LocalVariableTableElement *lvt) {
1421 lvt->start_bci = Bytes::get_Java_u2((u1*) &src->start_bci);
1422 lvt->length = Bytes::get_Java_u2((u1*) &src->length);
1423 lvt->name_cp_index = Bytes::get_Java_u2((u1*) &src->name_cp_index);
1424 lvt->descriptor_cp_index = Bytes::get_Java_u2((u1*) &src->descriptor_cp_index);
1425 lvt->signature_cp_index = 0;
1426 lvt->slot = Bytes::get_Java_u2((u1*) &src->slot);
1427 }
1429 // Function is used to parse both attributes:
1430 // LocalVariableTable (LVT) and LocalVariableTypeTable (LVTT)
1431 u2* ClassFileParser::parse_localvariable_table(u4 code_length,
1432 u2 max_locals,
1433 u4 code_attribute_length,
1434 constantPoolHandle cp,
1435 u2* localvariable_table_length,
1436 bool isLVTT,
1437 TRAPS) {
1438 ClassFileStream* cfs = stream();
1439 const char * tbl_name = (isLVTT) ? "LocalVariableTypeTable" : "LocalVariableTable";
1440 *localvariable_table_length = cfs->get_u2(CHECK_NULL);
1441 unsigned int size = (*localvariable_table_length) * sizeof(Classfile_LVT_Element) / sizeof(u2);
1442 // Verify local variable table attribute has right length
1443 if (_need_verify) {
1444 guarantee_property(code_attribute_length == (sizeof(*localvariable_table_length) + size * sizeof(u2)),
1445 "%s has wrong length in class file %s", tbl_name, CHECK_NULL);
1446 }
1447 u2* localvariable_table_start = cfs->get_u2_buffer();
1448 assert(localvariable_table_start != NULL, "null local variable table");
1449 if (!_need_verify) {
1450 cfs->skip_u2_fast(size);
1451 } else {
1452 cfs->guarantee_more(size * 2, CHECK_NULL);
1453 for(int i = 0; i < (*localvariable_table_length); i++) {
1454 u2 start_pc = cfs->get_u2_fast();
1455 u2 length = cfs->get_u2_fast();
1456 u2 name_index = cfs->get_u2_fast();
1457 u2 descriptor_index = cfs->get_u2_fast();
1458 u2 index = cfs->get_u2_fast();
1459 // Assign to a u4 to avoid overflow
1460 u4 end_pc = (u4)start_pc + (u4)length;
1462 if (start_pc >= code_length) {
1463 classfile_parse_error(
1464 "Invalid start_pc %u in %s in class file %s",
1465 start_pc, tbl_name, CHECK_NULL);
1466 }
1467 if (end_pc > code_length) {
1468 classfile_parse_error(
1469 "Invalid length %u in %s in class file %s",
1470 length, tbl_name, CHECK_NULL);
1471 }
1472 int cp_size = cp->length();
1473 guarantee_property(
1474 valid_cp_range(name_index, cp_size) &&
1475 cp->tag_at(name_index).is_utf8(),
1476 "Name index %u in %s has bad constant type in class file %s",
1477 name_index, tbl_name, CHECK_NULL);
1478 guarantee_property(
1479 valid_cp_range(descriptor_index, cp_size) &&
1480 cp->tag_at(descriptor_index).is_utf8(),
1481 "Signature index %u in %s has bad constant type in class file %s",
1482 descriptor_index, tbl_name, CHECK_NULL);
1484 symbolHandle name(THREAD, cp->symbol_at(name_index));
1485 symbolHandle sig(THREAD, cp->symbol_at(descriptor_index));
1486 verify_legal_field_name(name, CHECK_NULL);
1487 u2 extra_slot = 0;
1488 if (!isLVTT) {
1489 verify_legal_field_signature(name, sig, CHECK_NULL);
1491 // 4894874: check special cases for double and long local variables
1492 if (sig() == vmSymbols::type_signature(T_DOUBLE) ||
1493 sig() == vmSymbols::type_signature(T_LONG)) {
1494 extra_slot = 1;
1495 }
1496 }
1497 guarantee_property((index + extra_slot) < max_locals,
1498 "Invalid index %u in %s in class file %s",
1499 index, tbl_name, CHECK_NULL);
1500 }
1501 }
1502 return localvariable_table_start;
1503 }
1506 void ClassFileParser::parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index,
1507 u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS) {
1508 ClassFileStream* cfs = stream();
1509 u2 index = 0; // index in the array with long/double occupying two slots
1510 u4 i1 = *u1_index;
1511 u4 i2 = *u2_index + 1;
1512 for(int i = 0; i < array_length; i++) {
1513 u1 tag = u1_array[i1++] = cfs->get_u1(CHECK);
1514 index++;
1515 if (tag == ITEM_Long || tag == ITEM_Double) {
1516 index++;
1517 } else if (tag == ITEM_Object) {
1518 u2 class_index = u2_array[i2++] = cfs->get_u2(CHECK);
1519 guarantee_property(valid_cp_range(class_index, cp->length()) &&
1520 is_klass_reference(cp, class_index),
1521 "Bad class index %u in StackMap in class file %s",
1522 class_index, CHECK);
1523 } else if (tag == ITEM_Uninitialized) {
1524 u2 offset = u2_array[i2++] = cfs->get_u2(CHECK);
1525 guarantee_property(
1526 offset < code_length,
1527 "Bad uninitialized type offset %u in StackMap in class file %s",
1528 offset, CHECK);
1529 } else {
1530 guarantee_property(
1531 tag <= (u1)ITEM_Uninitialized,
1532 "Unknown variable type %u in StackMap in class file %s",
1533 tag, CHECK);
1534 }
1535 }
1536 u2_array[*u2_index] = index;
1537 *u1_index = i1;
1538 *u2_index = i2;
1539 }
1541 typeArrayOop ClassFileParser::parse_stackmap_table(
1542 u4 code_attribute_length, TRAPS) {
1543 if (code_attribute_length == 0)
1544 return NULL;
1546 ClassFileStream* cfs = stream();
1547 u1* stackmap_table_start = cfs->get_u1_buffer();
1548 assert(stackmap_table_start != NULL, "null stackmap table");
1550 // check code_attribute_length first
1551 stream()->skip_u1(code_attribute_length, CHECK_NULL);
1553 if (!_need_verify && !DumpSharedSpaces) {
1554 return NULL;
1555 }
1557 typeArrayOop stackmap_data =
1558 oopFactory::new_permanent_byteArray(code_attribute_length, CHECK_NULL);
1560 stackmap_data->set_length(code_attribute_length);
1561 memcpy((void*)stackmap_data->byte_at_addr(0),
1562 (void*)stackmap_table_start, code_attribute_length);
1563 return stackmap_data;
1564 }
1566 u2* ClassFileParser::parse_checked_exceptions(u2* checked_exceptions_length,
1567 u4 method_attribute_length,
1568 constantPoolHandle cp, TRAPS) {
1569 ClassFileStream* cfs = stream();
1570 cfs->guarantee_more(2, CHECK_NULL); // checked_exceptions_length
1571 *checked_exceptions_length = cfs->get_u2_fast();
1572 unsigned int size = (*checked_exceptions_length) * sizeof(CheckedExceptionElement) / sizeof(u2);
1573 u2* checked_exceptions_start = cfs->get_u2_buffer();
1574 assert(checked_exceptions_start != NULL, "null checked exceptions");
1575 if (!_need_verify) {
1576 cfs->skip_u2_fast(size);
1577 } else {
1578 // Verify each value in the checked exception table
1579 u2 checked_exception;
1580 u2 len = *checked_exceptions_length;
1581 cfs->guarantee_more(2 * len, CHECK_NULL);
1582 for (int i = 0; i < len; i++) {
1583 checked_exception = cfs->get_u2_fast();
1584 check_property(
1585 valid_cp_range(checked_exception, cp->length()) &&
1586 is_klass_reference(cp, checked_exception),
1587 "Exception name has bad type at constant pool %u in class file %s",
1588 checked_exception, CHECK_NULL);
1589 }
1590 }
1591 // check exceptions attribute length
1592 if (_need_verify) {
1593 guarantee_property(method_attribute_length == (sizeof(*checked_exceptions_length) +
1594 sizeof(u2) * size),
1595 "Exceptions attribute has wrong length in class file %s", CHECK_NULL);
1596 }
1597 return checked_exceptions_start;
1598 }
1600 void ClassFileParser::throwIllegalSignature(
1601 const char* type, symbolHandle name, symbolHandle sig, TRAPS) {
1602 ResourceMark rm(THREAD);
1603 Exceptions::fthrow(THREAD_AND_LOCATION,
1604 vmSymbols::java_lang_ClassFormatError(),
1605 "%s \"%s\" in class %s has illegal signature \"%s\"", type,
1606 name->as_C_string(), _class_name->as_C_string(), sig->as_C_string());
1607 }
1609 #define MAX_ARGS_SIZE 255
1610 #define MAX_CODE_SIZE 65535
1611 #define INITIAL_MAX_LVT_NUMBER 256
1613 // Note: the parse_method below is big and clunky because all parsing of the code and exceptions
1614 // attribute is inlined. This is curbersome to avoid since we inline most of the parts in the
1615 // methodOop to save footprint, so we only know the size of the resulting methodOop when the
1616 // entire method attribute is parsed.
1617 //
1618 // The promoted_flags parameter is used to pass relevant access_flags
1619 // from the method back up to the containing klass. These flag values
1620 // are added to klass's access_flags.
1622 methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interface,
1623 AccessFlags *promoted_flags,
1624 typeArrayHandle* method_annotations,
1625 typeArrayHandle* method_parameter_annotations,
1626 typeArrayHandle* method_default_annotations,
1627 TRAPS) {
1628 ClassFileStream* cfs = stream();
1629 methodHandle nullHandle;
1630 ResourceMark rm(THREAD);
1631 // Parse fixed parts
1632 cfs->guarantee_more(8, CHECK_(nullHandle)); // access_flags, name_index, descriptor_index, attributes_count
1634 int flags = cfs->get_u2_fast();
1635 u2 name_index = cfs->get_u2_fast();
1636 int cp_size = cp->length();
1637 check_property(
1638 valid_cp_range(name_index, cp_size) &&
1639 cp->tag_at(name_index).is_utf8(),
1640 "Illegal constant pool index %u for method name in class file %s",
1641 name_index, CHECK_(nullHandle));
1642 symbolHandle name(THREAD, cp->symbol_at(name_index));
1643 verify_legal_method_name(name, CHECK_(nullHandle));
1645 u2 signature_index = cfs->get_u2_fast();
1646 guarantee_property(
1647 valid_cp_range(signature_index, cp_size) &&
1648 cp->tag_at(signature_index).is_utf8(),
1649 "Illegal constant pool index %u for method signature in class file %s",
1650 signature_index, CHECK_(nullHandle));
1651 symbolHandle signature(THREAD, cp->symbol_at(signature_index));
1653 AccessFlags access_flags;
1654 if (name == vmSymbols::class_initializer_name()) {
1655 // We ignore the access flags for a class initializer. (JVM Spec. p. 116)
1656 flags = JVM_ACC_STATIC;
1657 } else {
1658 verify_legal_method_modifiers(flags, is_interface, name, CHECK_(nullHandle));
1659 }
1661 int args_size = -1; // only used when _need_verify is true
1662 if (_need_verify) {
1663 args_size = ((flags & JVM_ACC_STATIC) ? 0 : 1) +
1664 verify_legal_method_signature(name, signature, CHECK_(nullHandle));
1665 if (args_size > MAX_ARGS_SIZE) {
1666 classfile_parse_error("Too many arguments in method signature in class file %s", CHECK_(nullHandle));
1667 }
1668 }
1670 access_flags.set_flags(flags & JVM_RECOGNIZED_METHOD_MODIFIERS);
1672 // Default values for code and exceptions attribute elements
1673 u2 max_stack = 0;
1674 u2 max_locals = 0;
1675 u4 code_length = 0;
1676 u1* code_start = 0;
1677 u2 exception_table_length = 0;
1678 typeArrayHandle exception_handlers(THREAD, Universe::the_empty_int_array());
1679 u2 checked_exceptions_length = 0;
1680 u2* checked_exceptions_start = NULL;
1681 CompressedLineNumberWriteStream* linenumber_table = NULL;
1682 int linenumber_table_length = 0;
1683 int total_lvt_length = 0;
1684 u2 lvt_cnt = 0;
1685 u2 lvtt_cnt = 0;
1686 bool lvt_allocated = false;
1687 u2 max_lvt_cnt = INITIAL_MAX_LVT_NUMBER;
1688 u2 max_lvtt_cnt = INITIAL_MAX_LVT_NUMBER;
1689 u2* localvariable_table_length;
1690 u2** localvariable_table_start;
1691 u2* localvariable_type_table_length;
1692 u2** localvariable_type_table_start;
1693 bool parsed_code_attribute = false;
1694 bool parsed_checked_exceptions_attribute = false;
1695 bool parsed_stackmap_attribute = false;
1696 // stackmap attribute - JDK1.5
1697 typeArrayHandle stackmap_data;
1698 u2 generic_signature_index = 0;
1699 u1* runtime_visible_annotations = NULL;
1700 int runtime_visible_annotations_length = 0;
1701 u1* runtime_invisible_annotations = NULL;
1702 int runtime_invisible_annotations_length = 0;
1703 u1* runtime_visible_parameter_annotations = NULL;
1704 int runtime_visible_parameter_annotations_length = 0;
1705 u1* runtime_invisible_parameter_annotations = NULL;
1706 int runtime_invisible_parameter_annotations_length = 0;
1707 u1* annotation_default = NULL;
1708 int annotation_default_length = 0;
1710 // Parse code and exceptions attribute
1711 u2 method_attributes_count = cfs->get_u2_fast();
1712 while (method_attributes_count--) {
1713 cfs->guarantee_more(6, CHECK_(nullHandle)); // method_attribute_name_index, method_attribute_length
1714 u2 method_attribute_name_index = cfs->get_u2_fast();
1715 u4 method_attribute_length = cfs->get_u4_fast();
1716 check_property(
1717 valid_cp_range(method_attribute_name_index, cp_size) &&
1718 cp->tag_at(method_attribute_name_index).is_utf8(),
1719 "Invalid method attribute name index %u in class file %s",
1720 method_attribute_name_index, CHECK_(nullHandle));
1722 symbolOop method_attribute_name = cp->symbol_at(method_attribute_name_index);
1723 if (method_attribute_name == vmSymbols::tag_code()) {
1724 // Parse Code attribute
1725 if (_need_verify) {
1726 guarantee_property(!access_flags.is_native() && !access_flags.is_abstract(),
1727 "Code attribute in native or abstract methods in class file %s",
1728 CHECK_(nullHandle));
1729 }
1730 if (parsed_code_attribute) {
1731 classfile_parse_error("Multiple Code attributes in class file %s", CHECK_(nullHandle));
1732 }
1733 parsed_code_attribute = true;
1735 // Stack size, locals size, and code size
1736 if (_major_version == 45 && _minor_version <= 2) {
1737 cfs->guarantee_more(4, CHECK_(nullHandle));
1738 max_stack = cfs->get_u1_fast();
1739 max_locals = cfs->get_u1_fast();
1740 code_length = cfs->get_u2_fast();
1741 } else {
1742 cfs->guarantee_more(8, CHECK_(nullHandle));
1743 max_stack = cfs->get_u2_fast();
1744 max_locals = cfs->get_u2_fast();
1745 code_length = cfs->get_u4_fast();
1746 }
1747 if (_need_verify) {
1748 guarantee_property(args_size <= max_locals,
1749 "Arguments can't fit into locals in class file %s", CHECK_(nullHandle));
1750 guarantee_property(code_length > 0 && code_length <= MAX_CODE_SIZE,
1751 "Invalid method Code length %u in class file %s",
1752 code_length, CHECK_(nullHandle));
1753 }
1754 // Code pointer
1755 code_start = cfs->get_u1_buffer();
1756 assert(code_start != NULL, "null code start");
1757 cfs->guarantee_more(code_length, CHECK_(nullHandle));
1758 cfs->skip_u1_fast(code_length);
1760 // Exception handler table
1761 cfs->guarantee_more(2, CHECK_(nullHandle)); // exception_table_length
1762 exception_table_length = cfs->get_u2_fast();
1763 if (exception_table_length > 0) {
1764 exception_handlers =
1765 parse_exception_table(code_length, exception_table_length, cp, CHECK_(nullHandle));
1766 }
1768 // Parse additional attributes in code attribute
1769 cfs->guarantee_more(2, CHECK_(nullHandle)); // code_attributes_count
1770 u2 code_attributes_count = cfs->get_u2_fast();
1772 unsigned int calculated_attribute_length = 0;
1774 if (_major_version > 45 || (_major_version == 45 && _minor_version > 2)) {
1775 calculated_attribute_length =
1776 sizeof(max_stack) + sizeof(max_locals) + sizeof(code_length);
1777 } else {
1778 // max_stack, locals and length are smaller in pre-version 45.2 classes
1779 calculated_attribute_length = sizeof(u1) + sizeof(u1) + sizeof(u2);
1780 }
1781 calculated_attribute_length +=
1782 code_length +
1783 sizeof(exception_table_length) +
1784 sizeof(code_attributes_count) +
1785 exception_table_length *
1786 ( sizeof(u2) + // start_pc
1787 sizeof(u2) + // end_pc
1788 sizeof(u2) + // handler_pc
1789 sizeof(u2) ); // catch_type_index
1791 while (code_attributes_count--) {
1792 cfs->guarantee_more(6, CHECK_(nullHandle)); // code_attribute_name_index, code_attribute_length
1793 u2 code_attribute_name_index = cfs->get_u2_fast();
1794 u4 code_attribute_length = cfs->get_u4_fast();
1795 calculated_attribute_length += code_attribute_length +
1796 sizeof(code_attribute_name_index) +
1797 sizeof(code_attribute_length);
1798 check_property(valid_cp_range(code_attribute_name_index, cp_size) &&
1799 cp->tag_at(code_attribute_name_index).is_utf8(),
1800 "Invalid code attribute name index %u in class file %s",
1801 code_attribute_name_index,
1802 CHECK_(nullHandle));
1803 if (LoadLineNumberTables &&
1804 cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_line_number_table()) {
1805 // Parse and compress line number table
1806 parse_linenumber_table(code_attribute_length, code_length,
1807 &linenumber_table, CHECK_(nullHandle));
1809 } else if (LoadLocalVariableTables &&
1810 cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_table()) {
1811 // Parse local variable table
1812 if (!lvt_allocated) {
1813 localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
1814 THREAD, u2, INITIAL_MAX_LVT_NUMBER);
1815 localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
1816 THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
1817 localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
1818 THREAD, u2, INITIAL_MAX_LVT_NUMBER);
1819 localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
1820 THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
1821 lvt_allocated = true;
1822 }
1823 if (lvt_cnt == max_lvt_cnt) {
1824 max_lvt_cnt <<= 1;
1825 REALLOC_RESOURCE_ARRAY(u2, localvariable_table_length, lvt_cnt, max_lvt_cnt);
1826 REALLOC_RESOURCE_ARRAY(u2*, localvariable_table_start, lvt_cnt, max_lvt_cnt);
1827 }
1828 localvariable_table_start[lvt_cnt] =
1829 parse_localvariable_table(code_length,
1830 max_locals,
1831 code_attribute_length,
1832 cp,
1833 &localvariable_table_length[lvt_cnt],
1834 false, // is not LVTT
1835 CHECK_(nullHandle));
1836 total_lvt_length += localvariable_table_length[lvt_cnt];
1837 lvt_cnt++;
1838 } else if (LoadLocalVariableTypeTables &&
1839 _major_version >= JAVA_1_5_VERSION &&
1840 cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_type_table()) {
1841 if (!lvt_allocated) {
1842 localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
1843 THREAD, u2, INITIAL_MAX_LVT_NUMBER);
1844 localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
1845 THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
1846 localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
1847 THREAD, u2, INITIAL_MAX_LVT_NUMBER);
1848 localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
1849 THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
1850 lvt_allocated = true;
1851 }
1852 // Parse local variable type table
1853 if (lvtt_cnt == max_lvtt_cnt) {
1854 max_lvtt_cnt <<= 1;
1855 REALLOC_RESOURCE_ARRAY(u2, localvariable_type_table_length, lvtt_cnt, max_lvtt_cnt);
1856 REALLOC_RESOURCE_ARRAY(u2*, localvariable_type_table_start, lvtt_cnt, max_lvtt_cnt);
1857 }
1858 localvariable_type_table_start[lvtt_cnt] =
1859 parse_localvariable_table(code_length,
1860 max_locals,
1861 code_attribute_length,
1862 cp,
1863 &localvariable_type_table_length[lvtt_cnt],
1864 true, // is LVTT
1865 CHECK_(nullHandle));
1866 lvtt_cnt++;
1867 } else if (UseSplitVerifier &&
1868 _major_version >= Verifier::STACKMAP_ATTRIBUTE_MAJOR_VERSION &&
1869 cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_stack_map_table()) {
1870 // Stack map is only needed by the new verifier in JDK1.5.
1871 if (parsed_stackmap_attribute) {
1872 classfile_parse_error("Multiple StackMapTable attributes in class file %s", CHECK_(nullHandle));
1873 }
1874 typeArrayOop sm =
1875 parse_stackmap_table(code_attribute_length, CHECK_(nullHandle));
1876 stackmap_data = typeArrayHandle(THREAD, sm);
1877 parsed_stackmap_attribute = true;
1878 } else {
1879 // Skip unknown attributes
1880 cfs->skip_u1(code_attribute_length, CHECK_(nullHandle));
1881 }
1882 }
1883 // check method attribute length
1884 if (_need_verify) {
1885 guarantee_property(method_attribute_length == calculated_attribute_length,
1886 "Code segment has wrong length in class file %s", CHECK_(nullHandle));
1887 }
1888 } else if (method_attribute_name == vmSymbols::tag_exceptions()) {
1889 // Parse Exceptions attribute
1890 if (parsed_checked_exceptions_attribute) {
1891 classfile_parse_error("Multiple Exceptions attributes in class file %s", CHECK_(nullHandle));
1892 }
1893 parsed_checked_exceptions_attribute = true;
1894 checked_exceptions_start =
1895 parse_checked_exceptions(&checked_exceptions_length,
1896 method_attribute_length,
1897 cp, CHECK_(nullHandle));
1898 } else if (method_attribute_name == vmSymbols::tag_synthetic()) {
1899 if (method_attribute_length != 0) {
1900 classfile_parse_error(
1901 "Invalid Synthetic method attribute length %u in class file %s",
1902 method_attribute_length, CHECK_(nullHandle));
1903 }
1904 // Should we check that there hasn't already been a synthetic attribute?
1905 access_flags.set_is_synthetic();
1906 } else if (method_attribute_name == vmSymbols::tag_deprecated()) { // 4276120
1907 if (method_attribute_length != 0) {
1908 classfile_parse_error(
1909 "Invalid Deprecated method attribute length %u in class file %s",
1910 method_attribute_length, CHECK_(nullHandle));
1911 }
1912 } else if (_major_version >= JAVA_1_5_VERSION) {
1913 if (method_attribute_name == vmSymbols::tag_signature()) {
1914 if (method_attribute_length != 2) {
1915 classfile_parse_error(
1916 "Invalid Signature attribute length %u in class file %s",
1917 method_attribute_length, CHECK_(nullHandle));
1918 }
1919 cfs->guarantee_more(2, CHECK_(nullHandle)); // generic_signature_index
1920 generic_signature_index = cfs->get_u2_fast();
1921 } else if (method_attribute_name == vmSymbols::tag_runtime_visible_annotations()) {
1922 runtime_visible_annotations_length = method_attribute_length;
1923 runtime_visible_annotations = cfs->get_u1_buffer();
1924 assert(runtime_visible_annotations != NULL, "null visible annotations");
1925 cfs->skip_u1(runtime_visible_annotations_length, CHECK_(nullHandle));
1926 } else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {
1927 runtime_invisible_annotations_length = method_attribute_length;
1928 runtime_invisible_annotations = cfs->get_u1_buffer();
1929 assert(runtime_invisible_annotations != NULL, "null invisible annotations");
1930 cfs->skip_u1(runtime_invisible_annotations_length, CHECK_(nullHandle));
1931 } else if (method_attribute_name == vmSymbols::tag_runtime_visible_parameter_annotations()) {
1932 runtime_visible_parameter_annotations_length = method_attribute_length;
1933 runtime_visible_parameter_annotations = cfs->get_u1_buffer();
1934 assert(runtime_visible_parameter_annotations != NULL, "null visible parameter annotations");
1935 cfs->skip_u1(runtime_visible_parameter_annotations_length, CHECK_(nullHandle));
1936 } else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_parameter_annotations()) {
1937 runtime_invisible_parameter_annotations_length = method_attribute_length;
1938 runtime_invisible_parameter_annotations = cfs->get_u1_buffer();
1939 assert(runtime_invisible_parameter_annotations != NULL, "null invisible parameter annotations");
1940 cfs->skip_u1(runtime_invisible_parameter_annotations_length, CHECK_(nullHandle));
1941 } else if (method_attribute_name == vmSymbols::tag_annotation_default()) {
1942 annotation_default_length = method_attribute_length;
1943 annotation_default = cfs->get_u1_buffer();
1944 assert(annotation_default != NULL, "null annotation default");
1945 cfs->skip_u1(annotation_default_length, CHECK_(nullHandle));
1946 } else {
1947 // Skip unknown attributes
1948 cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));
1949 }
1950 } else {
1951 // Skip unknown attributes
1952 cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));
1953 }
1954 }
1956 if (linenumber_table != NULL) {
1957 linenumber_table->write_terminator();
1958 linenumber_table_length = linenumber_table->position();
1959 }
1961 // Make sure there's at least one Code attribute in non-native/non-abstract method
1962 if (_need_verify) {
1963 guarantee_property(access_flags.is_native() || access_flags.is_abstract() || parsed_code_attribute,
1964 "Absent Code attribute in method that is not native or abstract in class file %s", CHECK_(nullHandle));
1965 }
1967 // All sizing information for a methodOop is finally available, now create it
1968 methodOop m_oop = oopFactory::new_method(
1969 code_length, access_flags, linenumber_table_length,
1970 total_lvt_length, checked_exceptions_length,
1971 methodOopDesc::IsSafeConc, CHECK_(nullHandle));
1972 methodHandle m (THREAD, m_oop);
1974 ClassLoadingService::add_class_method_size(m_oop->size()*HeapWordSize);
1976 // Fill in information from fixed part (access_flags already set)
1977 m->set_constants(cp());
1978 m->set_name_index(name_index);
1979 m->set_signature_index(signature_index);
1980 m->set_generic_signature_index(generic_signature_index);
1981 #ifdef CC_INTERP
1982 // hmm is there a gc issue here??
1983 ResultTypeFinder rtf(cp->symbol_at(signature_index));
1984 m->set_result_index(rtf.type());
1985 #endif
1987 if (args_size >= 0) {
1988 m->set_size_of_parameters(args_size);
1989 } else {
1990 m->compute_size_of_parameters(THREAD);
1991 }
1992 #ifdef ASSERT
1993 if (args_size >= 0) {
1994 m->compute_size_of_parameters(THREAD);
1995 assert(args_size == m->size_of_parameters(), "");
1996 }
1997 #endif
1999 // Fill in code attribute information
2000 m->set_max_stack(max_stack);
2001 m->set_max_locals(max_locals);
2002 m->constMethod()->set_stackmap_data(stackmap_data());
2004 /**
2005 * The exception_table field is the flag used to indicate
2006 * that the methodOop and it's associated constMethodOop are partially
2007 * initialized and thus are exempt from pre/post GC verification. Once
2008 * the field is set, the oops are considered fully initialized so make
2009 * sure that the oops can pass verification when this field is set.
2010 */
2011 m->set_exception_table(exception_handlers());
2013 // Copy byte codes
2014 m->set_code(code_start);
2016 // Copy line number table
2017 if (linenumber_table != NULL) {
2018 memcpy(m->compressed_linenumber_table(),
2019 linenumber_table->buffer(), linenumber_table_length);
2020 }
2022 // Copy checked exceptions
2023 if (checked_exceptions_length > 0) {
2024 int size = checked_exceptions_length * sizeof(CheckedExceptionElement) / sizeof(u2);
2025 copy_u2_with_conversion((u2*) m->checked_exceptions_start(), checked_exceptions_start, size);
2026 }
2028 /* Copy class file LVT's/LVTT's into the HotSpot internal LVT.
2029 *
2030 * Rules for LVT's and LVTT's are:
2031 * - There can be any number of LVT's and LVTT's.
2032 * - If there are n LVT's, it is the same as if there was just
2033 * one LVT containing all the entries from the n LVT's.
2034 * - There may be no more than one LVT entry per local variable.
2035 * Two LVT entries are 'equal' if these fields are the same:
2036 * start_pc, length, name, slot
2037 * - There may be no more than one LVTT entry per each LVT entry.
2038 * Each LVTT entry has to match some LVT entry.
2039 * - HotSpot internal LVT keeps natural ordering of class file LVT entries.
2040 */
2041 if (total_lvt_length > 0) {
2042 int tbl_no, idx;
2044 promoted_flags->set_has_localvariable_table();
2046 LVT_Hash** lvt_Hash = NEW_RESOURCE_ARRAY(LVT_Hash*, HASH_ROW_SIZE);
2047 initialize_hashtable(lvt_Hash);
2049 // To fill LocalVariableTable in
2050 Classfile_LVT_Element* cf_lvt;
2051 LocalVariableTableElement* lvt = m->localvariable_table_start();
2053 for (tbl_no = 0; tbl_no < lvt_cnt; tbl_no++) {
2054 cf_lvt = (Classfile_LVT_Element *) localvariable_table_start[tbl_no];
2055 for (idx = 0; idx < localvariable_table_length[tbl_no]; idx++, lvt++) {
2056 copy_lvt_element(&cf_lvt[idx], lvt);
2057 // If no duplicates, add LVT elem in hashtable lvt_Hash.
2058 if (LVT_put_after_lookup(lvt, lvt_Hash) == false
2059 && _need_verify
2060 && _major_version >= JAVA_1_5_VERSION ) {
2061 clear_hashtable(lvt_Hash);
2062 classfile_parse_error("Duplicated LocalVariableTable attribute "
2063 "entry for '%s' in class file %s",
2064 cp->symbol_at(lvt->name_cp_index)->as_utf8(),
2065 CHECK_(nullHandle));
2066 }
2067 }
2068 }
2070 // To merge LocalVariableTable and LocalVariableTypeTable
2071 Classfile_LVT_Element* cf_lvtt;
2072 LocalVariableTableElement lvtt_elem;
2074 for (tbl_no = 0; tbl_no < lvtt_cnt; tbl_no++) {
2075 cf_lvtt = (Classfile_LVT_Element *) localvariable_type_table_start[tbl_no];
2076 for (idx = 0; idx < localvariable_type_table_length[tbl_no]; idx++) {
2077 copy_lvt_element(&cf_lvtt[idx], &lvtt_elem);
2078 int index = hash(&lvtt_elem);
2079 LVT_Hash* entry = LVT_lookup(&lvtt_elem, index, lvt_Hash);
2080 if (entry == NULL) {
2081 if (_need_verify) {
2082 clear_hashtable(lvt_Hash);
2083 classfile_parse_error("LVTT entry for '%s' in class file %s "
2084 "does not match any LVT entry",
2085 cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
2086 CHECK_(nullHandle));
2087 }
2088 } else if (entry->_elem->signature_cp_index != 0 && _need_verify) {
2089 clear_hashtable(lvt_Hash);
2090 classfile_parse_error("Duplicated LocalVariableTypeTable attribute "
2091 "entry for '%s' in class file %s",
2092 cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
2093 CHECK_(nullHandle));
2094 } else {
2095 // to add generic signatures into LocalVariableTable
2096 entry->_elem->signature_cp_index = lvtt_elem.descriptor_cp_index;
2097 }
2098 }
2099 }
2100 clear_hashtable(lvt_Hash);
2101 }
2103 *method_annotations = assemble_annotations(runtime_visible_annotations,
2104 runtime_visible_annotations_length,
2105 runtime_invisible_annotations,
2106 runtime_invisible_annotations_length,
2107 CHECK_(nullHandle));
2108 *method_parameter_annotations = assemble_annotations(runtime_visible_parameter_annotations,
2109 runtime_visible_parameter_annotations_length,
2110 runtime_invisible_parameter_annotations,
2111 runtime_invisible_parameter_annotations_length,
2112 CHECK_(nullHandle));
2113 *method_default_annotations = assemble_annotations(annotation_default,
2114 annotation_default_length,
2115 NULL,
2116 0,
2117 CHECK_(nullHandle));
2119 if (name() == vmSymbols::finalize_method_name() &&
2120 signature() == vmSymbols::void_method_signature()) {
2121 if (m->is_empty_method()) {
2122 _has_empty_finalizer = true;
2123 } else {
2124 _has_finalizer = true;
2125 }
2126 }
2127 if (name() == vmSymbols::object_initializer_name() &&
2128 signature() == vmSymbols::void_method_signature() &&
2129 m->is_vanilla_constructor()) {
2130 _has_vanilla_constructor = true;
2131 }
2133 if (EnableMethodHandles && (m->is_method_handle_invoke() ||
2134 m->is_method_handle_adapter())) {
2135 THROW_MSG_(vmSymbols::java_lang_VirtualMachineError(),
2136 "Method handle invokers must be defined internally to the VM", nullHandle);
2137 }
2139 return m;
2140 }
2143 // The promoted_flags parameter is used to pass relevant access_flags
2144 // from the methods back up to the containing klass. These flag values
2145 // are added to klass's access_flags.
2147 objArrayHandle ClassFileParser::parse_methods(constantPoolHandle cp, bool is_interface,
2148 AccessFlags* promoted_flags,
2149 bool* has_final_method,
2150 objArrayOop* methods_annotations_oop,
2151 objArrayOop* methods_parameter_annotations_oop,
2152 objArrayOop* methods_default_annotations_oop,
2153 TRAPS) {
2154 ClassFileStream* cfs = stream();
2155 objArrayHandle nullHandle;
2156 typeArrayHandle method_annotations;
2157 typeArrayHandle method_parameter_annotations;
2158 typeArrayHandle method_default_annotations;
2159 cfs->guarantee_more(2, CHECK_(nullHandle)); // length
2160 u2 length = cfs->get_u2_fast();
2161 if (length == 0) {
2162 return objArrayHandle(THREAD, Universe::the_empty_system_obj_array());
2163 } else {
2164 objArrayOop m = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
2165 objArrayHandle methods(THREAD, m);
2166 HandleMark hm(THREAD);
2167 objArrayHandle methods_annotations;
2168 objArrayHandle methods_parameter_annotations;
2169 objArrayHandle methods_default_annotations;
2170 for (int index = 0; index < length; index++) {
2171 methodHandle method = parse_method(cp, is_interface,
2172 promoted_flags,
2173 &method_annotations,
2174 &method_parameter_annotations,
2175 &method_default_annotations,
2176 CHECK_(nullHandle));
2177 if (method->is_final()) {
2178 *has_final_method = true;
2179 }
2180 methods->obj_at_put(index, method());
2181 if (method_annotations.not_null()) {
2182 if (methods_annotations.is_null()) {
2183 objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
2184 methods_annotations = objArrayHandle(THREAD, md);
2185 }
2186 methods_annotations->obj_at_put(index, method_annotations());
2187 }
2188 if (method_parameter_annotations.not_null()) {
2189 if (methods_parameter_annotations.is_null()) {
2190 objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
2191 methods_parameter_annotations = objArrayHandle(THREAD, md);
2192 }
2193 methods_parameter_annotations->obj_at_put(index, method_parameter_annotations());
2194 }
2195 if (method_default_annotations.not_null()) {
2196 if (methods_default_annotations.is_null()) {
2197 objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
2198 methods_default_annotations = objArrayHandle(THREAD, md);
2199 }
2200 methods_default_annotations->obj_at_put(index, method_default_annotations());
2201 }
2202 }
2203 if (_need_verify && length > 1) {
2204 // Check duplicated methods
2205 ResourceMark rm(THREAD);
2206 NameSigHash** names_and_sigs = NEW_RESOURCE_ARRAY_IN_THREAD(
2207 THREAD, NameSigHash*, HASH_ROW_SIZE);
2208 initialize_hashtable(names_and_sigs);
2209 bool dup = false;
2210 {
2211 debug_only(No_Safepoint_Verifier nsv;)
2212 for (int i = 0; i < length; i++) {
2213 methodOop m = (methodOop)methods->obj_at(i);
2214 // If no duplicates, add name/signature in hashtable names_and_sigs.
2215 if (!put_after_lookup(m->name(), m->signature(), names_and_sigs)) {
2216 dup = true;
2217 break;
2218 }
2219 }
2220 }
2221 if (dup) {
2222 classfile_parse_error("Duplicate method name&signature in class file %s",
2223 CHECK_(nullHandle));
2224 }
2225 }
2227 *methods_annotations_oop = methods_annotations();
2228 *methods_parameter_annotations_oop = methods_parameter_annotations();
2229 *methods_default_annotations_oop = methods_default_annotations();
2231 return methods;
2232 }
2233 }
2236 typeArrayHandle ClassFileParser::sort_methods(objArrayHandle methods,
2237 objArrayHandle methods_annotations,
2238 objArrayHandle methods_parameter_annotations,
2239 objArrayHandle methods_default_annotations,
2240 TRAPS) {
2241 typeArrayHandle nullHandle;
2242 int length = methods()->length();
2243 // If JVMTI original method ordering is enabled we have to
2244 // remember the original class file ordering.
2245 // We temporarily use the vtable_index field in the methodOop to store the
2246 // class file index, so we can read in after calling qsort.
2247 if (JvmtiExport::can_maintain_original_method_order()) {
2248 for (int index = 0; index < length; index++) {
2249 methodOop m = methodOop(methods->obj_at(index));
2250 assert(!m->valid_vtable_index(), "vtable index should not be set");
2251 m->set_vtable_index(index);
2252 }
2253 }
2254 // Sort method array by ascending method name (for faster lookups & vtable construction)
2255 // Note that the ordering is not alphabetical, see symbolOopDesc::fast_compare
2256 methodOopDesc::sort_methods(methods(),
2257 methods_annotations(),
2258 methods_parameter_annotations(),
2259 methods_default_annotations());
2261 // If JVMTI original method ordering is enabled construct int array remembering the original ordering
2262 if (JvmtiExport::can_maintain_original_method_order()) {
2263 typeArrayOop new_ordering = oopFactory::new_permanent_intArray(length, CHECK_(nullHandle));
2264 typeArrayHandle method_ordering(THREAD, new_ordering);
2265 for (int index = 0; index < length; index++) {
2266 methodOop m = methodOop(methods->obj_at(index));
2267 int old_index = m->vtable_index();
2268 assert(old_index >= 0 && old_index < length, "invalid method index");
2269 method_ordering->int_at_put(index, old_index);
2270 m->set_vtable_index(methodOopDesc::invalid_vtable_index);
2271 }
2272 return method_ordering;
2273 } else {
2274 return typeArrayHandle(THREAD, Universe::the_empty_int_array());
2275 }
2276 }
2279 void ClassFileParser::parse_classfile_sourcefile_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
2280 ClassFileStream* cfs = stream();
2281 cfs->guarantee_more(2, CHECK); // sourcefile_index
2282 u2 sourcefile_index = cfs->get_u2_fast();
2283 check_property(
2284 valid_cp_range(sourcefile_index, cp->length()) &&
2285 cp->tag_at(sourcefile_index).is_utf8(),
2286 "Invalid SourceFile attribute at constant pool index %u in class file %s",
2287 sourcefile_index, CHECK);
2288 k->set_source_file_name(cp->symbol_at(sourcefile_index));
2289 }
2293 void ClassFileParser::parse_classfile_source_debug_extension_attribute(constantPoolHandle cp,
2294 instanceKlassHandle k,
2295 int length, TRAPS) {
2296 ClassFileStream* cfs = stream();
2297 u1* sde_buffer = cfs->get_u1_buffer();
2298 assert(sde_buffer != NULL, "null sde buffer");
2300 // Don't bother storing it if there is no way to retrieve it
2301 if (JvmtiExport::can_get_source_debug_extension()) {
2302 // Optimistically assume that only 1 byte UTF format is used
2303 // (common case)
2304 symbolOop sde_symbol = oopFactory::new_symbol((char*)sde_buffer,
2305 length, CHECK);
2306 k->set_source_debug_extension(sde_symbol);
2307 }
2308 // Got utf8 string, set stream position forward
2309 cfs->skip_u1(length, CHECK);
2310 }
2313 // Inner classes can be static, private or protected (classic VM does this)
2314 #define RECOGNIZED_INNER_CLASS_MODIFIERS (JVM_RECOGNIZED_CLASS_MODIFIERS | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED | JVM_ACC_STATIC)
2316 // Return number of classes in the inner classes attribute table
2317 u2 ClassFileParser::parse_classfile_inner_classes_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
2318 ClassFileStream* cfs = stream();
2319 cfs->guarantee_more(2, CHECK_0); // length
2320 u2 length = cfs->get_u2_fast();
2322 // 4-tuples of shorts [inner_class_info_index, outer_class_info_index, inner_name_index, inner_class_access_flags]
2323 typeArrayOop ic = oopFactory::new_permanent_shortArray(length*4, CHECK_0);
2324 typeArrayHandle inner_classes(THREAD, ic);
2325 int index = 0;
2326 int cp_size = cp->length();
2327 cfs->guarantee_more(8 * length, CHECK_0); // 4-tuples of u2
2328 for (int n = 0; n < length; n++) {
2329 // Inner class index
2330 u2 inner_class_info_index = cfs->get_u2_fast();
2331 check_property(
2332 inner_class_info_index == 0 ||
2333 (valid_cp_range(inner_class_info_index, cp_size) &&
2334 is_klass_reference(cp, inner_class_info_index)),
2335 "inner_class_info_index %u has bad constant type in class file %s",
2336 inner_class_info_index, CHECK_0);
2337 // Outer class index
2338 u2 outer_class_info_index = cfs->get_u2_fast();
2339 check_property(
2340 outer_class_info_index == 0 ||
2341 (valid_cp_range(outer_class_info_index, cp_size) &&
2342 is_klass_reference(cp, outer_class_info_index)),
2343 "outer_class_info_index %u has bad constant type in class file %s",
2344 outer_class_info_index, CHECK_0);
2345 // Inner class name
2346 u2 inner_name_index = cfs->get_u2_fast();
2347 check_property(
2348 inner_name_index == 0 || (valid_cp_range(inner_name_index, cp_size) &&
2349 cp->tag_at(inner_name_index).is_utf8()),
2350 "inner_name_index %u has bad constant type in class file %s",
2351 inner_name_index, CHECK_0);
2352 if (_need_verify) {
2353 guarantee_property(inner_class_info_index != outer_class_info_index,
2354 "Class is both outer and inner class in class file %s", CHECK_0);
2355 }
2356 // Access flags
2357 AccessFlags inner_access_flags;
2358 jint flags = cfs->get_u2_fast() & RECOGNIZED_INNER_CLASS_MODIFIERS;
2359 if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
2360 // Set abstract bit for old class files for backward compatibility
2361 flags |= JVM_ACC_ABSTRACT;
2362 }
2363 verify_legal_class_modifiers(flags, CHECK_0);
2364 inner_access_flags.set_flags(flags);
2366 inner_classes->short_at_put(index++, inner_class_info_index);
2367 inner_classes->short_at_put(index++, outer_class_info_index);
2368 inner_classes->short_at_put(index++, inner_name_index);
2369 inner_classes->short_at_put(index++, inner_access_flags.as_short());
2370 }
2372 // 4347400: make sure there's no duplicate entry in the classes array
2373 if (_need_verify && _major_version >= JAVA_1_5_VERSION) {
2374 for(int i = 0; i < inner_classes->length(); i += 4) {
2375 for(int j = i + 4; j < inner_classes->length(); j += 4) {
2376 guarantee_property((inner_classes->ushort_at(i) != inner_classes->ushort_at(j) ||
2377 inner_classes->ushort_at(i+1) != inner_classes->ushort_at(j+1) ||
2378 inner_classes->ushort_at(i+2) != inner_classes->ushort_at(j+2) ||
2379 inner_classes->ushort_at(i+3) != inner_classes->ushort_at(j+3)),
2380 "Duplicate entry in InnerClasses in class file %s",
2381 CHECK_0);
2382 }
2383 }
2384 }
2386 // Update instanceKlass with inner class info.
2387 k->set_inner_classes(inner_classes());
2388 return length;
2389 }
2391 void ClassFileParser::parse_classfile_synthetic_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
2392 k->set_is_synthetic();
2393 }
2395 void ClassFileParser::parse_classfile_signature_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
2396 ClassFileStream* cfs = stream();
2397 u2 signature_index = cfs->get_u2(CHECK);
2398 check_property(
2399 valid_cp_range(signature_index, cp->length()) &&
2400 cp->tag_at(signature_index).is_utf8(),
2401 "Invalid constant pool index %u in Signature attribute in class file %s",
2402 signature_index, CHECK);
2403 k->set_generic_signature(cp->symbol_at(signature_index));
2404 }
2406 void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
2407 ClassFileStream* cfs = stream();
2408 // Set inner classes attribute to default sentinel
2409 k->set_inner_classes(Universe::the_empty_short_array());
2410 cfs->guarantee_more(2, CHECK); // attributes_count
2411 u2 attributes_count = cfs->get_u2_fast();
2412 bool parsed_sourcefile_attribute = false;
2413 bool parsed_innerclasses_attribute = false;
2414 bool parsed_enclosingmethod_attribute = false;
2415 u1* runtime_visible_annotations = NULL;
2416 int runtime_visible_annotations_length = 0;
2417 u1* runtime_invisible_annotations = NULL;
2418 int runtime_invisible_annotations_length = 0;
2419 // Iterate over attributes
2420 while (attributes_count--) {
2421 cfs->guarantee_more(6, CHECK); // attribute_name_index, attribute_length
2422 u2 attribute_name_index = cfs->get_u2_fast();
2423 u4 attribute_length = cfs->get_u4_fast();
2424 check_property(
2425 valid_cp_range(attribute_name_index, cp->length()) &&
2426 cp->tag_at(attribute_name_index).is_utf8(),
2427 "Attribute name has bad constant pool index %u in class file %s",
2428 attribute_name_index, CHECK);
2429 symbolOop tag = cp->symbol_at(attribute_name_index);
2430 if (tag == vmSymbols::tag_source_file()) {
2431 // Check for SourceFile tag
2432 if (_need_verify) {
2433 guarantee_property(attribute_length == 2, "Wrong SourceFile attribute length in class file %s", CHECK);
2434 }
2435 if (parsed_sourcefile_attribute) {
2436 classfile_parse_error("Multiple SourceFile attributes in class file %s", CHECK);
2437 } else {
2438 parsed_sourcefile_attribute = true;
2439 }
2440 parse_classfile_sourcefile_attribute(cp, k, CHECK);
2441 } else if (tag == vmSymbols::tag_source_debug_extension()) {
2442 // Check for SourceDebugExtension tag
2443 parse_classfile_source_debug_extension_attribute(cp, k, (int)attribute_length, CHECK);
2444 } else if (tag == vmSymbols::tag_inner_classes()) {
2445 // Check for InnerClasses tag
2446 if (parsed_innerclasses_attribute) {
2447 classfile_parse_error("Multiple InnerClasses attributes in class file %s", CHECK);
2448 } else {
2449 parsed_innerclasses_attribute = true;
2450 }
2451 u2 num_of_classes = parse_classfile_inner_classes_attribute(cp, k, CHECK);
2452 if (_need_verify && _major_version >= JAVA_1_5_VERSION) {
2453 guarantee_property(attribute_length == sizeof(num_of_classes) + 4 * sizeof(u2) * num_of_classes,
2454 "Wrong InnerClasses attribute length in class file %s", CHECK);
2455 }
2456 } else if (tag == vmSymbols::tag_synthetic()) {
2457 // Check for Synthetic tag
2458 // Shouldn't we check that the synthetic flags wasn't already set? - not required in spec
2459 if (attribute_length != 0) {
2460 classfile_parse_error(
2461 "Invalid Synthetic classfile attribute length %u in class file %s",
2462 attribute_length, CHECK);
2463 }
2464 parse_classfile_synthetic_attribute(cp, k, CHECK);
2465 } else if (tag == vmSymbols::tag_deprecated()) {
2466 // Check for Deprecatd tag - 4276120
2467 if (attribute_length != 0) {
2468 classfile_parse_error(
2469 "Invalid Deprecated classfile attribute length %u in class file %s",
2470 attribute_length, CHECK);
2471 }
2472 } else if (_major_version >= JAVA_1_5_VERSION) {
2473 if (tag == vmSymbols::tag_signature()) {
2474 if (attribute_length != 2) {
2475 classfile_parse_error(
2476 "Wrong Signature attribute length %u in class file %s",
2477 attribute_length, CHECK);
2478 }
2479 parse_classfile_signature_attribute(cp, k, CHECK);
2480 } else if (tag == vmSymbols::tag_runtime_visible_annotations()) {
2481 runtime_visible_annotations_length = attribute_length;
2482 runtime_visible_annotations = cfs->get_u1_buffer();
2483 assert(runtime_visible_annotations != NULL, "null visible annotations");
2484 cfs->skip_u1(runtime_visible_annotations_length, CHECK);
2485 } else if (PreserveAllAnnotations && tag == vmSymbols::tag_runtime_invisible_annotations()) {
2486 runtime_invisible_annotations_length = attribute_length;
2487 runtime_invisible_annotations = cfs->get_u1_buffer();
2488 assert(runtime_invisible_annotations != NULL, "null invisible annotations");
2489 cfs->skip_u1(runtime_invisible_annotations_length, CHECK);
2490 } else if (tag == vmSymbols::tag_enclosing_method()) {
2491 if (parsed_enclosingmethod_attribute) {
2492 classfile_parse_error("Multiple EnclosingMethod attributes in class file %s", CHECK);
2493 } else {
2494 parsed_enclosingmethod_attribute = true;
2495 }
2496 cfs->guarantee_more(4, CHECK); // class_index, method_index
2497 u2 class_index = cfs->get_u2_fast();
2498 u2 method_index = cfs->get_u2_fast();
2499 if (class_index == 0) {
2500 classfile_parse_error("Invalid class index in EnclosingMethod attribute in class file %s", CHECK);
2501 }
2502 // Validate the constant pool indices and types
2503 if (!cp->is_within_bounds(class_index) ||
2504 !is_klass_reference(cp, class_index)) {
2505 classfile_parse_error("Invalid or out-of-bounds class index in EnclosingMethod attribute in class file %s", CHECK);
2506 }
2507 if (method_index != 0 &&
2508 (!cp->is_within_bounds(method_index) ||
2509 !cp->tag_at(method_index).is_name_and_type())) {
2510 classfile_parse_error("Invalid or out-of-bounds method index in EnclosingMethod attribute in class file %s", CHECK);
2511 }
2512 k->set_enclosing_method_indices(class_index, method_index);
2513 } else {
2514 // Unknown attribute
2515 cfs->skip_u1(attribute_length, CHECK);
2516 }
2517 } else {
2518 // Unknown attribute
2519 cfs->skip_u1(attribute_length, CHECK);
2520 }
2521 }
2522 typeArrayHandle annotations = assemble_annotations(runtime_visible_annotations,
2523 runtime_visible_annotations_length,
2524 runtime_invisible_annotations,
2525 runtime_invisible_annotations_length,
2526 CHECK);
2527 k->set_class_annotations(annotations());
2528 }
2531 typeArrayHandle ClassFileParser::assemble_annotations(u1* runtime_visible_annotations,
2532 int runtime_visible_annotations_length,
2533 u1* runtime_invisible_annotations,
2534 int runtime_invisible_annotations_length, TRAPS) {
2535 typeArrayHandle annotations;
2536 if (runtime_visible_annotations != NULL ||
2537 runtime_invisible_annotations != NULL) {
2538 typeArrayOop anno = oopFactory::new_permanent_byteArray(runtime_visible_annotations_length +
2539 runtime_invisible_annotations_length, CHECK_(annotations));
2540 annotations = typeArrayHandle(THREAD, anno);
2541 if (runtime_visible_annotations != NULL) {
2542 memcpy(annotations->byte_at_addr(0), runtime_visible_annotations, runtime_visible_annotations_length);
2543 }
2544 if (runtime_invisible_annotations != NULL) {
2545 memcpy(annotations->byte_at_addr(runtime_visible_annotations_length), runtime_invisible_annotations, runtime_invisible_annotations_length);
2546 }
2547 }
2548 return annotations;
2549 }
2552 static void initialize_static_field(fieldDescriptor* fd, TRAPS) {
2553 KlassHandle h_k (THREAD, fd->field_holder());
2554 assert(h_k.not_null() && fd->is_static(), "just checking");
2555 if (fd->has_initial_value()) {
2556 BasicType t = fd->field_type();
2557 switch (t) {
2558 case T_BYTE:
2559 h_k()->byte_field_put(fd->offset(), fd->int_initial_value());
2560 break;
2561 case T_BOOLEAN:
2562 h_k()->bool_field_put(fd->offset(), fd->int_initial_value());
2563 break;
2564 case T_CHAR:
2565 h_k()->char_field_put(fd->offset(), fd->int_initial_value());
2566 break;
2567 case T_SHORT:
2568 h_k()->short_field_put(fd->offset(), fd->int_initial_value());
2569 break;
2570 case T_INT:
2571 h_k()->int_field_put(fd->offset(), fd->int_initial_value());
2572 break;
2573 case T_FLOAT:
2574 h_k()->float_field_put(fd->offset(), fd->float_initial_value());
2575 break;
2576 case T_DOUBLE:
2577 h_k()->double_field_put(fd->offset(), fd->double_initial_value());
2578 break;
2579 case T_LONG:
2580 h_k()->long_field_put(fd->offset(), fd->long_initial_value());
2581 break;
2582 case T_OBJECT:
2583 {
2584 #ifdef ASSERT
2585 symbolOop sym = oopFactory::new_symbol("Ljava/lang/String;", CHECK);
2586 assert(fd->signature() == sym, "just checking");
2587 #endif
2588 oop string = fd->string_initial_value(CHECK);
2589 h_k()->obj_field_put(fd->offset(), string);
2590 }
2591 break;
2592 default:
2593 THROW_MSG(vmSymbols::java_lang_ClassFormatError(),
2594 "Illegal ConstantValue attribute in class file");
2595 }
2596 }
2597 }
2600 void ClassFileParser::java_lang_ref_Reference_fix_pre(typeArrayHandle* fields_ptr,
2601 constantPoolHandle cp, FieldAllocationCount *fac_ptr, TRAPS) {
2602 // This code is for compatibility with earlier jdk's that do not
2603 // have the "discovered" field in java.lang.ref.Reference. For 1.5
2604 // the check for the "discovered" field should issue a warning if
2605 // the field is not found. For 1.6 this code should be issue a
2606 // fatal error if the "discovered" field is not found.
2607 //
2608 // Increment fac.nonstatic_oop_count so that the start of the
2609 // next type of non-static oops leaves room for the fake oop.
2610 // Do not increment next_nonstatic_oop_offset so that the
2611 // fake oop is place after the java.lang.ref.Reference oop
2612 // fields.
2613 //
2614 // Check the fields in java.lang.ref.Reference for the "discovered"
2615 // field. If it is not present, artifically create a field for it.
2616 // This allows this VM to run on early JDK where the field is not
2617 // present.
2618 int reference_sig_index = 0;
2619 int reference_name_index = 0;
2620 int reference_index = 0;
2621 int extra = java_lang_ref_Reference::number_of_fake_oop_fields;
2622 const int n = (*fields_ptr)()->length();
2623 for (int i = 0; i < n; i += instanceKlass::next_offset ) {
2624 int name_index =
2625 (*fields_ptr)()->ushort_at(i + instanceKlass::name_index_offset);
2626 int sig_index =
2627 (*fields_ptr)()->ushort_at(i + instanceKlass::signature_index_offset);
2628 symbolOop f_name = cp->symbol_at(name_index);
2629 symbolOop f_sig = cp->symbol_at(sig_index);
2630 if (f_sig == vmSymbols::reference_signature() && reference_index == 0) {
2631 // Save the index for reference signature for later use.
2632 // The fake discovered field does not entries in the
2633 // constant pool so the index for its signature cannot
2634 // be extracted from the constant pool. It will need
2635 // later, however. It's signature is vmSymbols::reference_signature()
2636 // so same an index for that signature.
2637 reference_sig_index = sig_index;
2638 reference_name_index = name_index;
2639 reference_index = i;
2640 }
2641 if (f_name == vmSymbols::reference_discovered_name() &&
2642 f_sig == vmSymbols::reference_signature()) {
2643 // The values below are fake but will force extra
2644 // non-static oop fields and a corresponding non-static
2645 // oop map block to be allocated.
2646 extra = 0;
2647 break;
2648 }
2649 }
2650 if (extra != 0) {
2651 fac_ptr->nonstatic_oop_count += extra;
2652 // Add the additional entry to "fields" so that the klass
2653 // contains the "discoverd" field and the field will be initialized
2654 // in instances of the object.
2655 int fields_with_fix_length = (*fields_ptr)()->length() +
2656 instanceKlass::next_offset;
2657 typeArrayOop ff = oopFactory::new_permanent_shortArray(
2658 fields_with_fix_length, CHECK);
2659 typeArrayHandle fields_with_fix(THREAD, ff);
2661 // Take everything from the original but the length.
2662 for (int idx = 0; idx < (*fields_ptr)->length(); idx++) {
2663 fields_with_fix->ushort_at_put(idx, (*fields_ptr)->ushort_at(idx));
2664 }
2666 // Add the fake field at the end.
2667 int i = (*fields_ptr)->length();
2668 // There is no name index for the fake "discovered" field nor
2669 // signature but a signature is needed so that the field will
2670 // be properly initialized. Use one found for
2671 // one of the other reference fields. Be sure the index for the
2672 // name is 0. In fieldDescriptor::initialize() the index of the
2673 // name is checked. That check is by passed for the last nonstatic
2674 // oop field in a java.lang.ref.Reference which is assumed to be
2675 // this artificial "discovered" field. An assertion checks that
2676 // the name index is 0.
2677 assert(reference_index != 0, "Missing signature for reference");
2679 int j;
2680 for (j = 0; j < instanceKlass::next_offset; j++) {
2681 fields_with_fix->ushort_at_put(i + j,
2682 (*fields_ptr)->ushort_at(reference_index +j));
2683 }
2684 // Clear the public access flag and set the private access flag.
2685 short flags;
2686 flags =
2687 fields_with_fix->ushort_at(i + instanceKlass::access_flags_offset);
2688 assert(!(flags & JVM_RECOGNIZED_FIELD_MODIFIERS), "Unexpected access flags set");
2689 flags = flags & (~JVM_ACC_PUBLIC);
2690 flags = flags | JVM_ACC_PRIVATE;
2691 AccessFlags access_flags;
2692 access_flags.set_flags(flags);
2693 assert(!access_flags.is_public(), "Failed to clear public flag");
2694 assert(access_flags.is_private(), "Failed to set private flag");
2695 fields_with_fix->ushort_at_put(i + instanceKlass::access_flags_offset,
2696 flags);
2698 assert(fields_with_fix->ushort_at(i + instanceKlass::name_index_offset)
2699 == reference_name_index, "The fake reference name is incorrect");
2700 assert(fields_with_fix->ushort_at(i + instanceKlass::signature_index_offset)
2701 == reference_sig_index, "The fake reference signature is incorrect");
2702 // The type of the field is stored in the low_offset entry during
2703 // parsing.
2704 assert(fields_with_fix->ushort_at(i + instanceKlass::low_offset) ==
2705 NONSTATIC_OOP, "The fake reference type is incorrect");
2707 // "fields" is allocated in the permanent generation. Disgard
2708 // it and let it be collected.
2709 (*fields_ptr) = fields_with_fix;
2710 }
2711 return;
2712 }
2715 void ClassFileParser::java_lang_Class_fix_pre(objArrayHandle* methods_ptr,
2716 FieldAllocationCount *fac_ptr, TRAPS) {
2717 // Add fake fields for java.lang.Class instances
2718 //
2719 // This is not particularly nice. We should consider adding a
2720 // private transient object field at the Java level to
2721 // java.lang.Class. Alternatively we could add a subclass of
2722 // instanceKlass which provides an accessor and size computer for
2723 // this field, but that appears to be more code than this hack.
2724 //
2725 // NOTE that we wedge these in at the beginning rather than the
2726 // end of the object because the Class layout changed between JDK
2727 // 1.3 and JDK 1.4 with the new reflection implementation; some
2728 // nonstatic oop fields were added at the Java level. The offsets
2729 // of these fake fields can't change between these two JDK
2730 // versions because when the offsets are computed at bootstrap
2731 // time we don't know yet which version of the JDK we're running in.
2733 // The values below are fake but will force two non-static oop fields and
2734 // a corresponding non-static oop map block to be allocated.
2735 const int extra = java_lang_Class::number_of_fake_oop_fields;
2736 fac_ptr->nonstatic_oop_count += extra;
2737 }
2740 void ClassFileParser::java_lang_Class_fix_post(int* next_nonstatic_oop_offset_ptr) {
2741 // Cause the extra fake fields in java.lang.Class to show up before
2742 // the Java fields for layout compatibility between 1.3 and 1.4
2743 // Incrementing next_nonstatic_oop_offset here advances the
2744 // location where the real java fields are placed.
2745 const int extra = java_lang_Class::number_of_fake_oop_fields;
2746 (*next_nonstatic_oop_offset_ptr) += (extra * heapOopSize);
2747 }
2750 // Force MethodHandle.vmentry to be an unmanaged pointer.
2751 // There is no way for a classfile to express this, so we must help it.
2752 void ClassFileParser::java_dyn_MethodHandle_fix_pre(constantPoolHandle cp,
2753 typeArrayHandle fields,
2754 FieldAllocationCount *fac_ptr,
2755 TRAPS) {
2756 // Add fake fields for java.dyn.MethodHandle instances
2757 //
2758 // This is not particularly nice, but since there is no way to express
2759 // a native wordSize field in Java, we must do it at this level.
2761 if (!EnableMethodHandles) return;
2763 int word_sig_index = 0;
2764 const int cp_size = cp->length();
2765 for (int index = 1; index < cp_size; index++) {
2766 if (cp->tag_at(index).is_utf8() &&
2767 cp->symbol_at(index) == vmSymbols::machine_word_signature()) {
2768 word_sig_index = index;
2769 break;
2770 }
2771 }
2773 if (word_sig_index == 0)
2774 THROW_MSG(vmSymbols::java_lang_VirtualMachineError(),
2775 "missing I or J signature (for vmentry) in java.dyn.MethodHandle");
2777 // Find vmentry field and change the signature.
2778 bool found_vmentry = false;
2779 for (int i = 0; i < fields->length(); i += instanceKlass::next_offset) {
2780 int name_index = fields->ushort_at(i + instanceKlass::name_index_offset);
2781 int sig_index = fields->ushort_at(i + instanceKlass::signature_index_offset);
2782 int acc_flags = fields->ushort_at(i + instanceKlass::access_flags_offset);
2783 symbolOop f_name = cp->symbol_at(name_index);
2784 symbolOop f_sig = cp->symbol_at(sig_index);
2786 if (f_name == vmSymbols::vmentry_name() && (acc_flags & JVM_ACC_STATIC) == 0) {
2787 if (f_sig == vmSymbols::machine_word_signature()) {
2788 // If the signature of vmentry is already changed, we're done.
2789 found_vmentry = true;
2790 break;
2791 }
2792 else if (f_sig == vmSymbols::byte_signature()) {
2793 // Adjust the field type from byte to an unmanaged pointer.
2794 assert(fac_ptr->nonstatic_byte_count > 0, "");
2795 fac_ptr->nonstatic_byte_count -= 1;
2797 fields->ushort_at_put(i + instanceKlass::signature_index_offset, word_sig_index);
2798 assert(wordSize == longSize || wordSize == jintSize, "ILP32 or LP64");
2799 if (wordSize == longSize) fac_ptr->nonstatic_double_count += 1;
2800 else fac_ptr->nonstatic_word_count += 1;
2802 FieldAllocationType atype = (FieldAllocationType) fields->ushort_at(i + instanceKlass::low_offset);
2803 assert(atype == NONSTATIC_BYTE, "");
2804 FieldAllocationType new_atype = (wordSize == longSize) ? NONSTATIC_DOUBLE : NONSTATIC_WORD;
2805 fields->ushort_at_put(i + instanceKlass::low_offset, new_atype);
2807 found_vmentry = true;
2808 break;
2809 }
2810 }
2811 }
2813 if (!found_vmentry)
2814 THROW_MSG(vmSymbols::java_lang_VirtualMachineError(),
2815 "missing vmentry byte field in java.dyn.MethodHandle");
2816 }
2819 instanceKlassHandle ClassFileParser::parseClassFile(symbolHandle name,
2820 Handle class_loader,
2821 Handle protection_domain,
2822 KlassHandle host_klass,
2823 GrowableArray<Handle>* cp_patches,
2824 symbolHandle& parsed_name,
2825 bool verify,
2826 TRAPS) {
2827 // So that JVMTI can cache class file in the state before retransformable agents
2828 // have modified it
2829 unsigned char *cached_class_file_bytes = NULL;
2830 jint cached_class_file_length;
2832 ClassFileStream* cfs = stream();
2833 // Timing
2834 assert(THREAD->is_Java_thread(), "must be a JavaThread");
2835 JavaThread* jt = (JavaThread*) THREAD;
2837 PerfClassTraceTime ctimer(ClassLoader::perf_class_parse_time(),
2838 ClassLoader::perf_class_parse_selftime(),
2839 NULL,
2840 jt->get_thread_stat()->perf_recursion_counts_addr(),
2841 jt->get_thread_stat()->perf_timers_addr(),
2842 PerfClassTraceTime::PARSE_CLASS);
2844 _has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false;
2846 if (JvmtiExport::should_post_class_file_load_hook()) {
2847 unsigned char* ptr = cfs->buffer();
2848 unsigned char* end_ptr = cfs->buffer() + cfs->length();
2850 JvmtiExport::post_class_file_load_hook(name, class_loader, protection_domain,
2851 &ptr, &end_ptr,
2852 &cached_class_file_bytes,
2853 &cached_class_file_length);
2855 if (ptr != cfs->buffer()) {
2856 // JVMTI agent has modified class file data.
2857 // Set new class file stream using JVMTI agent modified
2858 // class file data.
2859 cfs = new ClassFileStream(ptr, end_ptr - ptr, cfs->source());
2860 set_stream(cfs);
2861 }
2862 }
2864 _host_klass = host_klass;
2865 _cp_patches = cp_patches;
2867 instanceKlassHandle nullHandle;
2869 // Figure out whether we can skip format checking (matching classic VM behavior)
2870 _need_verify = Verifier::should_verify_for(class_loader(), verify);
2872 // Set the verify flag in stream
2873 cfs->set_verify(_need_verify);
2875 // Save the class file name for easier error message printing.
2876 _class_name = name.not_null()? name : vmSymbolHandles::unknown_class_name();
2878 cfs->guarantee_more(8, CHECK_(nullHandle)); // magic, major, minor
2879 // Magic value
2880 u4 magic = cfs->get_u4_fast();
2881 guarantee_property(magic == JAVA_CLASSFILE_MAGIC,
2882 "Incompatible magic value %u in class file %s",
2883 magic, CHECK_(nullHandle));
2885 // Version numbers
2886 u2 minor_version = cfs->get_u2_fast();
2887 u2 major_version = cfs->get_u2_fast();
2889 // Check version numbers - we check this even with verifier off
2890 if (!is_supported_version(major_version, minor_version)) {
2891 if (name.is_null()) {
2892 Exceptions::fthrow(
2893 THREAD_AND_LOCATION,
2894 vmSymbolHandles::java_lang_UnsupportedClassVersionError(),
2895 "Unsupported major.minor version %u.%u",
2896 major_version,
2897 minor_version);
2898 } else {
2899 ResourceMark rm(THREAD);
2900 Exceptions::fthrow(
2901 THREAD_AND_LOCATION,
2902 vmSymbolHandles::java_lang_UnsupportedClassVersionError(),
2903 "%s : Unsupported major.minor version %u.%u",
2904 name->as_C_string(),
2905 major_version,
2906 minor_version);
2907 }
2908 return nullHandle;
2909 }
2911 _major_version = major_version;
2912 _minor_version = minor_version;
2915 // Check if verification needs to be relaxed for this class file
2916 // Do not restrict it to jdk1.0 or jdk1.1 to maintain backward compatibility (4982376)
2917 _relax_verify = Verifier::relax_verify_for(class_loader());
2919 // Constant pool
2920 constantPoolHandle cp = parse_constant_pool(CHECK_(nullHandle));
2921 int cp_size = cp->length();
2923 cfs->guarantee_more(8, CHECK_(nullHandle)); // flags, this_class, super_class, infs_len
2925 // Access flags
2926 AccessFlags access_flags;
2927 jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_CLASS_MODIFIERS;
2929 if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
2930 // Set abstract bit for old class files for backward compatibility
2931 flags |= JVM_ACC_ABSTRACT;
2932 }
2933 verify_legal_class_modifiers(flags, CHECK_(nullHandle));
2934 access_flags.set_flags(flags);
2936 // This class and superclass
2937 instanceKlassHandle super_klass;
2938 u2 this_class_index = cfs->get_u2_fast();
2939 check_property(
2940 valid_cp_range(this_class_index, cp_size) &&
2941 cp->tag_at(this_class_index).is_unresolved_klass(),
2942 "Invalid this class index %u in constant pool in class file %s",
2943 this_class_index, CHECK_(nullHandle));
2945 symbolHandle class_name (THREAD, cp->unresolved_klass_at(this_class_index));
2946 assert(class_name.not_null(), "class_name can't be null");
2948 // It's important to set parsed_name *before* resolving the super class.
2949 // (it's used for cleanup by the caller if parsing fails)
2950 parsed_name = class_name;
2952 // Update _class_name which could be null previously to be class_name
2953 _class_name = class_name;
2955 // Don't need to check whether this class name is legal or not.
2956 // It has been checked when constant pool is parsed.
2957 // However, make sure it is not an array type.
2958 if (_need_verify) {
2959 guarantee_property(class_name->byte_at(0) != JVM_SIGNATURE_ARRAY,
2960 "Bad class name in class file %s",
2961 CHECK_(nullHandle));
2962 }
2964 klassOop preserve_this_klass; // for storing result across HandleMark
2966 // release all handles when parsing is done
2967 { HandleMark hm(THREAD);
2969 // Checks if name in class file matches requested name
2970 if (name.not_null() && class_name() != name()) {
2971 ResourceMark rm(THREAD);
2972 Exceptions::fthrow(
2973 THREAD_AND_LOCATION,
2974 vmSymbolHandles::java_lang_NoClassDefFoundError(),
2975 "%s (wrong name: %s)",
2976 name->as_C_string(),
2977 class_name->as_C_string()
2978 );
2979 return nullHandle;
2980 }
2982 if (TraceClassLoadingPreorder) {
2983 tty->print("[Loading %s", name()->as_klass_external_name());
2984 if (cfs->source() != NULL) tty->print(" from %s", cfs->source());
2985 tty->print_cr("]");
2986 }
2988 u2 super_class_index = cfs->get_u2_fast();
2989 if (super_class_index == 0) {
2990 check_property(class_name() == vmSymbols::java_lang_Object(),
2991 "Invalid superclass index %u in class file %s",
2992 super_class_index,
2993 CHECK_(nullHandle));
2994 } else {
2995 check_property(valid_cp_range(super_class_index, cp_size) &&
2996 is_klass_reference(cp, super_class_index),
2997 "Invalid superclass index %u in class file %s",
2998 super_class_index,
2999 CHECK_(nullHandle));
3000 // The class name should be legal because it is checked when parsing constant pool.
3001 // However, make sure it is not an array type.
3002 bool is_array = false;
3003 if (cp->tag_at(super_class_index).is_klass()) {
3004 super_klass = instanceKlassHandle(THREAD, cp->resolved_klass_at(super_class_index));
3005 if (_need_verify)
3006 is_array = super_klass->oop_is_array();
3007 } else if (_need_verify) {
3008 is_array = (cp->unresolved_klass_at(super_class_index)->byte_at(0) == JVM_SIGNATURE_ARRAY);
3009 }
3010 if (_need_verify) {
3011 guarantee_property(!is_array,
3012 "Bad superclass name in class file %s", CHECK_(nullHandle));
3013 }
3014 }
3016 // Interfaces
3017 u2 itfs_len = cfs->get_u2_fast();
3018 objArrayHandle local_interfaces;
3019 if (itfs_len == 0) {
3020 local_interfaces = objArrayHandle(THREAD, Universe::the_empty_system_obj_array());
3021 } else {
3022 local_interfaces = parse_interfaces(cp, itfs_len, class_loader, protection_domain, _class_name, CHECK_(nullHandle));
3023 }
3025 // Fields (offsets are filled in later)
3026 struct FieldAllocationCount fac = {0,0,0,0,0,0,0,0,0,0};
3027 objArrayHandle fields_annotations;
3028 typeArrayHandle fields = parse_fields(cp, access_flags.is_interface(), &fac, &fields_annotations, CHECK_(nullHandle));
3029 // Methods
3030 bool has_final_method = false;
3031 AccessFlags promoted_flags;
3032 promoted_flags.set_flags(0);
3033 // These need to be oop pointers because they are allocated lazily
3034 // inside parse_methods inside a nested HandleMark
3035 objArrayOop methods_annotations_oop = NULL;
3036 objArrayOop methods_parameter_annotations_oop = NULL;
3037 objArrayOop methods_default_annotations_oop = NULL;
3038 objArrayHandle methods = parse_methods(cp, access_flags.is_interface(),
3039 &promoted_flags,
3040 &has_final_method,
3041 &methods_annotations_oop,
3042 &methods_parameter_annotations_oop,
3043 &methods_default_annotations_oop,
3044 CHECK_(nullHandle));
3046 objArrayHandle methods_annotations(THREAD, methods_annotations_oop);
3047 objArrayHandle methods_parameter_annotations(THREAD, methods_parameter_annotations_oop);
3048 objArrayHandle methods_default_annotations(THREAD, methods_default_annotations_oop);
3050 // We check super class after class file is parsed and format is checked
3051 if (super_class_index > 0 && super_klass.is_null()) {
3052 symbolHandle sk (THREAD, cp->klass_name_at(super_class_index));
3053 if (access_flags.is_interface()) {
3054 // Before attempting to resolve the superclass, check for class format
3055 // errors not checked yet.
3056 guarantee_property(sk() == vmSymbols::java_lang_Object(),
3057 "Interfaces must have java.lang.Object as superclass in class file %s",
3058 CHECK_(nullHandle));
3059 }
3060 klassOop k = SystemDictionary::resolve_super_or_fail(class_name,
3061 sk,
3062 class_loader,
3063 protection_domain,
3064 true,
3065 CHECK_(nullHandle));
3067 KlassHandle kh (THREAD, k);
3068 super_klass = instanceKlassHandle(THREAD, kh());
3069 if (LinkWellKnownClasses) // my super class is well known to me
3070 cp->klass_at_put(super_class_index, super_klass()); // eagerly resolve
3071 }
3072 if (super_klass.not_null()) {
3073 if (super_klass->is_interface()) {
3074 ResourceMark rm(THREAD);
3075 Exceptions::fthrow(
3076 THREAD_AND_LOCATION,
3077 vmSymbolHandles::java_lang_IncompatibleClassChangeError(),
3078 "class %s has interface %s as super class",
3079 class_name->as_klass_external_name(),
3080 super_klass->external_name()
3081 );
3082 return nullHandle;
3083 }
3084 // Make sure super class is not final
3085 if (super_klass->is_final()) {
3086 THROW_MSG_(vmSymbols::java_lang_VerifyError(), "Cannot inherit from final class", nullHandle);
3087 }
3088 }
3090 // Compute the transitive list of all unique interfaces implemented by this class
3091 objArrayHandle transitive_interfaces = compute_transitive_interfaces(super_klass, local_interfaces, CHECK_(nullHandle));
3093 // sort methods
3094 typeArrayHandle method_ordering = sort_methods(methods,
3095 methods_annotations,
3096 methods_parameter_annotations,
3097 methods_default_annotations,
3098 CHECK_(nullHandle));
3100 // promote flags from parse_methods() to the klass' flags
3101 access_flags.add_promoted_flags(promoted_flags.as_int());
3103 // Size of Java vtable (in words)
3104 int vtable_size = 0;
3105 int itable_size = 0;
3106 int num_miranda_methods = 0;
3108 klassVtable::compute_vtable_size_and_num_mirandas(vtable_size,
3109 num_miranda_methods,
3110 super_klass(),
3111 methods(),
3112 access_flags,
3113 class_loader,
3114 class_name,
3115 local_interfaces(),
3116 CHECK_(nullHandle));
3118 // Size of Java itable (in words)
3119 itable_size = access_flags.is_interface() ? 0 : klassItable::compute_itable_size(transitive_interfaces);
3121 // Field size and offset computation
3122 int nonstatic_field_size = super_klass() == NULL ? 0 : super_klass->nonstatic_field_size();
3123 #ifndef PRODUCT
3124 int orig_nonstatic_field_size = 0;
3125 #endif
3126 int static_field_size = 0;
3127 int next_static_oop_offset;
3128 int next_static_double_offset;
3129 int next_static_word_offset;
3130 int next_static_short_offset;
3131 int next_static_byte_offset;
3132 int next_static_type_offset;
3133 int next_nonstatic_oop_offset;
3134 int next_nonstatic_double_offset;
3135 int next_nonstatic_word_offset;
3136 int next_nonstatic_short_offset;
3137 int next_nonstatic_byte_offset;
3138 int next_nonstatic_type_offset;
3139 int first_nonstatic_oop_offset;
3140 int first_nonstatic_field_offset;
3141 int next_nonstatic_field_offset;
3143 // Calculate the starting byte offsets
3144 next_static_oop_offset = (instanceKlass::header_size() +
3145 align_object_offset(vtable_size) +
3146 align_object_offset(itable_size)) * wordSize;
3147 next_static_double_offset = next_static_oop_offset +
3148 (fac.static_oop_count * heapOopSize);
3149 if ( fac.static_double_count &&
3150 (Universe::field_type_should_be_aligned(T_DOUBLE) ||
3151 Universe::field_type_should_be_aligned(T_LONG)) ) {
3152 next_static_double_offset = align_size_up(next_static_double_offset, BytesPerLong);
3153 }
3155 next_static_word_offset = next_static_double_offset +
3156 (fac.static_double_count * BytesPerLong);
3157 next_static_short_offset = next_static_word_offset +
3158 (fac.static_word_count * BytesPerInt);
3159 next_static_byte_offset = next_static_short_offset +
3160 (fac.static_short_count * BytesPerShort);
3161 next_static_type_offset = align_size_up((next_static_byte_offset +
3162 fac.static_byte_count ), wordSize );
3163 static_field_size = (next_static_type_offset -
3164 next_static_oop_offset) / wordSize;
3165 first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() +
3166 nonstatic_field_size * heapOopSize;
3167 next_nonstatic_field_offset = first_nonstatic_field_offset;
3169 // Add fake fields for java.lang.Class instances (also see below)
3170 if (class_name() == vmSymbols::java_lang_Class() && class_loader.is_null()) {
3171 java_lang_Class_fix_pre(&methods, &fac, CHECK_(nullHandle));
3172 }
3174 // adjust the vmentry field declaration in java.dyn.MethodHandle
3175 if (EnableMethodHandles && class_name() == vmSymbols::sun_dyn_MethodHandleImpl() && class_loader.is_null()) {
3176 java_dyn_MethodHandle_fix_pre(cp, fields, &fac, CHECK_(nullHandle));
3177 }
3179 // Add a fake "discovered" field if it is not present
3180 // for compatibility with earlier jdk's.
3181 if (class_name() == vmSymbols::java_lang_ref_Reference()
3182 && class_loader.is_null()) {
3183 java_lang_ref_Reference_fix_pre(&fields, cp, &fac, CHECK_(nullHandle));
3184 }
3185 // end of "discovered" field compactibility fix
3187 unsigned int nonstatic_double_count = fac.nonstatic_double_count;
3188 unsigned int nonstatic_word_count = fac.nonstatic_word_count;
3189 unsigned int nonstatic_short_count = fac.nonstatic_short_count;
3190 unsigned int nonstatic_byte_count = fac.nonstatic_byte_count;
3191 unsigned int nonstatic_oop_count = fac.nonstatic_oop_count;
3193 bool super_has_nonstatic_fields =
3194 (super_klass() != NULL && super_klass->has_nonstatic_fields());
3195 bool has_nonstatic_fields = super_has_nonstatic_fields ||
3196 ((nonstatic_double_count + nonstatic_word_count +
3197 nonstatic_short_count + nonstatic_byte_count +
3198 nonstatic_oop_count) != 0);
3201 // Prepare list of oops for oop map generation.
3202 int* nonstatic_oop_offsets;
3203 unsigned int* nonstatic_oop_counts;
3204 unsigned int nonstatic_oop_map_count = 0;
3206 nonstatic_oop_offsets = NEW_RESOURCE_ARRAY_IN_THREAD(
3207 THREAD, int, nonstatic_oop_count + 1);
3208 nonstatic_oop_counts = NEW_RESOURCE_ARRAY_IN_THREAD(
3209 THREAD, unsigned int, nonstatic_oop_count + 1);
3211 // Add fake fields for java.lang.Class instances (also see above).
3212 // FieldsAllocationStyle and CompactFields values will be reset to default.
3213 if(class_name() == vmSymbols::java_lang_Class() && class_loader.is_null()) {
3214 java_lang_Class_fix_post(&next_nonstatic_field_offset);
3215 nonstatic_oop_offsets[0] = first_nonstatic_field_offset;
3216 const uint fake_oop_count = (next_nonstatic_field_offset -
3217 first_nonstatic_field_offset) / heapOopSize;
3218 nonstatic_oop_counts[0] = fake_oop_count;
3219 nonstatic_oop_map_count = 1;
3220 nonstatic_oop_count -= fake_oop_count;
3221 first_nonstatic_oop_offset = first_nonstatic_field_offset;
3222 } else {
3223 first_nonstatic_oop_offset = 0; // will be set for first oop field
3224 }
3226 #ifndef PRODUCT
3227 if( PrintCompactFieldsSavings ) {
3228 next_nonstatic_double_offset = next_nonstatic_field_offset +
3229 (nonstatic_oop_count * heapOopSize);
3230 if ( nonstatic_double_count > 0 ) {
3231 next_nonstatic_double_offset = align_size_up(next_nonstatic_double_offset, BytesPerLong);
3232 }
3233 next_nonstatic_word_offset = next_nonstatic_double_offset +
3234 (nonstatic_double_count * BytesPerLong);
3235 next_nonstatic_short_offset = next_nonstatic_word_offset +
3236 (nonstatic_word_count * BytesPerInt);
3237 next_nonstatic_byte_offset = next_nonstatic_short_offset +
3238 (nonstatic_short_count * BytesPerShort);
3239 next_nonstatic_type_offset = align_size_up((next_nonstatic_byte_offset +
3240 nonstatic_byte_count ), heapOopSize );
3241 orig_nonstatic_field_size = nonstatic_field_size +
3242 ((next_nonstatic_type_offset - first_nonstatic_field_offset)/heapOopSize);
3243 }
3244 #endif
3245 bool compact_fields = CompactFields;
3246 int allocation_style = FieldsAllocationStyle;
3247 if( allocation_style < 0 || allocation_style > 2 ) { // Out of range?
3248 assert(false, "0 <= FieldsAllocationStyle <= 2");
3249 allocation_style = 1; // Optimistic
3250 }
3252 // The next classes have predefined hard-coded fields offsets
3253 // (see in JavaClasses::compute_hard_coded_offsets()).
3254 // Use default fields allocation order for them.
3255 if( (allocation_style != 0 || compact_fields ) && class_loader.is_null() &&
3256 (class_name() == vmSymbols::java_lang_AssertionStatusDirectives() ||
3257 class_name() == vmSymbols::java_lang_Class() ||
3258 class_name() == vmSymbols::java_lang_ClassLoader() ||
3259 class_name() == vmSymbols::java_lang_ref_Reference() ||
3260 class_name() == vmSymbols::java_lang_ref_SoftReference() ||
3261 class_name() == vmSymbols::java_lang_StackTraceElement() ||
3262 class_name() == vmSymbols::java_lang_String() ||
3263 class_name() == vmSymbols::java_lang_Throwable() ||
3264 class_name() == vmSymbols::java_lang_Boolean() ||
3265 class_name() == vmSymbols::java_lang_Character() ||
3266 class_name() == vmSymbols::java_lang_Float() ||
3267 class_name() == vmSymbols::java_lang_Double() ||
3268 class_name() == vmSymbols::java_lang_Byte() ||
3269 class_name() == vmSymbols::java_lang_Short() ||
3270 class_name() == vmSymbols::java_lang_Integer() ||
3271 class_name() == vmSymbols::java_lang_Long())) {
3272 allocation_style = 0; // Allocate oops first
3273 compact_fields = false; // Don't compact fields
3274 }
3276 if( allocation_style == 0 ) {
3277 // Fields order: oops, longs/doubles, ints, shorts/chars, bytes
3278 next_nonstatic_oop_offset = next_nonstatic_field_offset;
3279 next_nonstatic_double_offset = next_nonstatic_oop_offset +
3280 (nonstatic_oop_count * heapOopSize);
3281 } else if( allocation_style == 1 ) {
3282 // Fields order: longs/doubles, ints, shorts/chars, bytes, oops
3283 next_nonstatic_double_offset = next_nonstatic_field_offset;
3284 } else if( allocation_style == 2 ) {
3285 // Fields allocation: oops fields in super and sub classes are together.
3286 if( nonstatic_field_size > 0 && super_klass() != NULL &&
3287 super_klass->nonstatic_oop_map_size() > 0 ) {
3288 int map_size = super_klass->nonstatic_oop_map_size();
3289 OopMapBlock* first_map = super_klass->start_of_nonstatic_oop_maps();
3290 OopMapBlock* last_map = first_map + map_size - 1;
3291 int next_offset = last_map->offset() + (last_map->count() * heapOopSize);
3292 if (next_offset == next_nonstatic_field_offset) {
3293 allocation_style = 0; // allocate oops first
3294 next_nonstatic_oop_offset = next_nonstatic_field_offset;
3295 next_nonstatic_double_offset = next_nonstatic_oop_offset +
3296 (nonstatic_oop_count * heapOopSize);
3297 }
3298 }
3299 if( allocation_style == 2 ) {
3300 allocation_style = 1; // allocate oops last
3301 next_nonstatic_double_offset = next_nonstatic_field_offset;
3302 }
3303 } else {
3304 ShouldNotReachHere();
3305 }
3307 int nonstatic_oop_space_count = 0;
3308 int nonstatic_word_space_count = 0;
3309 int nonstatic_short_space_count = 0;
3310 int nonstatic_byte_space_count = 0;
3311 int nonstatic_oop_space_offset;
3312 int nonstatic_word_space_offset;
3313 int nonstatic_short_space_offset;
3314 int nonstatic_byte_space_offset;
3316 if( nonstatic_double_count > 0 ) {
3317 int offset = next_nonstatic_double_offset;
3318 next_nonstatic_double_offset = align_size_up(offset, BytesPerLong);
3319 if( compact_fields && offset != next_nonstatic_double_offset ) {
3320 // Allocate available fields into the gap before double field.
3321 int length = next_nonstatic_double_offset - offset;
3322 assert(length == BytesPerInt, "");
3323 nonstatic_word_space_offset = offset;
3324 if( nonstatic_word_count > 0 ) {
3325 nonstatic_word_count -= 1;
3326 nonstatic_word_space_count = 1; // Only one will fit
3327 length -= BytesPerInt;
3328 offset += BytesPerInt;
3329 }
3330 nonstatic_short_space_offset = offset;
3331 while( length >= BytesPerShort && nonstatic_short_count > 0 ) {
3332 nonstatic_short_count -= 1;
3333 nonstatic_short_space_count += 1;
3334 length -= BytesPerShort;
3335 offset += BytesPerShort;
3336 }
3337 nonstatic_byte_space_offset = offset;
3338 while( length > 0 && nonstatic_byte_count > 0 ) {
3339 nonstatic_byte_count -= 1;
3340 nonstatic_byte_space_count += 1;
3341 length -= 1;
3342 }
3343 // Allocate oop field in the gap if there are no other fields for that.
3344 nonstatic_oop_space_offset = offset;
3345 if( length >= heapOopSize && nonstatic_oop_count > 0 &&
3346 allocation_style != 0 ) { // when oop fields not first
3347 nonstatic_oop_count -= 1;
3348 nonstatic_oop_space_count = 1; // Only one will fit
3349 length -= heapOopSize;
3350 offset += heapOopSize;
3351 }
3352 }
3353 }
3355 next_nonstatic_word_offset = next_nonstatic_double_offset +
3356 (nonstatic_double_count * BytesPerLong);
3357 next_nonstatic_short_offset = next_nonstatic_word_offset +
3358 (nonstatic_word_count * BytesPerInt);
3359 next_nonstatic_byte_offset = next_nonstatic_short_offset +
3360 (nonstatic_short_count * BytesPerShort);
3362 int notaligned_offset;
3363 if( allocation_style == 0 ) {
3364 notaligned_offset = next_nonstatic_byte_offset + nonstatic_byte_count;
3365 } else { // allocation_style == 1
3366 next_nonstatic_oop_offset = next_nonstatic_byte_offset + nonstatic_byte_count;
3367 if( nonstatic_oop_count > 0 ) {
3368 next_nonstatic_oop_offset = align_size_up(next_nonstatic_oop_offset, heapOopSize);
3369 }
3370 notaligned_offset = next_nonstatic_oop_offset + (nonstatic_oop_count * heapOopSize);
3371 }
3372 next_nonstatic_type_offset = align_size_up(notaligned_offset, heapOopSize );
3373 nonstatic_field_size = nonstatic_field_size + ((next_nonstatic_type_offset
3374 - first_nonstatic_field_offset)/heapOopSize);
3376 // Iterate over fields again and compute correct offsets.
3377 // The field allocation type was temporarily stored in the offset slot.
3378 // oop fields are located before non-oop fields (static and non-static).
3379 int len = fields->length();
3380 for (int i = 0; i < len; i += instanceKlass::next_offset) {
3381 int real_offset;
3382 FieldAllocationType atype = (FieldAllocationType) fields->ushort_at(i + instanceKlass::low_offset);
3383 switch (atype) {
3384 case STATIC_OOP:
3385 real_offset = next_static_oop_offset;
3386 next_static_oop_offset += heapOopSize;
3387 break;
3388 case STATIC_BYTE:
3389 real_offset = next_static_byte_offset;
3390 next_static_byte_offset += 1;
3391 break;
3392 case STATIC_SHORT:
3393 real_offset = next_static_short_offset;
3394 next_static_short_offset += BytesPerShort;
3395 break;
3396 case STATIC_WORD:
3397 real_offset = next_static_word_offset;
3398 next_static_word_offset += BytesPerInt;
3399 break;
3400 case STATIC_ALIGNED_DOUBLE:
3401 case STATIC_DOUBLE:
3402 real_offset = next_static_double_offset;
3403 next_static_double_offset += BytesPerLong;
3404 break;
3405 case NONSTATIC_OOP:
3406 if( nonstatic_oop_space_count > 0 ) {
3407 real_offset = nonstatic_oop_space_offset;
3408 nonstatic_oop_space_offset += heapOopSize;
3409 nonstatic_oop_space_count -= 1;
3410 } else {
3411 real_offset = next_nonstatic_oop_offset;
3412 next_nonstatic_oop_offset += heapOopSize;
3413 }
3414 // Update oop maps
3415 if( nonstatic_oop_map_count > 0 &&
3416 nonstatic_oop_offsets[nonstatic_oop_map_count - 1] ==
3417 real_offset -
3418 int(nonstatic_oop_counts[nonstatic_oop_map_count - 1]) *
3419 heapOopSize ) {
3420 // Extend current oop map
3421 nonstatic_oop_counts[nonstatic_oop_map_count - 1] += 1;
3422 } else {
3423 // Create new oop map
3424 nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset;
3425 nonstatic_oop_counts [nonstatic_oop_map_count] = 1;
3426 nonstatic_oop_map_count += 1;
3427 if( first_nonstatic_oop_offset == 0 ) { // Undefined
3428 first_nonstatic_oop_offset = real_offset;
3429 }
3430 }
3431 break;
3432 case NONSTATIC_BYTE:
3433 if( nonstatic_byte_space_count > 0 ) {
3434 real_offset = nonstatic_byte_space_offset;
3435 nonstatic_byte_space_offset += 1;
3436 nonstatic_byte_space_count -= 1;
3437 } else {
3438 real_offset = next_nonstatic_byte_offset;
3439 next_nonstatic_byte_offset += 1;
3440 }
3441 break;
3442 case NONSTATIC_SHORT:
3443 if( nonstatic_short_space_count > 0 ) {
3444 real_offset = nonstatic_short_space_offset;
3445 nonstatic_short_space_offset += BytesPerShort;
3446 nonstatic_short_space_count -= 1;
3447 } else {
3448 real_offset = next_nonstatic_short_offset;
3449 next_nonstatic_short_offset += BytesPerShort;
3450 }
3451 break;
3452 case NONSTATIC_WORD:
3453 if( nonstatic_word_space_count > 0 ) {
3454 real_offset = nonstatic_word_space_offset;
3455 nonstatic_word_space_offset += BytesPerInt;
3456 nonstatic_word_space_count -= 1;
3457 } else {
3458 real_offset = next_nonstatic_word_offset;
3459 next_nonstatic_word_offset += BytesPerInt;
3460 }
3461 break;
3462 case NONSTATIC_ALIGNED_DOUBLE:
3463 case NONSTATIC_DOUBLE:
3464 real_offset = next_nonstatic_double_offset;
3465 next_nonstatic_double_offset += BytesPerLong;
3466 break;
3467 default:
3468 ShouldNotReachHere();
3469 }
3470 fields->short_at_put(i + instanceKlass::low_offset, extract_low_short_from_int(real_offset));
3471 fields->short_at_put(i + instanceKlass::high_offset, extract_high_short_from_int(real_offset));
3472 }
3474 // Size of instances
3475 int instance_size;
3477 next_nonstatic_type_offset = align_size_up(notaligned_offset, wordSize );
3478 instance_size = align_object_size(next_nonstatic_type_offset / wordSize);
3480 assert(instance_size == align_object_size(align_size_up((instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize), wordSize) / wordSize), "consistent layout helper value");
3482 // Number of non-static oop map blocks allocated at end of klass.
3483 const unsigned int total_oop_map_count =
3484 compute_oop_map_count(super_klass, nonstatic_oop_map_count,
3485 first_nonstatic_oop_offset);
3487 // Compute reference type
3488 ReferenceType rt;
3489 if (super_klass() == NULL) {
3490 rt = REF_NONE;
3491 } else {
3492 rt = super_klass->reference_type();
3493 }
3495 // We can now create the basic klassOop for this klass
3496 klassOop ik = oopFactory::new_instanceKlass(vtable_size, itable_size,
3497 static_field_size,
3498 total_oop_map_count,
3499 rt, CHECK_(nullHandle));
3500 instanceKlassHandle this_klass (THREAD, ik);
3502 assert(this_klass->static_field_size() == static_field_size, "sanity");
3503 assert(this_klass->nonstatic_oop_map_count() == total_oop_map_count,
3504 "sanity");
3506 // Fill in information already parsed
3507 this_klass->set_access_flags(access_flags);
3508 this_klass->set_should_verify_class(verify);
3509 jint lh = Klass::instance_layout_helper(instance_size, false);
3510 this_klass->set_layout_helper(lh);
3511 assert(this_klass->oop_is_instance(), "layout is correct");
3512 assert(this_klass->size_helper() == instance_size, "correct size_helper");
3513 // Not yet: supers are done below to support the new subtype-checking fields
3514 //this_klass->set_super(super_klass());
3515 this_klass->set_class_loader(class_loader());
3516 this_klass->set_nonstatic_field_size(nonstatic_field_size);
3517 this_klass->set_has_nonstatic_fields(has_nonstatic_fields);
3518 this_klass->set_static_oop_field_size(fac.static_oop_count);
3519 cp->set_pool_holder(this_klass());
3520 this_klass->set_constants(cp());
3521 this_klass->set_local_interfaces(local_interfaces());
3522 this_klass->set_fields(fields());
3523 this_klass->set_methods(methods());
3524 if (has_final_method) {
3525 this_klass->set_has_final_method();
3526 }
3527 this_klass->set_method_ordering(method_ordering());
3528 // The instanceKlass::_methods_jmethod_ids cache and the
3529 // instanceKlass::_methods_cached_itable_indices cache are
3530 // both managed on the assumption that the initial cache
3531 // size is equal to the number of methods in the class. If
3532 // that changes, then instanceKlass::idnum_can_increment()
3533 // has to be changed accordingly.
3534 this_klass->set_initial_method_idnum(methods->length());
3535 this_klass->set_name(cp->klass_name_at(this_class_index));
3536 if (LinkWellKnownClasses || is_anonymous()) // I am well known to myself
3537 cp->klass_at_put(this_class_index, this_klass()); // eagerly resolve
3538 this_klass->set_protection_domain(protection_domain());
3539 this_klass->set_fields_annotations(fields_annotations());
3540 this_klass->set_methods_annotations(methods_annotations());
3541 this_klass->set_methods_parameter_annotations(methods_parameter_annotations());
3542 this_klass->set_methods_default_annotations(methods_default_annotations());
3544 this_klass->set_minor_version(minor_version);
3545 this_klass->set_major_version(major_version);
3547 // Set up methodOop::intrinsic_id as soon as we know the names of methods.
3548 // (We used to do this lazily, but now we query it in Rewriter,
3549 // which is eagerly done for every method, so we might as well do it now,
3550 // when everything is fresh in memory.)
3551 if (methodOopDesc::klass_id_for_intrinsics(this_klass->as_klassOop()) != vmSymbols::NO_SID) {
3552 for (int j = 0; j < methods->length(); j++) {
3553 ((methodOop)methods->obj_at(j))->init_intrinsic_id();
3554 }
3555 }
3557 if (cached_class_file_bytes != NULL) {
3558 // JVMTI: we have an instanceKlass now, tell it about the cached bytes
3559 this_klass->set_cached_class_file(cached_class_file_bytes,
3560 cached_class_file_length);
3561 }
3563 // Miranda methods
3564 if ((num_miranda_methods > 0) ||
3565 // if this class introduced new miranda methods or
3566 (super_klass.not_null() && (super_klass->has_miranda_methods()))
3567 // super class exists and this class inherited miranda methods
3568 ) {
3569 this_klass->set_has_miranda_methods(); // then set a flag
3570 }
3572 // Additional attributes
3573 parse_classfile_attributes(cp, this_klass, CHECK_(nullHandle));
3575 // Make sure this is the end of class file stream
3576 guarantee_property(cfs->at_eos(), "Extra bytes at the end of class file %s", CHECK_(nullHandle));
3578 // Initialize static fields
3579 this_klass->do_local_static_fields(&initialize_static_field, CHECK_(nullHandle));
3581 // VerifyOops believes that once this has been set, the object is completely loaded.
3582 // Compute transitive closure of interfaces this class implements
3583 this_klass->set_transitive_interfaces(transitive_interfaces());
3585 // Fill in information needed to compute superclasses.
3586 this_klass->initialize_supers(super_klass(), CHECK_(nullHandle));
3588 // Initialize itable offset tables
3589 klassItable::setup_itable_offset_table(this_klass);
3591 // Do final class setup
3592 fill_oop_maps(this_klass, nonstatic_oop_map_count, nonstatic_oop_offsets, nonstatic_oop_counts);
3594 set_precomputed_flags(this_klass);
3596 // reinitialize modifiers, using the InnerClasses attribute
3597 int computed_modifiers = this_klass->compute_modifier_flags(CHECK_(nullHandle));
3598 this_klass->set_modifier_flags(computed_modifiers);
3600 // check if this class can access its super class
3601 check_super_class_access(this_klass, CHECK_(nullHandle));
3603 // check if this class can access its superinterfaces
3604 check_super_interface_access(this_klass, CHECK_(nullHandle));
3606 // check if this class overrides any final method
3607 check_final_method_override(this_klass, CHECK_(nullHandle));
3609 // check that if this class is an interface then it doesn't have static methods
3610 if (this_klass->is_interface()) {
3611 check_illegal_static_method(this_klass, CHECK_(nullHandle));
3612 }
3614 ClassLoadingService::notify_class_loaded(instanceKlass::cast(this_klass()),
3615 false /* not shared class */);
3617 if (TraceClassLoading) {
3618 // print in a single call to reduce interleaving of output
3619 if (cfs->source() != NULL) {
3620 tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
3621 cfs->source());
3622 } else if (class_loader.is_null()) {
3623 if (THREAD->is_Java_thread()) {
3624 klassOop caller = ((JavaThread*)THREAD)->security_get_caller_class(1);
3625 tty->print("[Loaded %s by instance of %s]\n",
3626 this_klass->external_name(),
3627 instanceKlass::cast(caller)->external_name());
3628 } else {
3629 tty->print("[Loaded %s]\n", this_klass->external_name());
3630 }
3631 } else {
3632 ResourceMark rm;
3633 tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
3634 instanceKlass::cast(class_loader->klass())->external_name());
3635 }
3636 }
3638 if (TraceClassResolution) {
3639 // print out the superclass.
3640 const char * from = Klass::cast(this_klass())->external_name();
3641 if (this_klass->java_super() != NULL) {
3642 tty->print("RESOLVE %s %s (super)\n", from, instanceKlass::cast(this_klass->java_super())->external_name());
3643 }
3644 // print out each of the interface classes referred to by this class.
3645 objArrayHandle local_interfaces(THREAD, this_klass->local_interfaces());
3646 if (!local_interfaces.is_null()) {
3647 int length = local_interfaces->length();
3648 for (int i = 0; i < length; i++) {
3649 klassOop k = klassOop(local_interfaces->obj_at(i));
3650 instanceKlass* to_class = instanceKlass::cast(k);
3651 const char * to = to_class->external_name();
3652 tty->print("RESOLVE %s %s (interface)\n", from, to);
3653 }
3654 }
3655 }
3657 #ifndef PRODUCT
3658 if( PrintCompactFieldsSavings ) {
3659 if( nonstatic_field_size < orig_nonstatic_field_size ) {
3660 tty->print("[Saved %d of %d bytes in %s]\n",
3661 (orig_nonstatic_field_size - nonstatic_field_size)*heapOopSize,
3662 orig_nonstatic_field_size*heapOopSize,
3663 this_klass->external_name());
3664 } else if( nonstatic_field_size > orig_nonstatic_field_size ) {
3665 tty->print("[Wasted %d over %d bytes in %s]\n",
3666 (nonstatic_field_size - orig_nonstatic_field_size)*heapOopSize,
3667 orig_nonstatic_field_size*heapOopSize,
3668 this_klass->external_name());
3669 }
3670 }
3671 #endif
3673 // preserve result across HandleMark
3674 preserve_this_klass = this_klass();
3675 }
3677 // Create new handle outside HandleMark
3678 instanceKlassHandle this_klass (THREAD, preserve_this_klass);
3679 debug_only(this_klass->as_klassOop()->verify();)
3681 return this_klass;
3682 }
3685 unsigned int
3686 ClassFileParser::compute_oop_map_count(instanceKlassHandle super,
3687 unsigned int nonstatic_oop_map_count,
3688 int first_nonstatic_oop_offset) {
3689 unsigned int map_count =
3690 super.is_null() ? 0 : super->nonstatic_oop_map_count();
3691 if (nonstatic_oop_map_count > 0) {
3692 // We have oops to add to map
3693 if (map_count == 0) {
3694 map_count = nonstatic_oop_map_count;
3695 } else {
3696 // Check whether we should add a new map block or whether the last one can
3697 // be extended
3698 OopMapBlock* const first_map = super->start_of_nonstatic_oop_maps();
3699 OopMapBlock* const last_map = first_map + map_count - 1;
3701 int next_offset = last_map->offset() + last_map->count() * heapOopSize;
3702 if (next_offset == first_nonstatic_oop_offset) {
3703 // There is no gap bettwen superklass's last oop field and first
3704 // local oop field, merge maps.
3705 nonstatic_oop_map_count -= 1;
3706 } else {
3707 // Superklass didn't end with a oop field, add extra maps
3708 assert(next_offset < first_nonstatic_oop_offset, "just checking");
3709 }
3710 map_count += nonstatic_oop_map_count;
3711 }
3712 }
3713 return map_count;
3714 }
3717 void ClassFileParser::fill_oop_maps(instanceKlassHandle k,
3718 unsigned int nonstatic_oop_map_count,
3719 int* nonstatic_oop_offsets,
3720 unsigned int* nonstatic_oop_counts) {
3721 OopMapBlock* this_oop_map = k->start_of_nonstatic_oop_maps();
3722 const instanceKlass* const super = k->superklass();
3723 const unsigned int super_count = super ? super->nonstatic_oop_map_count() : 0;
3724 if (super_count > 0) {
3725 // Copy maps from superklass
3726 OopMapBlock* super_oop_map = super->start_of_nonstatic_oop_maps();
3727 for (unsigned int i = 0; i < super_count; ++i) {
3728 *this_oop_map++ = *super_oop_map++;
3729 }
3730 }
3732 if (nonstatic_oop_map_count > 0) {
3733 if (super_count + nonstatic_oop_map_count > k->nonstatic_oop_map_count()) {
3734 // The counts differ because there is no gap between superklass's last oop
3735 // field and the first local oop field. Extend the last oop map copied
3736 // from the superklass instead of creating new one.
3737 nonstatic_oop_map_count--;
3738 nonstatic_oop_offsets++;
3739 this_oop_map--;
3740 this_oop_map->set_count(this_oop_map->count() + *nonstatic_oop_counts++);
3741 this_oop_map++;
3742 }
3744 // Add new map blocks, fill them
3745 while (nonstatic_oop_map_count-- > 0) {
3746 this_oop_map->set_offset(*nonstatic_oop_offsets++);
3747 this_oop_map->set_count(*nonstatic_oop_counts++);
3748 this_oop_map++;
3749 }
3750 assert(k->start_of_nonstatic_oop_maps() + k->nonstatic_oop_map_count() ==
3751 this_oop_map, "sanity");
3752 }
3753 }
3756 void ClassFileParser::set_precomputed_flags(instanceKlassHandle k) {
3757 klassOop super = k->super();
3759 // Check if this klass has an empty finalize method (i.e. one with return bytecode only),
3760 // in which case we don't have to register objects as finalizable
3761 if (!_has_empty_finalizer) {
3762 if (_has_finalizer ||
3763 (super != NULL && super->klass_part()->has_finalizer())) {
3764 k->set_has_finalizer();
3765 }
3766 }
3768 #ifdef ASSERT
3769 bool f = false;
3770 methodOop m = k->lookup_method(vmSymbols::finalize_method_name(),
3771 vmSymbols::void_method_signature());
3772 if (m != NULL && !m->is_empty_method()) {
3773 f = true;
3774 }
3775 assert(f == k->has_finalizer(), "inconsistent has_finalizer");
3776 #endif
3778 // Check if this klass supports the java.lang.Cloneable interface
3779 if (SystemDictionary::Cloneable_klass_loaded()) {
3780 if (k->is_subtype_of(SystemDictionary::Cloneable_klass())) {
3781 k->set_is_cloneable();
3782 }
3783 }
3785 // Check if this klass has a vanilla default constructor
3786 if (super == NULL) {
3787 // java.lang.Object has empty default constructor
3788 k->set_has_vanilla_constructor();
3789 } else {
3790 if (Klass::cast(super)->has_vanilla_constructor() &&
3791 _has_vanilla_constructor) {
3792 k->set_has_vanilla_constructor();
3793 }
3794 #ifdef ASSERT
3795 bool v = false;
3796 if (Klass::cast(super)->has_vanilla_constructor()) {
3797 methodOop constructor = k->find_method(vmSymbols::object_initializer_name(
3798 ), vmSymbols::void_method_signature());
3799 if (constructor != NULL && constructor->is_vanilla_constructor()) {
3800 v = true;
3801 }
3802 }
3803 assert(v == k->has_vanilla_constructor(), "inconsistent has_vanilla_constructor");
3804 #endif
3805 }
3807 // If it cannot be fast-path allocated, set a bit in the layout helper.
3808 // See documentation of instanceKlass::can_be_fastpath_allocated().
3809 assert(k->size_helper() > 0, "layout_helper is initialized");
3810 if ((!RegisterFinalizersAtInit && k->has_finalizer())
3811 || k->is_abstract() || k->is_interface()
3812 || (k->name() == vmSymbols::java_lang_Class()
3813 && k->class_loader() == NULL)
3814 || k->size_helper() >= FastAllocateSizeLimit) {
3815 // Forbid fast-path allocation.
3816 jint lh = Klass::instance_layout_helper(k->size_helper(), true);
3817 k->set_layout_helper(lh);
3818 }
3819 }
3822 // utility method for appending and array with check for duplicates
3824 void append_interfaces(objArrayHandle result, int& index, objArrayOop ifs) {
3825 // iterate over new interfaces
3826 for (int i = 0; i < ifs->length(); i++) {
3827 oop e = ifs->obj_at(i);
3828 assert(e->is_klass() && instanceKlass::cast(klassOop(e))->is_interface(), "just checking");
3829 // check for duplicates
3830 bool duplicate = false;
3831 for (int j = 0; j < index; j++) {
3832 if (result->obj_at(j) == e) {
3833 duplicate = true;
3834 break;
3835 }
3836 }
3837 // add new interface
3838 if (!duplicate) {
3839 result->obj_at_put(index++, e);
3840 }
3841 }
3842 }
3844 objArrayHandle ClassFileParser::compute_transitive_interfaces(instanceKlassHandle super, objArrayHandle local_ifs, TRAPS) {
3845 // Compute maximum size for transitive interfaces
3846 int max_transitive_size = 0;
3847 int super_size = 0;
3848 // Add superclass transitive interfaces size
3849 if (super.not_null()) {
3850 super_size = super->transitive_interfaces()->length();
3851 max_transitive_size += super_size;
3852 }
3853 // Add local interfaces' super interfaces
3854 int local_size = local_ifs->length();
3855 for (int i = 0; i < local_size; i++) {
3856 klassOop l = klassOop(local_ifs->obj_at(i));
3857 max_transitive_size += instanceKlass::cast(l)->transitive_interfaces()->length();
3858 }
3859 // Finally add local interfaces
3860 max_transitive_size += local_size;
3861 // Construct array
3862 objArrayHandle result;
3863 if (max_transitive_size == 0) {
3864 // no interfaces, use canonicalized array
3865 result = objArrayHandle(THREAD, Universe::the_empty_system_obj_array());
3866 } else if (max_transitive_size == super_size) {
3867 // no new local interfaces added, share superklass' transitive interface array
3868 result = objArrayHandle(THREAD, super->transitive_interfaces());
3869 } else if (max_transitive_size == local_size) {
3870 // only local interfaces added, share local interface array
3871 result = local_ifs;
3872 } else {
3873 objArrayHandle nullHandle;
3874 objArrayOop new_objarray = oopFactory::new_system_objArray(max_transitive_size, CHECK_(nullHandle));
3875 result = objArrayHandle(THREAD, new_objarray);
3876 int index = 0;
3877 // Copy down from superclass
3878 if (super.not_null()) {
3879 append_interfaces(result, index, super->transitive_interfaces());
3880 }
3881 // Copy down from local interfaces' superinterfaces
3882 for (int i = 0; i < local_ifs->length(); i++) {
3883 klassOop l = klassOop(local_ifs->obj_at(i));
3884 append_interfaces(result, index, instanceKlass::cast(l)->transitive_interfaces());
3885 }
3886 // Finally add local interfaces
3887 append_interfaces(result, index, local_ifs());
3889 // Check if duplicates were removed
3890 if (index != max_transitive_size) {
3891 assert(index < max_transitive_size, "just checking");
3892 objArrayOop new_result = oopFactory::new_system_objArray(index, CHECK_(nullHandle));
3893 for (int i = 0; i < index; i++) {
3894 oop e = result->obj_at(i);
3895 assert(e != NULL, "just checking");
3896 new_result->obj_at_put(i, e);
3897 }
3898 result = objArrayHandle(THREAD, new_result);
3899 }
3900 }
3901 return result;
3902 }
3905 void ClassFileParser::check_super_class_access(instanceKlassHandle this_klass, TRAPS) {
3906 klassOop super = this_klass->super();
3907 if ((super != NULL) &&
3908 (!Reflection::verify_class_access(this_klass->as_klassOop(), super, false))) {
3909 ResourceMark rm(THREAD);
3910 Exceptions::fthrow(
3911 THREAD_AND_LOCATION,
3912 vmSymbolHandles::java_lang_IllegalAccessError(),
3913 "class %s cannot access its superclass %s",
3914 this_klass->external_name(),
3915 instanceKlass::cast(super)->external_name()
3916 );
3917 return;
3918 }
3919 }
3922 void ClassFileParser::check_super_interface_access(instanceKlassHandle this_klass, TRAPS) {
3923 objArrayHandle local_interfaces (THREAD, this_klass->local_interfaces());
3924 int lng = local_interfaces->length();
3925 for (int i = lng - 1; i >= 0; i--) {
3926 klassOop k = klassOop(local_interfaces->obj_at(i));
3927 assert (k != NULL && Klass::cast(k)->is_interface(), "invalid interface");
3928 if (!Reflection::verify_class_access(this_klass->as_klassOop(), k, false)) {
3929 ResourceMark rm(THREAD);
3930 Exceptions::fthrow(
3931 THREAD_AND_LOCATION,
3932 vmSymbolHandles::java_lang_IllegalAccessError(),
3933 "class %s cannot access its superinterface %s",
3934 this_klass->external_name(),
3935 instanceKlass::cast(k)->external_name()
3936 );
3937 return;
3938 }
3939 }
3940 }
3943 void ClassFileParser::check_final_method_override(instanceKlassHandle this_klass, TRAPS) {
3944 objArrayHandle methods (THREAD, this_klass->methods());
3945 int num_methods = methods->length();
3947 // go thru each method and check if it overrides a final method
3948 for (int index = 0; index < num_methods; index++) {
3949 methodOop m = (methodOop)methods->obj_at(index);
3951 // skip private, static and <init> methods
3952 if ((!m->is_private()) &&
3953 (!m->is_static()) &&
3954 (m->name() != vmSymbols::object_initializer_name())) {
3956 symbolOop name = m->name();
3957 symbolOop signature = m->signature();
3958 klassOop k = this_klass->super();
3959 methodOop super_m = NULL;
3960 while (k != NULL) {
3961 // skip supers that don't have final methods.
3962 if (k->klass_part()->has_final_method()) {
3963 // lookup a matching method in the super class hierarchy
3964 super_m = instanceKlass::cast(k)->lookup_method(name, signature);
3965 if (super_m == NULL) {
3966 break; // didn't find any match; get out
3967 }
3969 if (super_m->is_final() &&
3970 // matching method in super is final
3971 (Reflection::verify_field_access(this_klass->as_klassOop(),
3972 super_m->method_holder(),
3973 super_m->method_holder(),
3974 super_m->access_flags(), false))
3975 // this class can access super final method and therefore override
3976 ) {
3977 ResourceMark rm(THREAD);
3978 Exceptions::fthrow(
3979 THREAD_AND_LOCATION,
3980 vmSymbolHandles::java_lang_VerifyError(),
3981 "class %s overrides final method %s.%s",
3982 this_klass->external_name(),
3983 name->as_C_string(),
3984 signature->as_C_string()
3985 );
3986 return;
3987 }
3989 // continue to look from super_m's holder's super.
3990 k = instanceKlass::cast(super_m->method_holder())->super();
3991 continue;
3992 }
3994 k = k->klass_part()->super();
3995 }
3996 }
3997 }
3998 }
4001 // assumes that this_klass is an interface
4002 void ClassFileParser::check_illegal_static_method(instanceKlassHandle this_klass, TRAPS) {
4003 assert(this_klass->is_interface(), "not an interface");
4004 objArrayHandle methods (THREAD, this_klass->methods());
4005 int num_methods = methods->length();
4007 for (int index = 0; index < num_methods; index++) {
4008 methodOop m = (methodOop)methods->obj_at(index);
4009 // if m is static and not the init method, throw a verify error
4010 if ((m->is_static()) && (m->name() != vmSymbols::class_initializer_name())) {
4011 ResourceMark rm(THREAD);
4012 Exceptions::fthrow(
4013 THREAD_AND_LOCATION,
4014 vmSymbolHandles::java_lang_VerifyError(),
4015 "Illegal static method %s in interface %s",
4016 m->name()->as_C_string(),
4017 this_klass->external_name()
4018 );
4019 return;
4020 }
4021 }
4022 }
4024 // utility methods for format checking
4026 void ClassFileParser::verify_legal_class_modifiers(jint flags, TRAPS) {
4027 if (!_need_verify) { return; }
4029 const bool is_interface = (flags & JVM_ACC_INTERFACE) != 0;
4030 const bool is_abstract = (flags & JVM_ACC_ABSTRACT) != 0;
4031 const bool is_final = (flags & JVM_ACC_FINAL) != 0;
4032 const bool is_super = (flags & JVM_ACC_SUPER) != 0;
4033 const bool is_enum = (flags & JVM_ACC_ENUM) != 0;
4034 const bool is_annotation = (flags & JVM_ACC_ANNOTATION) != 0;
4035 const bool major_gte_15 = _major_version >= JAVA_1_5_VERSION;
4037 if ((is_abstract && is_final) ||
4038 (is_interface && !is_abstract) ||
4039 (is_interface && major_gte_15 && (is_super || is_enum)) ||
4040 (!is_interface && major_gte_15 && is_annotation)) {
4041 ResourceMark rm(THREAD);
4042 Exceptions::fthrow(
4043 THREAD_AND_LOCATION,
4044 vmSymbolHandles::java_lang_ClassFormatError(),
4045 "Illegal class modifiers in class %s: 0x%X",
4046 _class_name->as_C_string(), flags
4047 );
4048 return;
4049 }
4050 }
4052 bool ClassFileParser::has_illegal_visibility(jint flags) {
4053 const bool is_public = (flags & JVM_ACC_PUBLIC) != 0;
4054 const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0;
4055 const bool is_private = (flags & JVM_ACC_PRIVATE) != 0;
4057 return ((is_public && is_protected) ||
4058 (is_public && is_private) ||
4059 (is_protected && is_private));
4060 }
4062 bool ClassFileParser::is_supported_version(u2 major, u2 minor) {
4063 u2 max_version =
4064 JDK_Version::is_gte_jdk17x_version() ? JAVA_MAX_SUPPORTED_VERSION :
4065 (JDK_Version::is_gte_jdk16x_version() ? JAVA_6_VERSION : JAVA_1_5_VERSION);
4066 return (major >= JAVA_MIN_SUPPORTED_VERSION) &&
4067 (major <= max_version) &&
4068 ((major != max_version) ||
4069 (minor <= JAVA_MAX_SUPPORTED_MINOR_VERSION));
4070 }
4072 void ClassFileParser::verify_legal_field_modifiers(
4073 jint flags, bool is_interface, TRAPS) {
4074 if (!_need_verify) { return; }
4076 const bool is_public = (flags & JVM_ACC_PUBLIC) != 0;
4077 const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0;
4078 const bool is_private = (flags & JVM_ACC_PRIVATE) != 0;
4079 const bool is_static = (flags & JVM_ACC_STATIC) != 0;
4080 const bool is_final = (flags & JVM_ACC_FINAL) != 0;
4081 const bool is_volatile = (flags & JVM_ACC_VOLATILE) != 0;
4082 const bool is_transient = (flags & JVM_ACC_TRANSIENT) != 0;
4083 const bool is_enum = (flags & JVM_ACC_ENUM) != 0;
4084 const bool major_gte_15 = _major_version >= JAVA_1_5_VERSION;
4086 bool is_illegal = false;
4088 if (is_interface) {
4089 if (!is_public || !is_static || !is_final || is_private ||
4090 is_protected || is_volatile || is_transient ||
4091 (major_gte_15 && is_enum)) {
4092 is_illegal = true;
4093 }
4094 } else { // not interface
4095 if (has_illegal_visibility(flags) || (is_final && is_volatile)) {
4096 is_illegal = true;
4097 }
4098 }
4100 if (is_illegal) {
4101 ResourceMark rm(THREAD);
4102 Exceptions::fthrow(
4103 THREAD_AND_LOCATION,
4104 vmSymbolHandles::java_lang_ClassFormatError(),
4105 "Illegal field modifiers in class %s: 0x%X",
4106 _class_name->as_C_string(), flags);
4107 return;
4108 }
4109 }
4111 void ClassFileParser::verify_legal_method_modifiers(
4112 jint flags, bool is_interface, symbolHandle name, TRAPS) {
4113 if (!_need_verify) { return; }
4115 const bool is_public = (flags & JVM_ACC_PUBLIC) != 0;
4116 const bool is_private = (flags & JVM_ACC_PRIVATE) != 0;
4117 const bool is_static = (flags & JVM_ACC_STATIC) != 0;
4118 const bool is_final = (flags & JVM_ACC_FINAL) != 0;
4119 const bool is_native = (flags & JVM_ACC_NATIVE) != 0;
4120 const bool is_abstract = (flags & JVM_ACC_ABSTRACT) != 0;
4121 const bool is_bridge = (flags & JVM_ACC_BRIDGE) != 0;
4122 const bool is_strict = (flags & JVM_ACC_STRICT) != 0;
4123 const bool is_synchronized = (flags & JVM_ACC_SYNCHRONIZED) != 0;
4124 const bool major_gte_15 = _major_version >= JAVA_1_5_VERSION;
4125 const bool is_initializer = (name == vmSymbols::object_initializer_name());
4127 bool is_illegal = false;
4129 if (is_interface) {
4130 if (!is_abstract || !is_public || is_static || is_final ||
4131 is_native || (major_gte_15 && (is_synchronized || is_strict))) {
4132 is_illegal = true;
4133 }
4134 } else { // not interface
4135 if (is_initializer) {
4136 if (is_static || is_final || is_synchronized || is_native ||
4137 is_abstract || (major_gte_15 && is_bridge)) {
4138 is_illegal = true;
4139 }
4140 } else { // not initializer
4141 if (is_abstract) {
4142 if ((is_final || is_native || is_private || is_static ||
4143 (major_gte_15 && (is_synchronized || is_strict)))) {
4144 is_illegal = true;
4145 }
4146 }
4147 if (has_illegal_visibility(flags)) {
4148 is_illegal = true;
4149 }
4150 }
4151 }
4153 if (is_illegal) {
4154 ResourceMark rm(THREAD);
4155 Exceptions::fthrow(
4156 THREAD_AND_LOCATION,
4157 vmSymbolHandles::java_lang_ClassFormatError(),
4158 "Method %s in class %s has illegal modifiers: 0x%X",
4159 name->as_C_string(), _class_name->as_C_string(), flags);
4160 return;
4161 }
4162 }
4164 void ClassFileParser::verify_legal_utf8(const unsigned char* buffer, int length, TRAPS) {
4165 assert(_need_verify, "only called when _need_verify is true");
4166 int i = 0;
4167 int count = length >> 2;
4168 for (int k=0; k<count; k++) {
4169 unsigned char b0 = buffer[i];
4170 unsigned char b1 = buffer[i+1];
4171 unsigned char b2 = buffer[i+2];
4172 unsigned char b3 = buffer[i+3];
4173 // For an unsigned char v,
4174 // (v | v - 1) is < 128 (highest bit 0) for 0 < v < 128;
4175 // (v | v - 1) is >= 128 (highest bit 1) for v == 0 or v >= 128.
4176 unsigned char res = b0 | b0 - 1 |
4177 b1 | b1 - 1 |
4178 b2 | b2 - 1 |
4179 b3 | b3 - 1;
4180 if (res >= 128) break;
4181 i += 4;
4182 }
4183 for(; i < length; i++) {
4184 unsigned short c;
4185 // no embedded zeros
4186 guarantee_property((buffer[i] != 0), "Illegal UTF8 string in constant pool in class file %s", CHECK);
4187 if(buffer[i] < 128) {
4188 continue;
4189 }
4190 if ((i + 5) < length) { // see if it's legal supplementary character
4191 if (UTF8::is_supplementary_character(&buffer[i])) {
4192 c = UTF8::get_supplementary_character(&buffer[i]);
4193 i += 5;
4194 continue;
4195 }
4196 }
4197 switch (buffer[i] >> 4) {
4198 default: break;
4199 case 0x8: case 0x9: case 0xA: case 0xB: case 0xF:
4200 classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", CHECK);
4201 case 0xC: case 0xD: // 110xxxxx 10xxxxxx
4202 c = (buffer[i] & 0x1F) << 6;
4203 i++;
4204 if ((i < length) && ((buffer[i] & 0xC0) == 0x80)) {
4205 c += buffer[i] & 0x3F;
4206 if (_major_version <= 47 || c == 0 || c >= 0x80) {
4207 // for classes with major > 47, c must a null or a character in its shortest form
4208 break;
4209 }
4210 }
4211 classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", CHECK);
4212 case 0xE: // 1110xxxx 10xxxxxx 10xxxxxx
4213 c = (buffer[i] & 0xF) << 12;
4214 i += 2;
4215 if ((i < length) && ((buffer[i-1] & 0xC0) == 0x80) && ((buffer[i] & 0xC0) == 0x80)) {
4216 c += ((buffer[i-1] & 0x3F) << 6) + (buffer[i] & 0x3F);
4217 if (_major_version <= 47 || c >= 0x800) {
4218 // for classes with major > 47, c must be in its shortest form
4219 break;
4220 }
4221 }
4222 classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", CHECK);
4223 } // end of switch
4224 } // end of for
4225 }
4227 // Checks if name is a legal class name.
4228 void ClassFileParser::verify_legal_class_name(symbolHandle name, TRAPS) {
4229 if (!_need_verify || _relax_verify) { return; }
4231 char buf[fixed_buffer_size];
4232 char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
4233 unsigned int length = name->utf8_length();
4234 bool legal = false;
4236 if (length > 0) {
4237 char* p;
4238 if (bytes[0] == JVM_SIGNATURE_ARRAY) {
4239 p = skip_over_field_signature(bytes, false, length, CHECK);
4240 legal = (p != NULL) && ((p - bytes) == (int)length);
4241 } else if (_major_version < JAVA_1_5_VERSION) {
4242 if (bytes[0] != '<') {
4243 p = skip_over_field_name(bytes, true, length);
4244 legal = (p != NULL) && ((p - bytes) == (int)length);
4245 }
4246 } else {
4247 // 4900761: relax the constraints based on JSR202 spec
4248 // Class names may be drawn from the entire Unicode character set.
4249 // Identifiers between '/' must be unqualified names.
4250 // The utf8 string has been verified when parsing cpool entries.
4251 legal = verify_unqualified_name(bytes, length, LegalClass);
4252 }
4253 }
4254 if (!legal) {
4255 ResourceMark rm(THREAD);
4256 Exceptions::fthrow(
4257 THREAD_AND_LOCATION,
4258 vmSymbolHandles::java_lang_ClassFormatError(),
4259 "Illegal class name \"%s\" in class file %s", bytes,
4260 _class_name->as_C_string()
4261 );
4262 return;
4263 }
4264 }
4266 // Checks if name is a legal field name.
4267 void ClassFileParser::verify_legal_field_name(symbolHandle name, TRAPS) {
4268 if (!_need_verify || _relax_verify) { return; }
4270 char buf[fixed_buffer_size];
4271 char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
4272 unsigned int length = name->utf8_length();
4273 bool legal = false;
4275 if (length > 0) {
4276 if (_major_version < JAVA_1_5_VERSION) {
4277 if (bytes[0] != '<') {
4278 char* p = skip_over_field_name(bytes, false, length);
4279 legal = (p != NULL) && ((p - bytes) == (int)length);
4280 }
4281 } else {
4282 // 4881221: relax the constraints based on JSR202 spec
4283 legal = verify_unqualified_name(bytes, length, LegalField);
4284 }
4285 }
4287 if (!legal) {
4288 ResourceMark rm(THREAD);
4289 Exceptions::fthrow(
4290 THREAD_AND_LOCATION,
4291 vmSymbolHandles::java_lang_ClassFormatError(),
4292 "Illegal field name \"%s\" in class %s", bytes,
4293 _class_name->as_C_string()
4294 );
4295 return;
4296 }
4297 }
4299 // Checks if name is a legal method name.
4300 void ClassFileParser::verify_legal_method_name(symbolHandle name, TRAPS) {
4301 if (!_need_verify || _relax_verify) { return; }
4303 assert(!name.is_null(), "method name is null");
4304 char buf[fixed_buffer_size];
4305 char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
4306 unsigned int length = name->utf8_length();
4307 bool legal = false;
4309 if (length > 0) {
4310 if (bytes[0] == '<') {
4311 if (name == vmSymbols::object_initializer_name() || name == vmSymbols::class_initializer_name()) {
4312 legal = true;
4313 }
4314 } else if (_major_version < JAVA_1_5_VERSION) {
4315 char* p;
4316 p = skip_over_field_name(bytes, false, length);
4317 legal = (p != NULL) && ((p - bytes) == (int)length);
4318 } else {
4319 // 4881221: relax the constraints based on JSR202 spec
4320 legal = verify_unqualified_name(bytes, length, LegalMethod);
4321 }
4322 }
4324 if (!legal) {
4325 ResourceMark rm(THREAD);
4326 Exceptions::fthrow(
4327 THREAD_AND_LOCATION,
4328 vmSymbolHandles::java_lang_ClassFormatError(),
4329 "Illegal method name \"%s\" in class %s", bytes,
4330 _class_name->as_C_string()
4331 );
4332 return;
4333 }
4334 }
4337 // Checks if signature is a legal field signature.
4338 void ClassFileParser::verify_legal_field_signature(symbolHandle name, symbolHandle signature, TRAPS) {
4339 if (!_need_verify) { return; }
4341 char buf[fixed_buffer_size];
4342 char* bytes = signature->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
4343 unsigned int length = signature->utf8_length();
4344 char* p = skip_over_field_signature(bytes, false, length, CHECK);
4346 if (p == NULL || (p - bytes) != (int)length) {
4347 throwIllegalSignature("Field", name, signature, CHECK);
4348 }
4349 }
4351 // Checks if signature is a legal method signature.
4352 // Returns number of parameters
4353 int ClassFileParser::verify_legal_method_signature(symbolHandle name, symbolHandle signature, TRAPS) {
4354 if (!_need_verify) {
4355 // make sure caller's args_size will be less than 0 even for non-static
4356 // method so it will be recomputed in compute_size_of_parameters().
4357 return -2;
4358 }
4360 unsigned int args_size = 0;
4361 char buf[fixed_buffer_size];
4362 char* p = signature->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
4363 unsigned int length = signature->utf8_length();
4364 char* nextp;
4366 // The first character must be a '('
4367 if ((length > 0) && (*p++ == JVM_SIGNATURE_FUNC)) {
4368 length--;
4369 // Skip over legal field signatures
4370 nextp = skip_over_field_signature(p, false, length, CHECK_0);
4371 while ((length > 0) && (nextp != NULL)) {
4372 args_size++;
4373 if (p[0] == 'J' || p[0] == 'D') {
4374 args_size++;
4375 }
4376 length -= nextp - p;
4377 p = nextp;
4378 nextp = skip_over_field_signature(p, false, length, CHECK_0);
4379 }
4380 // The first non-signature thing better be a ')'
4381 if ((length > 0) && (*p++ == JVM_SIGNATURE_ENDFUNC)) {
4382 length--;
4383 if (name->utf8_length() > 0 && name->byte_at(0) == '<') {
4384 // All internal methods must return void
4385 if ((length == 1) && (p[0] == JVM_SIGNATURE_VOID)) {
4386 return args_size;
4387 }
4388 } else {
4389 // Now we better just have a return value
4390 nextp = skip_over_field_signature(p, true, length, CHECK_0);
4391 if (nextp && ((int)length == (nextp - p))) {
4392 return args_size;
4393 }
4394 }
4395 }
4396 }
4397 // Report error
4398 throwIllegalSignature("Method", name, signature, CHECK_0);
4399 return 0;
4400 }
4403 // Unqualified names may not contain the characters '.', ';', or '/'.
4404 // Method names also may not contain the characters '<' or '>', unless <init> or <clinit>.
4405 // Note that method names may not be <init> or <clinit> in this method.
4406 // Because these names have been checked as special cases before calling this method
4407 // in verify_legal_method_name.
4408 bool ClassFileParser::verify_unqualified_name(char* name, unsigned int length, int type) {
4409 jchar ch;
4411 for (char* p = name; p != name + length; ) {
4412 ch = *p;
4413 if (ch < 128) {
4414 p++;
4415 if (ch == '.' || ch == ';') {
4416 return false; // do not permit '.' or ';'
4417 }
4418 if (type != LegalClass && ch == '/') {
4419 return false; // do not permit '/' unless it's class name
4420 }
4421 if (type == LegalMethod && (ch == '<' || ch == '>')) {
4422 return false; // do not permit '<' or '>' in method names
4423 }
4424 } else {
4425 char* tmp_p = UTF8::next(p, &ch);
4426 p = tmp_p;
4427 }
4428 }
4429 return true;
4430 }
4433 // Take pointer to a string. Skip over the longest part of the string that could
4434 // be taken as a fieldname. Allow '/' if slash_ok is true.
4435 // Return a pointer to just past the fieldname.
4436 // Return NULL if no fieldname at all was found, or in the case of slash_ok
4437 // being true, we saw consecutive slashes (meaning we were looking for a
4438 // qualified path but found something that was badly-formed).
4439 char* ClassFileParser::skip_over_field_name(char* name, bool slash_ok, unsigned int length) {
4440 char* p;
4441 jchar ch;
4442 jboolean last_is_slash = false;
4443 jboolean not_first_ch = false;
4445 for (p = name; p != name + length; not_first_ch = true) {
4446 char* old_p = p;
4447 ch = *p;
4448 if (ch < 128) {
4449 p++;
4450 // quick check for ascii
4451 if ((ch >= 'a' && ch <= 'z') ||
4452 (ch >= 'A' && ch <= 'Z') ||
4453 (ch == '_' || ch == '$') ||
4454 (not_first_ch && ch >= '0' && ch <= '9')) {
4455 last_is_slash = false;
4456 continue;
4457 }
4458 if (slash_ok && ch == '/') {
4459 if (last_is_slash) {
4460 return NULL; // Don't permit consecutive slashes
4461 }
4462 last_is_slash = true;
4463 continue;
4464 }
4465 } else {
4466 jint unicode_ch;
4467 char* tmp_p = UTF8::next_character(p, &unicode_ch);
4468 p = tmp_p;
4469 last_is_slash = false;
4470 // Check if ch is Java identifier start or is Java identifier part
4471 // 4672820: call java.lang.Character methods directly without generating separate tables.
4472 EXCEPTION_MARK;
4473 instanceKlassHandle klass (THREAD, SystemDictionary::Character_klass());
4475 // return value
4476 JavaValue result(T_BOOLEAN);
4477 // Set up the arguments to isJavaIdentifierStart and isJavaIdentifierPart
4478 JavaCallArguments args;
4479 args.push_int(unicode_ch);
4481 // public static boolean isJavaIdentifierStart(char ch);
4482 JavaCalls::call_static(&result,
4483 klass,
4484 vmSymbolHandles::isJavaIdentifierStart_name(),
4485 vmSymbolHandles::int_bool_signature(),
4486 &args,
4487 THREAD);
4489 if (HAS_PENDING_EXCEPTION) {
4490 CLEAR_PENDING_EXCEPTION;
4491 return 0;
4492 }
4493 if (result.get_jboolean()) {
4494 continue;
4495 }
4497 if (not_first_ch) {
4498 // public static boolean isJavaIdentifierPart(char ch);
4499 JavaCalls::call_static(&result,
4500 klass,
4501 vmSymbolHandles::isJavaIdentifierPart_name(),
4502 vmSymbolHandles::int_bool_signature(),
4503 &args,
4504 THREAD);
4506 if (HAS_PENDING_EXCEPTION) {
4507 CLEAR_PENDING_EXCEPTION;
4508 return 0;
4509 }
4511 if (result.get_jboolean()) {
4512 continue;
4513 }
4514 }
4515 }
4516 return (not_first_ch) ? old_p : NULL;
4517 }
4518 return (not_first_ch) ? p : NULL;
4519 }
4522 // Take pointer to a string. Skip over the longest part of the string that could
4523 // be taken as a field signature. Allow "void" if void_ok.
4524 // Return a pointer to just past the signature.
4525 // Return NULL if no legal signature is found.
4526 char* ClassFileParser::skip_over_field_signature(char* signature,
4527 bool void_ok,
4528 unsigned int length,
4529 TRAPS) {
4530 unsigned int array_dim = 0;
4531 while (length > 0) {
4532 switch (signature[0]) {
4533 case JVM_SIGNATURE_VOID: if (!void_ok) { return NULL; }
4534 case JVM_SIGNATURE_BOOLEAN:
4535 case JVM_SIGNATURE_BYTE:
4536 case JVM_SIGNATURE_CHAR:
4537 case JVM_SIGNATURE_SHORT:
4538 case JVM_SIGNATURE_INT:
4539 case JVM_SIGNATURE_FLOAT:
4540 case JVM_SIGNATURE_LONG:
4541 case JVM_SIGNATURE_DOUBLE:
4542 return signature + 1;
4543 case JVM_SIGNATURE_CLASS: {
4544 if (_major_version < JAVA_1_5_VERSION) {
4545 // Skip over the class name if one is there
4546 char* p = skip_over_field_name(signature + 1, true, --length);
4548 // The next character better be a semicolon
4549 if (p && (p - signature) > 1 && p[0] == ';') {
4550 return p + 1;
4551 }
4552 } else {
4553 // 4900761: For class version > 48, any unicode is allowed in class name.
4554 length--;
4555 signature++;
4556 while (length > 0 && signature[0] != ';') {
4557 if (signature[0] == '.') {
4558 classfile_parse_error("Class name contains illegal character '.' in descriptor in class file %s", CHECK_0);
4559 }
4560 length--;
4561 signature++;
4562 }
4563 if (signature[0] == ';') { return signature + 1; }
4564 }
4566 return NULL;
4567 }
4568 case JVM_SIGNATURE_ARRAY:
4569 array_dim++;
4570 if (array_dim > 255) {
4571 // 4277370: array descriptor is valid only if it represents 255 or fewer dimensions.
4572 classfile_parse_error("Array type descriptor has more than 255 dimensions in class file %s", CHECK_0);
4573 }
4574 // The rest of what's there better be a legal signature
4575 signature++;
4576 length--;
4577 void_ok = false;
4578 break;
4580 default:
4581 return NULL;
4582 }
4583 }
4584 return NULL;
4585 }