Skip to content

Commit 88fc3bf

Browse files
author
Vladimir Ivanov
committedFeb 14, 2022
8280473: CI: Support unresolved JVM_CONSTANT_Dynamic constant pool entries
Reviewed-by: dlong, redestad, neliasso
1 parent f07b816 commit 88fc3bf

12 files changed

+417
-102
lines changed
 

‎src/hotspot/share/c1/c1_GraphBuilder.cpp

+40-25
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@
3434
#include "ci/ciMemberName.hpp"
3535
#include "ci/ciSymbols.hpp"
3636
#include "ci/ciUtilities.inline.hpp"
37+
#include "classfile/javaClasses.hpp"
3738
#include "compiler/compilationPolicy.hpp"
3839
#include "compiler/compileBroker.hpp"
3940
#include "compiler/compilerEvent.hpp"
@@ -916,53 +917,67 @@ void GraphBuilder::ScopeData::incr_num_returns() {
916917

917918
void GraphBuilder::load_constant() {
918919
ciConstant con = stream()->get_constant();
919-
if (con.basic_type() == T_ILLEGAL) {
920-
// FIXME: an unresolved Dynamic constant can get here,
921-
// and that should not terminate the whole compilation.
922-
BAILOUT("could not resolve a constant");
923-
} else {
920+
if (con.is_valid()) {
924921
ValueType* t = illegalType;
925922
ValueStack* patch_state = NULL;
926923
switch (con.basic_type()) {
927-
case T_BOOLEAN: t = new IntConstant (con.as_boolean()); break;
928-
case T_BYTE : t = new IntConstant (con.as_byte ()); break;
929-
case T_CHAR : t = new IntConstant (con.as_char ()); break;
930-
case T_SHORT : t = new IntConstant (con.as_short ()); break;
931-
case T_INT : t = new IntConstant (con.as_int ()); break;
932-
case T_LONG : t = new LongConstant (con.as_long ()); break;
933-
case T_FLOAT : t = new FloatConstant (con.as_float ()); break;
934-
case T_DOUBLE : t = new DoubleConstant (con.as_double ()); break;
935-
case T_ARRAY : t = new ArrayConstant (con.as_object ()->as_array ()); break;
936-
case T_OBJECT :
937-
{
924+
case T_BOOLEAN: t = new IntConstant (con.as_boolean()); break;
925+
case T_BYTE : t = new IntConstant (con.as_byte ()); break;
926+
case T_CHAR : t = new IntConstant (con.as_char ()); break;
927+
case T_SHORT : t = new IntConstant (con.as_short ()); break;
928+
case T_INT : t = new IntConstant (con.as_int ()); break;
929+
case T_LONG : t = new LongConstant (con.as_long ()); break;
930+
case T_FLOAT : t = new FloatConstant (con.as_float ()); break;
931+
case T_DOUBLE : t = new DoubleConstant(con.as_double ()); break;
932+
case T_ARRAY : // fall-through
933+
case T_OBJECT : {
938934
ciObject* obj = con.as_object();
939-
if (!obj->is_loaded()
940-
|| (PatchALot && obj->klass() != ciEnv::current()->String_klass())) {
941-
// A Class, MethodType, MethodHandle, or String.
942-
// Unloaded condy nodes show up as T_ILLEGAL, above.
935+
if (!obj->is_loaded() || (PatchALot && (obj->is_null_object() || obj->klass() != ciEnv::current()->String_klass()))) {
936+
// A Class, MethodType, MethodHandle, Dynamic, or String.
943937
patch_state = copy_state_before();
944938
t = new ObjectConstant(obj);
945939
} else {
946940
// Might be a Class, MethodType, MethodHandle, or Dynamic constant
947941
// result, which might turn out to be an array.
948-
if (obj->is_null_object())
942+
if (obj->is_null_object()) {
949943
t = objectNull;
950-
else if (obj->is_array())
944+
} else if (obj->is_array()) {
951945
t = new ArrayConstant(obj->as_array());
952-
else
946+
} else {
953947
t = new InstanceConstant(obj->as_instance());
948+
}
954949
}
955950
break;
956-
}
957-
default : ShouldNotReachHere();
951+
}
952+
default: ShouldNotReachHere();
958953
}
959954
Value x;
960955
if (patch_state != NULL) {
961956
x = new Constant(t, patch_state);
962957
} else {
963958
x = new Constant(t);
964959
}
960+
961+
// Unbox the value at runtime, if needed.
962+
// ConstantDynamic entry can be of a primitive type, but it is cached in boxed form.
963+
if (patch_state != NULL) {
964+
int index = stream()->get_constant_pool_index();
965+
BasicType type = stream()->get_basic_type_for_constant_at(index);
966+
if (is_java_primitive(type)) {
967+
ciInstanceKlass* box_klass = ciEnv::current()->get_box_klass_for_primitive_type(type);
968+
assert(box_klass->is_loaded(), "sanity");
969+
int offset = java_lang_boxing_object::value_offset(type);
970+
ciField* value_field = box_klass->get_field_by_offset(offset, false /*is_static*/);
971+
x = new LoadField(append(x), offset, value_field, false /*is_static*/, patch_state, false /*needs_patching*/);
972+
t = as_ValueType(type);
973+
} else {
974+
assert(is_reference_type(type), "not a reference: %s", type2name(type));
975+
}
976+
}
977+
965978
push(t, append(x));
979+
} else {
980+
BAILOUT("could not resolve a constant");
966981
}
967982
}
968983

‎src/hotspot/share/c1/c1_InstructionPrinter.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -262,7 +262,7 @@ void InstructionPrinter::print_inline_level(BlockBegin* block) {
262262

263263

264264
void InstructionPrinter::print_unsafe_op(UnsafeOp* op, const char* name) {
265-
output()->print("%s", name);
265+
output()->print("%s(", name);
266266
print_value(op->object());
267267
output()->print(", ");
268268
print_value(op->offset());

‎src/hotspot/share/c1/c1_LIRAssembler.cpp

+1
Original file line numberDiff line numberDiff line change
@@ -76,6 +76,7 @@ void LIR_Assembler::patching_epilog(PatchingStub* patch, LIR_PatchCode patch_cod
7676
case Bytecodes::_getstatic:
7777
case Bytecodes::_ldc:
7878
case Bytecodes::_ldc_w:
79+
case Bytecodes::_ldc2_w:
7980
break;
8081
default:
8182
ShouldNotReachHere();

‎src/hotspot/share/c1/c1_Runtime1.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -1009,6 +1009,7 @@ JRT_ENTRY(void, Runtime1::patch_code(JavaThread* current, Runtime1::StubID stub_
10091009
break;
10101010
case Bytecodes::_ldc:
10111011
case Bytecodes::_ldc_w:
1012+
case Bytecodes::_ldc2_w:
10121013
{
10131014
Bytecode_loadconstant cc(caller_method, bci);
10141015
oop m = cc.resolve_constant(CHECK);
@@ -1153,7 +1154,6 @@ JRT_ENTRY(void, Runtime1::patch_code(JavaThread* current, Runtime1::StubID stub_
11531154
assert(load_klass != NULL, "klass not set");
11541155
n_copy->set_data((intx) (load_klass));
11551156
} else {
1156-
assert(mirror() != NULL, "klass not set");
11571157
// Don't need a G1 pre-barrier here since we assert above that data isn't an oop.
11581158
n_copy->set_data(cast_from_oop<intx>(mirror()));
11591159
}

‎src/hotspot/share/ci/ciEnv.cpp

+87-54
Original file line numberDiff line numberDiff line change
@@ -392,6 +392,23 @@ ciInstance* ciEnv::get_or_create_exception(jobject& handle, Symbol* name) {
392392
return obj == NULL? NULL: get_object(obj)->as_instance();
393393
}
394394

395+
ciInstanceKlass* ciEnv::get_box_klass_for_primitive_type(BasicType type) {
396+
switch (type) {
397+
case T_BOOLEAN: return Boolean_klass();
398+
case T_BYTE : return Byte_klass();
399+
case T_CHAR : return Character_klass();
400+
case T_SHORT : return Short_klass();
401+
case T_INT : return Integer_klass();
402+
case T_LONG : return Long_klass();
403+
case T_FLOAT : return Float_klass();
404+
case T_DOUBLE : return Double_klass();
405+
406+
default:
407+
assert(false, "not a primitive: %s", type2name(type));
408+
return NULL;
409+
}
410+
}
411+
395412
ciInstance* ciEnv::ArrayIndexOutOfBoundsException_instance() {
396413
if (_ArrayIndexOutOfBoundsException_instance == NULL) {
397414
_ArrayIndexOutOfBoundsException_instance
@@ -650,54 +667,75 @@ ciKlass* ciEnv::get_klass_by_index(const constantPoolHandle& cpool,
650667
GUARDED_VM_ENTRY(return get_klass_by_index_impl(cpool, index, is_accessible, accessor);)
651668
}
652669

670+
// ------------------------------------------------------------------
671+
// ciEnv::unbox_primitive_value
672+
//
673+
// Unbox a primitive and return it as a ciConstant.
674+
ciConstant ciEnv::unbox_primitive_value(ciObject* cibox, BasicType expected_bt) {
675+
jvalue value;
676+
BasicType bt = java_lang_boxing_object::get_value(cibox->get_oop(), &value);
677+
if (bt != expected_bt && expected_bt != T_ILLEGAL) {
678+
assert(false, "type mismatch: %s vs %s", type2name(expected_bt), cibox->klass()->name()->as_klass_external_name());
679+
return ciConstant();
680+
}
681+
switch (bt) {
682+
case T_BOOLEAN: return ciConstant(bt, value.z);
683+
case T_BYTE: return ciConstant(bt, value.b);
684+
case T_SHORT: return ciConstant(bt, value.s);
685+
case T_CHAR: return ciConstant(bt, value.c);
686+
case T_INT: return ciConstant(bt, value.i);
687+
case T_LONG: return ciConstant(value.j);
688+
case T_FLOAT: return ciConstant(value.f);
689+
case T_DOUBLE: return ciConstant(value.d);
690+
691+
default:
692+
assert(false, "not a primitive type: %s", type2name(bt));
693+
return ciConstant();
694+
}
695+
}
696+
697+
// ------------------------------------------------------------------
698+
// ciEnv::get_resolved_constant
699+
//
700+
ciConstant ciEnv::get_resolved_constant(const constantPoolHandle& cpool, int obj_index) {
701+
assert(obj_index >= 0, "");
702+
oop obj = cpool->resolved_references()->obj_at(obj_index);
703+
if (obj == NULL) {
704+
// Unresolved constant. It is resolved when the corresponding slot contains a non-null reference.
705+
// Null constant is represented as a sentinel (non-null) value.
706+
return ciConstant();
707+
} else if (obj == Universe::the_null_sentinel()) {
708+
return ciConstant(T_OBJECT, get_object(NULL));
709+
} else {
710+
ciObject* ciobj = get_object(obj);
711+
if (ciobj->is_array()) {
712+
return ciConstant(T_ARRAY, ciobj);
713+
} else {
714+
int cp_index = cpool->object_to_cp_index(obj_index);
715+
BasicType bt = cpool->basic_type_for_constant_at(cp_index);
716+
if (is_java_primitive(bt)) {
717+
assert(cpool->tag_at(cp_index).is_dynamic_constant(), "sanity");
718+
return unbox_primitive_value(ciobj, bt);
719+
} else {
720+
assert(ciobj->is_instance(), "should be an instance");
721+
return ciConstant(T_OBJECT, ciobj);
722+
}
723+
}
724+
}
725+
}
726+
653727
// ------------------------------------------------------------------
654728
// ciEnv::get_constant_by_index_impl
655729
//
656730
// Implementation of get_constant_by_index().
657731
ciConstant ciEnv::get_constant_by_index_impl(const constantPoolHandle& cpool,
658-
int pool_index, int cache_index,
732+
int index, int obj_index,
659733
ciInstanceKlass* accessor) {
660734
bool ignore_will_link;
661-
int index = pool_index;
662-
if (cache_index >= 0) {
663-
assert(index < 0, "only one kind of index at a time");
664-
index = cpool->object_to_cp_index(cache_index);
665-
oop obj = cpool->resolved_references()->obj_at(cache_index);
666-
if (obj != NULL) {
667-
if (obj == Universe::the_null_sentinel()) {
668-
return ciConstant(T_OBJECT, get_object(NULL));
669-
}
670-
BasicType bt = T_OBJECT;
671-
if (cpool->tag_at(index).is_dynamic_constant()) {
672-
bt = Signature::basic_type(cpool->uncached_signature_ref_at(index));
673-
}
674-
if (!is_reference_type(bt)) {
675-
// we have to unbox the primitive value
676-
if (!is_java_primitive(bt)) {
677-
return ciConstant();
678-
}
679-
jvalue value;
680-
BasicType bt2 = java_lang_boxing_object::get_value(obj, &value);
681-
assert(bt2 == bt, "");
682-
switch (bt2) {
683-
case T_DOUBLE: return ciConstant(value.d);
684-
case T_FLOAT: return ciConstant(value.f);
685-
case T_LONG: return ciConstant(value.j);
686-
case T_INT: return ciConstant(bt2, value.i);
687-
case T_SHORT: return ciConstant(bt2, value.s);
688-
case T_BYTE: return ciConstant(bt2, value.b);
689-
case T_CHAR: return ciConstant(bt2, value.c);
690-
case T_BOOLEAN: return ciConstant(bt2, value.z);
691-
default: return ciConstant();
692-
}
693-
}
694-
ciObject* ciobj = get_object(obj);
695-
if (ciobj->is_array()) {
696-
return ciConstant(T_ARRAY, ciobj);
697-
} else {
698-
assert(ciobj->is_instance(), "should be an instance");
699-
return ciConstant(T_OBJECT, ciobj);
700-
}
735+
if (obj_index >= 0) {
736+
ciConstant con = get_resolved_constant(cpool, obj_index);
737+
if (con.is_valid()) {
738+
return con;
701739
}
702740
}
703741
constantTag tag = cpool->tag_at(index);
@@ -711,35 +749,29 @@ ciConstant ciEnv::get_constant_by_index_impl(const constantPoolHandle& cpool,
711749
return ciConstant((jdouble)cpool->double_at(index));
712750
} else if (tag.is_string()) {
713751
EXCEPTION_CONTEXT;
714-
oop string = NULL;
715-
assert(cache_index >= 0, "should have a cache index");
716-
string = cpool->string_at(index, cache_index, THREAD);
752+
assert(obj_index >= 0, "should have an object index");
753+
oop string = cpool->string_at(index, obj_index, THREAD);
717754
if (HAS_PENDING_EXCEPTION) {
718755
CLEAR_PENDING_EXCEPTION;
719756
record_out_of_memory_failure();
720757
return ciConstant();
721758
}
722-
ciObject* constant = get_object(string);
723-
if (constant->is_array()) {
724-
return ciConstant(T_ARRAY, constant);
725-
} else {
726-
assert (constant->is_instance(), "must be an instance, or not? ");
727-
return ciConstant(T_OBJECT, constant);
728-
}
759+
ciInstance* constant = get_object(string)->as_instance();
760+
return ciConstant(T_OBJECT, constant);
729761
} else if (tag.is_unresolved_klass_in_error()) {
730762
return ciConstant(T_OBJECT, get_unloaded_klass_mirror(NULL));
731763
} else if (tag.is_klass() || tag.is_unresolved_klass()) {
732764
ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore_will_link, accessor);
733-
assert (klass->is_instance_klass() || klass->is_array_klass(),
734-
"must be an instance or array klass ");
735765
return ciConstant(T_OBJECT, klass->java_mirror());
736766
} else if (tag.is_method_type() || tag.is_method_type_in_error()) {
737767
// must execute Java code to link this CP entry into cache[i].f1
768+
assert(obj_index >= 0, "should have an object index");
738769
ciSymbol* signature = get_symbol(cpool->method_type_signature_at(index));
739770
ciObject* ciobj = get_unloaded_method_type_constant(signature);
740771
return ciConstant(T_OBJECT, ciobj);
741772
} else if (tag.is_method_handle() || tag.is_method_handle_in_error()) {
742773
// must execute Java code to link this CP entry into cache[i].f1
774+
assert(obj_index >= 0, "should have an object index");
743775
int ref_kind = cpool->method_handle_ref_kind_at(index);
744776
int callee_index = cpool->method_handle_klass_index_at(index);
745777
ciKlass* callee = get_klass_by_index_impl(cpool, callee_index, ignore_will_link, accessor);
@@ -748,7 +780,8 @@ ciConstant ciEnv::get_constant_by_index_impl(const constantPoolHandle& cpool,
748780
ciObject* ciobj = get_unloaded_method_handle_constant(callee, name, signature, ref_kind);
749781
return ciConstant(T_OBJECT, ciobj);
750782
} else if (tag.is_dynamic_constant() || tag.is_dynamic_constant_in_error()) {
751-
return ciConstant(); // not supported
783+
assert(obj_index >= 0, "should have an object index");
784+
return ciConstant(T_OBJECT, unloaded_ciinstance()); // unresolved dynamic constant
752785
} else {
753786
assert(false, "unknown tag: %d (%s)", tag.value(), tag.internal_name());
754787
return ciConstant();

‎src/hotspot/share/ci/ciEnv.hpp

+5
Original file line numberDiff line numberDiff line change
@@ -165,6 +165,9 @@ class ciEnv : StackObj {
165165
Bytecodes::Code bc,
166166
constantTag tag);
167167

168+
ciConstant unbox_primitive_value(ciObject* cibox, BasicType expected_bt = T_ILLEGAL);
169+
ciConstant get_resolved_constant(const constantPoolHandle& cpool, int obj_index);
170+
168171
// Get a ciObject from the object factory. Ensures uniqueness
169172
// of ciObjects.
170173
ciObject* get_object(oop o) {
@@ -429,6 +432,8 @@ class ciEnv : StackObj {
429432
}
430433
ciInstance* unloaded_ciinstance();
431434

435+
ciInstanceKlass* get_box_klass_for_primitive_type(BasicType type);
436+
432437
// Note: To find a class from its name string, use ciSymbol::make,
433438
// but consider adding to vmSymbols.hpp instead.
434439

‎src/hotspot/share/ci/ciObjectFactory.cpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -555,7 +555,7 @@ ciInstance* ciObjectFactory::get_unloaded_instance(ciInstanceKlass* instance_kla
555555
// Get a ciInstance representing an unresolved klass mirror.
556556
//
557557
// Currently, this ignores the parameters and returns a unique unloaded instance.
558-
ciInstance* ciObjectFactory::get_unloaded_klass_mirror(ciKlass* type) {
558+
ciInstance* ciObjectFactory::get_unloaded_klass_mirror(ciKlass* type) {
559559
assert(ciEnv::_Class_klass != NULL, "");
560560
return get_unloaded_instance(ciEnv::_Class_klass->as_instance_klass());
561561
}
@@ -570,7 +570,7 @@ ciInstance* ciObjectFactory::get_unloaded_method_handle_constant(ciKlass* holde
570570
ciSymbol* name,
571571
ciSymbol* signature,
572572
int ref_kind) {
573-
if (ciEnv::_MethodHandle_klass == NULL) return NULL;
573+
assert(ciEnv::_MethodHandle_klass != NULL, "");
574574
return get_unloaded_instance(ciEnv::_MethodHandle_klass->as_instance_klass());
575575
}
576576

@@ -581,12 +581,12 @@ ciInstance* ciObjectFactory::get_unloaded_method_handle_constant(ciKlass* holde
581581
//
582582
// Currently, this ignores the parameters and returns a unique unloaded instance.
583583
ciInstance* ciObjectFactory::get_unloaded_method_type_constant(ciSymbol* signature) {
584-
if (ciEnv::_MethodType_klass == NULL) return NULL;
584+
assert(ciEnv::_MethodType_klass != NULL, "");
585585
return get_unloaded_instance(ciEnv::_MethodType_klass->as_instance_klass());
586586
}
587587

588588
ciInstance* ciObjectFactory::get_unloaded_object_constant() {
589-
if (ciEnv::_Object_klass == NULL) return NULL;
589+
assert(ciEnv::_Object_klass != NULL, "");
590590
return get_unloaded_instance(ciEnv::_Object_klass->as_instance_klass());
591591
}
592592

0 commit comments

Comments
 (0)
Please sign in to comment.