33 #include "code/nmethod.hpp"
34 #include "code/pcDesc.hpp"
35 #include "code/scopeDesc.hpp"
36 #include "compiler/compilationPolicy.hpp"
37 #include "interpreter/bytecode.hpp"
38 #include "interpreter/interpreter.hpp"
39 #include "interpreter/oopMapCache.hpp"
40 #include "memory/allocation.inline.hpp"
41 #include "memory/oopFactory.hpp"
42 #include "memory/resourceArea.hpp"
43 #include "memory/universe.hpp"
44 #include "oops/constantPool.hpp"
45 #include "oops/method.hpp"
46 #include "oops/objArrayKlass.hpp"
47 #include "oops/objArrayOop.inline.hpp"
48 #include "oops/oop.inline.hpp"
49 #include "oops/fieldStreams.inline.hpp"
50 #include "oops/typeArrayOop.inline.hpp"
51 #include "oops/verifyOopClosure.hpp"
52 #include "prims/jvmtiThreadState.hpp"
53 #include "runtime/atomic.hpp"
54 #include "runtime/biasedLocking.hpp"
55 #include "runtime/deoptimization.hpp"
56 #include "runtime/fieldDescriptor.hpp"
57 #include "runtime/fieldDescriptor.inline.hpp"
58 #include "runtime/frame.inline.hpp"
59 #include "runtime/handles.inline.hpp"
60 #include "runtime/interfaceSupport.inline.hpp"
61 #include "runtime/jniHandles.inline.hpp"
62 #include "runtime/safepointVerifiers.hpp"
63 #include "runtime/sharedRuntime.hpp"
64 #include "runtime/signature.hpp"
65 #include "runtime/stubRoutines.hpp"
66 #include "runtime/thread.hpp"
67 #include "runtime/threadSMR.hpp"
68 #include "runtime/vframe.hpp"
69 #include "runtime/vframeArray.hpp"
70 #include "runtime/vframe_hp.hpp"
71 #include "utilities/events.hpp"
72 #include "utilities/macros.hpp"
984 assert(objects->at(i)->is_object(), "invalid debug information");
985 ObjectValue* sv = (ObjectValue*) objects->at(i);
986
987 Klass* k = java_lang_Class::as_Klass(sv->klass()->as_ConstantOopReadValue()->value()());
988 oop obj = NULL;
989
990 if (k->is_instance_klass()) {
991 #if INCLUDE_JVMCI || INCLUDE_AOT
992 CompiledMethod* cm = fr->cb()->as_compiled_method_or_null();
993 if (cm->is_compiled_by_jvmci() && sv->is_auto_box()) {
994 AutoBoxObjectValue* abv = (AutoBoxObjectValue*) sv;
995 obj = get_cached_box(abv, fr, reg_map, THREAD);
996 if (obj != NULL) {
997 // Set the flag to indicate the box came from a cache, so that we can skip the field reassignment for it.
998 abv->set_cached(true);
999 }
1000 }
1001 #endif // INCLUDE_JVMCI || INCLUDE_AOT
1002 InstanceKlass* ik = InstanceKlass::cast(k);
1003 if (obj == NULL) {
1004 obj = ik->allocate_instance(THREAD);
1005 }
1006 } else if (k->is_typeArray_klass()) {
1007 TypeArrayKlass* ak = TypeArrayKlass::cast(k);
1008 assert(sv->field_size() % type2size[ak->element_type()] == 0, "non-integral array length");
1009 int len = sv->field_size() / type2size[ak->element_type()];
1010 obj = ak->allocate(len, THREAD);
1011 } else if (k->is_objArray_klass()) {
1012 ObjArrayKlass* ak = ObjArrayKlass::cast(k);
1013 obj = ak->allocate(sv->field_size(), THREAD);
1014 }
1015
1016 if (obj == NULL) {
1017 failures = true;
1018 }
1019
1020 assert(sv->value().is_null(), "redundant reallocation");
1021 assert(obj != NULL || HAS_PENDING_EXCEPTION, "allocation should succeed or we should get an exception");
1022 CLEAR_PENDING_EXCEPTION;
1023 sv->set_value(obj);
1024 }
1264
1265 // restore fields of all eliminated objects and arrays
1266 void Deoptimization::reassign_fields(frame* fr, RegisterMap* reg_map, GrowableArray<ScopeValue*>* objects, bool realloc_failures, bool skip_internal) {
1267 for (int i = 0; i < objects->length(); i++) {
1268 ObjectValue* sv = (ObjectValue*) objects->at(i);
1269 Klass* k = java_lang_Class::as_Klass(sv->klass()->as_ConstantOopReadValue()->value()());
1270 Handle obj = sv->value();
1271 assert(obj.not_null() || realloc_failures, "reallocation was missed");
1272 if (PrintDeoptimizationDetails) {
1273 tty->print_cr("reassign fields for object of type %s!", k->name()->as_C_string());
1274 }
1275 if (obj.is_null()) {
1276 continue;
1277 }
1278 #if INCLUDE_JVMCI || INCLUDE_AOT
1279 // Don't reassign fields of boxes that came from a cache. Caches may be in CDS.
1280 if (sv->is_auto_box() && ((AutoBoxObjectValue*) sv)->is_cached()) {
1281 continue;
1282 }
1283 #endif // INCLUDE_JVMCI || INCLUDE_AOT
1284 if (k->is_instance_klass()) {
1285 InstanceKlass* ik = InstanceKlass::cast(k);
1286 reassign_fields_by_klass(ik, fr, reg_map, sv, 0, obj(), skip_internal);
1287 } else if (k->is_typeArray_klass()) {
1288 TypeArrayKlass* ak = TypeArrayKlass::cast(k);
1289 reassign_type_array_elements(fr, reg_map, sv, (typeArrayOop) obj(), ak->element_type());
1290 } else if (k->is_objArray_klass()) {
1291 reassign_object_array_elements(fr, reg_map, sv, (objArrayOop) obj());
1292 }
1293 }
1294 }
1295
1296
1297 // relock objects for which synchronization was eliminated
1298 void Deoptimization::relock_objects(GrowableArray<MonitorInfo*>* monitors, JavaThread* thread, bool realloc_failures) {
1299 for (int i = 0; i < monitors->length(); i++) {
1300 MonitorInfo* mon_info = monitors->at(i);
1301 if (mon_info->eliminated()) {
1302 assert(!mon_info->owner_is_scalar_replaced() || realloc_failures, "reallocation was missed");
1303 if (!mon_info->owner_is_scalar_replaced()) {
|
33 #include "code/nmethod.hpp"
34 #include "code/pcDesc.hpp"
35 #include "code/scopeDesc.hpp"
36 #include "compiler/compilationPolicy.hpp"
37 #include "interpreter/bytecode.hpp"
38 #include "interpreter/interpreter.hpp"
39 #include "interpreter/oopMapCache.hpp"
40 #include "memory/allocation.inline.hpp"
41 #include "memory/oopFactory.hpp"
42 #include "memory/resourceArea.hpp"
43 #include "memory/universe.hpp"
44 #include "oops/constantPool.hpp"
45 #include "oops/method.hpp"
46 #include "oops/objArrayKlass.hpp"
47 #include "oops/objArrayOop.inline.hpp"
48 #include "oops/oop.inline.hpp"
49 #include "oops/fieldStreams.inline.hpp"
50 #include "oops/typeArrayOop.inline.hpp"
51 #include "oops/verifyOopClosure.hpp"
52 #include "prims/jvmtiThreadState.hpp"
53 #include "prims/vectorSupport.hpp"
54 #include "runtime/atomic.hpp"
55 #include "runtime/biasedLocking.hpp"
56 #include "runtime/deoptimization.hpp"
57 #include "runtime/fieldDescriptor.hpp"
58 #include "runtime/fieldDescriptor.inline.hpp"
59 #include "runtime/frame.inline.hpp"
60 #include "runtime/handles.inline.hpp"
61 #include "runtime/interfaceSupport.inline.hpp"
62 #include "runtime/jniHandles.inline.hpp"
63 #include "runtime/safepointVerifiers.hpp"
64 #include "runtime/sharedRuntime.hpp"
65 #include "runtime/signature.hpp"
66 #include "runtime/stubRoutines.hpp"
67 #include "runtime/thread.hpp"
68 #include "runtime/threadSMR.hpp"
69 #include "runtime/vframe.hpp"
70 #include "runtime/vframeArray.hpp"
71 #include "runtime/vframe_hp.hpp"
72 #include "utilities/events.hpp"
73 #include "utilities/macros.hpp"
985 assert(objects->at(i)->is_object(), "invalid debug information");
986 ObjectValue* sv = (ObjectValue*) objects->at(i);
987
988 Klass* k = java_lang_Class::as_Klass(sv->klass()->as_ConstantOopReadValue()->value()());
989 oop obj = NULL;
990
991 if (k->is_instance_klass()) {
992 #if INCLUDE_JVMCI || INCLUDE_AOT
993 CompiledMethod* cm = fr->cb()->as_compiled_method_or_null();
994 if (cm->is_compiled_by_jvmci() && sv->is_auto_box()) {
995 AutoBoxObjectValue* abv = (AutoBoxObjectValue*) sv;
996 obj = get_cached_box(abv, fr, reg_map, THREAD);
997 if (obj != NULL) {
998 // Set the flag to indicate the box came from a cache, so that we can skip the field reassignment for it.
999 abv->set_cached(true);
1000 }
1001 }
1002 #endif // INCLUDE_JVMCI || INCLUDE_AOT
1003 InstanceKlass* ik = InstanceKlass::cast(k);
1004 if (obj == NULL) {
1005 #ifdef COMPILER2
1006 if (EnableVectorSupport && VectorSupport::is_vector(ik)) {
1007 obj = VectorSupport::allocate_vector(ik, fr, reg_map, sv, THREAD);
1008 } else {
1009 obj = ik->allocate_instance(THREAD);
1010 }
1011 #else
1012 obj = ik->allocate_instance(THREAD);
1013 #endif // COMPILER2
1014 }
1015 } else if (k->is_typeArray_klass()) {
1016 TypeArrayKlass* ak = TypeArrayKlass::cast(k);
1017 assert(sv->field_size() % type2size[ak->element_type()] == 0, "non-integral array length");
1018 int len = sv->field_size() / type2size[ak->element_type()];
1019 obj = ak->allocate(len, THREAD);
1020 } else if (k->is_objArray_klass()) {
1021 ObjArrayKlass* ak = ObjArrayKlass::cast(k);
1022 obj = ak->allocate(sv->field_size(), THREAD);
1023 }
1024
1025 if (obj == NULL) {
1026 failures = true;
1027 }
1028
1029 assert(sv->value().is_null(), "redundant reallocation");
1030 assert(obj != NULL || HAS_PENDING_EXCEPTION, "allocation should succeed or we should get an exception");
1031 CLEAR_PENDING_EXCEPTION;
1032 sv->set_value(obj);
1033 }
1273
1274 // restore fields of all eliminated objects and arrays
1275 void Deoptimization::reassign_fields(frame* fr, RegisterMap* reg_map, GrowableArray<ScopeValue*>* objects, bool realloc_failures, bool skip_internal) {
1276 for (int i = 0; i < objects->length(); i++) {
1277 ObjectValue* sv = (ObjectValue*) objects->at(i);
1278 Klass* k = java_lang_Class::as_Klass(sv->klass()->as_ConstantOopReadValue()->value()());
1279 Handle obj = sv->value();
1280 assert(obj.not_null() || realloc_failures, "reallocation was missed");
1281 if (PrintDeoptimizationDetails) {
1282 tty->print_cr("reassign fields for object of type %s!", k->name()->as_C_string());
1283 }
1284 if (obj.is_null()) {
1285 continue;
1286 }
1287 #if INCLUDE_JVMCI || INCLUDE_AOT
1288 // Don't reassign fields of boxes that came from a cache. Caches may be in CDS.
1289 if (sv->is_auto_box() && ((AutoBoxObjectValue*) sv)->is_cached()) {
1290 continue;
1291 }
1292 #endif // INCLUDE_JVMCI || INCLUDE_AOT
1293 #ifdef COMPILER2
1294 if (EnableVectorSupport && VectorSupport::is_vector(k)) {
1295 continue; // skip field reassignment for vectors
1296 }
1297 #endif
1298 if (k->is_instance_klass()) {
1299 InstanceKlass* ik = InstanceKlass::cast(k);
1300 reassign_fields_by_klass(ik, fr, reg_map, sv, 0, obj(), skip_internal);
1301 } else if (k->is_typeArray_klass()) {
1302 TypeArrayKlass* ak = TypeArrayKlass::cast(k);
1303 reassign_type_array_elements(fr, reg_map, sv, (typeArrayOop) obj(), ak->element_type());
1304 } else if (k->is_objArray_klass()) {
1305 reassign_object_array_elements(fr, reg_map, sv, (objArrayOop) obj());
1306 }
1307 }
1308 }
1309
1310
1311 // relock objects for which synchronization was eliminated
1312 void Deoptimization::relock_objects(GrowableArray<MonitorInfo*>* monitors, JavaThread* thread, bool realloc_failures) {
1313 for (int i = 0; i < monitors->length(); i++) {
1314 MonitorInfo* mon_info = monitors->at(i);
1315 if (mon_info->eliminated()) {
1316 assert(!mon_info->owner_is_scalar_replaced() || realloc_failures, "reallocation was missed");
1317 if (!mon_info->owner_is_scalar_replaced()) {
|