113 case JVM_CONSTANT_String : |
113 case JVM_CONSTANT_String : |
114 { |
114 { |
115 cfs->guarantee_more(3, CHECK); // string_index, tag/access_flags |
115 cfs->guarantee_more(3, CHECK); // string_index, tag/access_flags |
116 u2 string_index = cfs->get_u2_fast(); |
116 u2 string_index = cfs->get_u2_fast(); |
117 cp->string_index_at_put(index, string_index); |
117 cp->string_index_at_put(index, string_index); |
|
118 } |
|
119 break; |
|
120 case JVM_CONSTANT_MethodHandle : |
|
121 case JVM_CONSTANT_MethodType : |
|
122 if (!EnableMethodHandles || |
|
123 _major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) { |
|
124 classfile_parse_error( |
|
125 (!EnableInvokeDynamic ? |
|
126 "This JVM does not support constant tag %u in class file %s" : |
|
127 "Class file version does not support constant tag %u in class file %s"), |
|
128 tag, CHECK); |
|
129 } |
|
130 if (tag == JVM_CONSTANT_MethodHandle) { |
|
131 cfs->guarantee_more(4, CHECK); // ref_kind, method_index, tag/access_flags |
|
132 u1 ref_kind = cfs->get_u1_fast(); |
|
133 u2 method_index = cfs->get_u2_fast(); |
|
134 cp->method_handle_index_at_put(index, ref_kind, method_index); |
|
135 } else if (tag == JVM_CONSTANT_MethodType) { |
|
136 cfs->guarantee_more(3, CHECK); // signature_index, tag/access_flags |
|
137 u2 signature_index = cfs->get_u2_fast(); |
|
138 cp->method_type_index_at_put(index, signature_index); |
|
139 } else { |
|
140 ShouldNotReachHere(); |
118 } |
141 } |
119 break; |
142 break; |
120 case JVM_CONSTANT_Integer : |
143 case JVM_CONSTANT_Integer : |
121 { |
144 { |
122 cfs->guarantee_more(5, CHECK); // bytes, tag/access_flags |
145 cfs->guarantee_more(5, CHECK); // bytes, tag/access_flags |
333 cp->tag_at(string_index).is_utf8(), |
356 cp->tag_at(string_index).is_utf8(), |
334 "Invalid constant pool index %u in class file %s", |
357 "Invalid constant pool index %u in class file %s", |
335 string_index, CHECK_(nullHandle)); |
358 string_index, CHECK_(nullHandle)); |
336 symbolOop sym = cp->symbol_at(string_index); |
359 symbolOop sym = cp->symbol_at(string_index); |
337 cp->unresolved_string_at_put(index, sym); |
360 cp->unresolved_string_at_put(index, sym); |
|
361 } |
|
362 break; |
|
363 case JVM_CONSTANT_MethodHandle : |
|
364 { |
|
365 int ref_index = cp->method_handle_index_at(index); |
|
366 check_property( |
|
367 valid_cp_range(ref_index, length) && |
|
368 EnableMethodHandles, |
|
369 "Invalid constant pool index %u in class file %s", |
|
370 ref_index, CHECK_(nullHandle)); |
|
371 constantTag tag = cp->tag_at(ref_index); |
|
372 int ref_kind = cp->method_handle_ref_kind_at(index); |
|
373 switch (ref_kind) { |
|
374 case JVM_REF_getField: |
|
375 case JVM_REF_getStatic: |
|
376 case JVM_REF_putField: |
|
377 case JVM_REF_putStatic: |
|
378 check_property( |
|
379 tag.is_field(), |
|
380 "Invalid constant pool index %u in class file %s (not a field)", |
|
381 ref_index, CHECK_(nullHandle)); |
|
382 break; |
|
383 case JVM_REF_invokeVirtual: |
|
384 case JVM_REF_invokeStatic: |
|
385 case JVM_REF_invokeSpecial: |
|
386 case JVM_REF_newInvokeSpecial: |
|
387 check_property( |
|
388 tag.is_method(), |
|
389 "Invalid constant pool index %u in class file %s (not a method)", |
|
390 ref_index, CHECK_(nullHandle)); |
|
391 break; |
|
392 case JVM_REF_invokeInterface: |
|
393 check_property( |
|
394 tag.is_interface_method(), |
|
395 "Invalid constant pool index %u in class file %s (not an interface method)", |
|
396 ref_index, CHECK_(nullHandle)); |
|
397 break; |
|
398 default: |
|
399 classfile_parse_error( |
|
400 "Bad method handle kind at constant pool index %u in class file %s", |
|
401 index, CHECK_(nullHandle)); |
|
402 } |
|
403 // Keep the ref_index unchanged. It will be indirected at link-time. |
|
404 } |
|
405 break; |
|
406 case JVM_CONSTANT_MethodType : |
|
407 { |
|
408 int ref_index = cp->method_type_index_at(index); |
|
409 check_property( |
|
410 valid_cp_range(ref_index, length) && |
|
411 cp->tag_at(ref_index).is_utf8() && |
|
412 EnableMethodHandles, |
|
413 "Invalid constant pool index %u in class file %s", |
|
414 ref_index, CHECK_(nullHandle)); |
338 } |
415 } |
339 break; |
416 break; |
340 default: |
417 default: |
341 fatal(err_msg("bad constant pool tag value %u", |
418 fatal(err_msg("bad constant pool tag value %u", |
342 cp->tag_at(index).value())); |
419 cp->tag_at(index).value())); |
450 } |
527 } |
451 } |
528 } |
452 } |
529 } |
453 break; |
530 break; |
454 } |
531 } |
|
532 case JVM_CONSTANT_MethodHandle: { |
|
533 int ref_index = cp->method_handle_index_at(index); |
|
534 int ref_kind = cp->method_handle_ref_kind_at(index); |
|
535 switch (ref_kind) { |
|
536 case JVM_REF_invokeVirtual: |
|
537 case JVM_REF_invokeStatic: |
|
538 case JVM_REF_invokeSpecial: |
|
539 case JVM_REF_newInvokeSpecial: |
|
540 { |
|
541 int name_and_type_ref_index = cp->name_and_type_ref_index_at(ref_index); |
|
542 int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index); |
|
543 symbolHandle name(THREAD, cp->symbol_at(name_ref_index)); |
|
544 if (ref_kind == JVM_REF_newInvokeSpecial) { |
|
545 if (name() != vmSymbols::object_initializer_name()) { |
|
546 classfile_parse_error( |
|
547 "Bad constructor name at constant pool index %u in class file %s", |
|
548 name_ref_index, CHECK_(nullHandle)); |
|
549 } |
|
550 } else { |
|
551 if (name() == vmSymbols::object_initializer_name()) { |
|
552 classfile_parse_error( |
|
553 "Bad method name at constant pool index %u in class file %s", |
|
554 name_ref_index, CHECK_(nullHandle)); |
|
555 } |
|
556 } |
|
557 } |
|
558 break; |
|
559 // Other ref_kinds are already fully checked in previous pass. |
|
560 } |
|
561 break; |
|
562 } |
|
563 case JVM_CONSTANT_MethodType: { |
|
564 symbolHandle no_name = vmSymbolHandles::type_name(); // place holder |
|
565 symbolHandle signature(THREAD, cp->method_type_signature_at(index)); |
|
566 verify_legal_method_signature(no_name, signature, CHECK_(nullHandle)); |
|
567 break; |
|
568 } |
455 } // end of switch |
569 } // end of switch |
456 } // end of for |
570 } // end of for |
457 |
571 |
458 return cp; |
572 return cp; |
459 } |
573 } |
465 switch (cp->tag_at(index).value()) { |
579 switch (cp->tag_at(index).value()) { |
466 |
580 |
467 case JVM_CONSTANT_UnresolvedClass : |
581 case JVM_CONSTANT_UnresolvedClass : |
468 // Patching a class means pre-resolving it. |
582 // Patching a class means pre-resolving it. |
469 // The name in the constant pool is ignored. |
583 // The name in the constant pool is ignored. |
470 if (patch->klass() == SystemDictionary::Class_klass()) { // %%% java_lang_Class::is_instance |
584 if (java_lang_Class::is_instance(patch())) { |
471 guarantee_property(!java_lang_Class::is_primitive(patch()), |
585 guarantee_property(!java_lang_Class::is_primitive(patch()), |
472 "Illegal class patch at %d in class file %s", |
586 "Illegal class patch at %d in class file %s", |
473 index, CHECK); |
587 index, CHECK); |
474 cp->klass_at_put(index, java_lang_Class::as_klassOop(patch())); |
588 cp->klass_at_put(index, java_lang_Class::as_klassOop(patch())); |
475 } else { |
589 } else { |