1 /* 2 * Copyright (c) 2011, 2023, 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 24 #include "precompiled.hpp" 25 #include "classfile/javaClasses.inline.hpp" 26 #include "code/compiledIC.hpp" 27 #include "compiler/compileBroker.hpp" 28 #include "compiler/compilerThread.hpp" 29 #include "compiler/oopMap.hpp" 30 #include "gc/shared/barrierSetNMethod.hpp" 31 #include "jvmci/jvmciCodeInstaller.hpp" 32 #include "jvmci/jvmciCompilerToVM.hpp" 33 #include "jvmci/jvmciRuntime.hpp" 34 #include "memory/universe.hpp" 35 #include "oops/compressedKlass.inline.hpp" 36 #include "oops/klass.inline.hpp" 37 #include "prims/jvmtiExport.hpp" 38 #include "prims/methodHandles.hpp" 39 #include "runtime/interfaceSupport.inline.hpp" 40 #include "runtime/jniHandles.inline.hpp" 41 #include "runtime/os.hpp" 42 #include "runtime/sharedRuntime.hpp" 43 #include "utilities/align.hpp" 44 45 // frequently used constants 46 // Allocate them with new so they are never destroyed (otherwise, a 47 // forced exit could destroy these objects while they are still in 48 // use). 49 ConstantOopWriteValue* CodeInstaller::_oop_null_scope_value = new (mtJVMCI) ConstantOopWriteValue(nullptr); 50 ConstantIntValue* CodeInstaller::_int_m1_scope_value = new (mtJVMCI) ConstantIntValue(-1); 51 ConstantIntValue* CodeInstaller::_int_0_scope_value = new (mtJVMCI) ConstantIntValue((jint)0); 52 ConstantIntValue* CodeInstaller::_int_1_scope_value = new (mtJVMCI) ConstantIntValue(1); 53 ConstantIntValue* CodeInstaller::_int_2_scope_value = new (mtJVMCI) ConstantIntValue(2); 54 LocationValue* CodeInstaller::_illegal_value = new (mtJVMCI) LocationValue(Location()); 55 MarkerValue* CodeInstaller::_virtual_byte_array_marker = new (mtJVMCI) MarkerValue(); 56 57 static bool is_set(u1 flags, u1 bit) { 58 return flags & bit; 59 } 60 61 oop HotSpotCompiledCodeStream::get_oop(int id, JVMCI_TRAPS) const { 62 if (_object_pool.is_null()) { 63 JVMCI_ERROR_NULL("object pool is null%s", context()); 64 } 65 if (!_object_pool.is_null() && 0 <= id && id < _object_pool->length()) { 66 return _object_pool->obj_at(id); 67 } 68 JVMCI_ERROR_NULL("unknown direct object id %d%s", id, context()); 69 } 70 71 u4 HotSpotCompiledCodeStream::offset() const { 72 u4 res = 0; 73 for (Chunk* c = _head; c != nullptr; c = c->next()) { 74 if (c == _chunk) { 75 res += _pos - c->data(); 76 break; 77 } else { 78 res += c->size(); 79 } 80 } 81 return res; 82 } 83 84 bool HotSpotCompiledCodeStream::available() const { 85 u4 rem = _chunk->data_end() - _pos; 86 for (Chunk* c = _chunk->next(); c != nullptr; c = c->next()) { 87 rem += c->size(); 88 } 89 return rem; 90 } 91 92 void HotSpotCompiledCodeStream::dump_buffer(outputStream* st) const { 93 st->print_cr("HotSpotCompiledCode stream for %s:", code_desc()); 94 int chunk_index = 0; 95 for (Chunk* c = _head; c != nullptr; c = c->next()) { 96 const u1* data = c->data(); 97 const u1* data_end = c->data_end(); 98 99 int to_dump = data_end - data; 100 st->print_cr("# chunk %d, %d bytes", chunk_index, to_dump); 101 st->print_data((void*) data, to_dump, true, false); 102 chunk_index++; 103 } 104 } 105 106 void HotSpotCompiledCodeStream::dump_buffer_tail(int len, outputStream* st) const { 107 const u1* start; 108 int avail = _pos - _chunk->data(); 109 if (len >= avail) { 110 len = avail; 111 start = _chunk->data(); 112 } else { 113 start = _pos - len; 114 115 // Ensure start is 16-byte aligned wrt chunk start 116 int start_offset = start - _chunk->data(); 117 start -= (start_offset % 16); 118 len = _pos - start; 119 } 120 121 st->print_cr("Last %d bytes up to current read position " INTPTR_FORMAT " in HotSpotCompiledCode stream for %s:", len, p2i(_pos), code_desc()); 122 st->print_data((void*) start, len, true, false); 123 } 124 125 const char* HotSpotCompiledCodeStream::context() const { 126 stringStream st; 127 st.cr(); 128 st.print_cr("at " INTPTR_FORMAT " in HotSpotCompiledCode stream", p2i(_pos)); 129 dump_buffer_tail(100, &st); 130 return st.as_string(); 131 } 132 133 void HotSpotCompiledCodeStream::before_read(u1 size) { 134 if (_pos + size > _chunk->data_end()) { 135 Chunk* next = _chunk->next(); 136 if (next == nullptr || size > next->size()) { 137 dump_buffer(); 138 fatal("%s: reading %d bytes overflows buffer at " INTPTR_FORMAT, code_desc(), size, p2i(_pos)); 139 } 140 _chunk = next; 141 _pos = _chunk->data(); 142 } 143 } 144 145 // Reads a size followed by an ascii string from the stream and 146 // checks that they match `expect_size` and `expect_name` respectively. This 147 // implements a rudimentary type checking of the stream between the stream producer 148 // (Java) and the consumer (C++). 149 void HotSpotCompiledCodeStream::check_data(u2 expect_size, const char* expect_name) { 150 u2 actual_size = get_u1(); 151 u2 ascii_len = get_u1(); 152 const char* actual_name = (const char*) _pos; 153 char* end = (char*) _pos + ascii_len; 154 _pos = (const u1*) end; 155 if (strlen(expect_name) != ascii_len || strncmp(expect_name, actual_name, ascii_len) != 0) { 156 dump_buffer(); 157 fatal("%s: expected \"%s\" at " INTPTR_FORMAT ", got \"%.*s\" (len: %d)", 158 code_desc(), expect_name, p2i(actual_name), ascii_len, actual_name, ascii_len); 159 } 160 if (actual_size != expect_size) { 161 dump_buffer(); 162 fatal("%s: expected \"%s\" at " INTPTR_FORMAT " to have size %u, got %u", 163 code_desc(), expect_name, p2i(actual_name), expect_size, actual_size); 164 } 165 } 166 167 const char* HotSpotCompiledCodeStream::read_utf8(const char* name, JVMCI_TRAPS) { 168 jint utf_len = read_s4(name); 169 if (utf_len == -1) { 170 return nullptr; 171 } 172 guarantee(utf_len >= 0, "bad utf_len: %d", utf_len); 173 174 const char* utf = (const char*) _pos; 175 char* end = (char*) _pos + utf_len; 176 _pos = (const u1*) (end + 1); 177 if (*end != '\0') { 178 JVMCI_ERROR_NULL("UTF8 string at " INTPTR_FORMAT " of length %d missing 0 terminator: \"%.*s\"%s", 179 p2i(utf), utf_len, utf_len, utf, context()); 180 } 181 return utf; 182 } 183 184 Method* HotSpotCompiledCodeStream::read_method(const char* name) { 185 return (Method*) read_u8(name); 186 } 187 188 Klass* HotSpotCompiledCodeStream::read_klass(const char* name) { 189 return (Klass*) read_u8(name); 190 } 191 192 ScopeValue* HotSpotCompiledCodeStream::virtual_object_at(int id, JVMCI_TRAPS) const { 193 if (_virtual_objects == nullptr) { 194 JVMCI_ERROR_NULL("virtual object id %d read outside scope of decoding DebugInfo%s", id, context()); 195 } 196 if (id < 0 || id >= _virtual_objects->length()) { 197 JVMCI_ERROR_NULL("invalid virtual object id %d%s", id, context()); 198 } 199 return _virtual_objects->at(id); 200 } 201 202 #ifndef PRODUCT 203 void CodeInstaller::verify_bci_constants(JVMCIEnv* env) { 204 #define CHECK_IN_SYNC(name) do { \ 205 int expect = env->get_BytecodeFrame_ ## name ##_BCI(); \ 206 int actual = name##_BCI; \ 207 if (expect != actual) fatal("CodeInstaller::" #name "_BCI(%d) != BytecodeFrame." #name "_BCI(%d)", expect, actual); \ 208 } while(0) 209 210 CHECK_IN_SYNC(UNWIND); 211 CHECK_IN_SYNC(BEFORE); 212 CHECK_IN_SYNC(AFTER); 213 CHECK_IN_SYNC(AFTER_EXCEPTION); 214 CHECK_IN_SYNC(UNKNOWN); 215 CHECK_IN_SYNC(INVALID_FRAMESTATE); 216 #undef CHECK_IN_SYNC 217 } 218 #endif 219 220 VMReg CodeInstaller::getVMRegFromLocation(HotSpotCompiledCodeStream* stream, int total_frame_size, JVMCI_TRAPS) { 221 u2 reg = stream->read_u2("register"); 222 u2 offset = stream->read_u2("offset"); 223 224 if (reg != NO_REGISTER) { 225 VMReg vmReg = CodeInstaller::get_hotspot_reg(reg, JVMCI_CHECK_NULL); 226 if (offset % 4 == 0) { 227 return vmReg->next(offset / 4); 228 } else { 229 JVMCI_ERROR_NULL("unaligned subregister offset %d in oop map%s", offset, stream->context()); 230 } 231 } else { 232 if (offset % 4 == 0) { 233 VMReg vmReg = VMRegImpl::stack2reg(offset / 4); 234 if (!OopMapValue::legal_vm_reg_name(vmReg)) { 235 // This restriction only applies to VMRegs that are used in OopMap but 236 // since that's the only use of VMRegs it's simplest to put this test 237 // here. This test should also be equivalent legal_vm_reg_name but JVMCI 238 // clients can use max_oop_map_stack_stack_offset to detect this problem 239 // directly. The asserts just ensure that the tests are in agreement. 240 assert(offset > CompilerToVM::Data::max_oop_map_stack_offset(), "illegal VMReg"); 241 JVMCI_ERROR_NULL("stack offset %d is too large to be encoded in OopMap (max %d)%s", 242 offset, CompilerToVM::Data::max_oop_map_stack_offset(), stream->context()); 243 } 244 assert(OopMapValue::legal_vm_reg_name(vmReg), "illegal VMReg"); 245 return vmReg; 246 } else { 247 JVMCI_ERROR_NULL("unaligned stack offset %d in oop map%s", offset, stream->context()); 248 } 249 } 250 } 251 252 OopMap* CodeInstaller::create_oop_map(HotSpotCompiledCodeStream* stream, u1 debug_info_flags, JVMCI_TRAPS) { 253 assert(is_set(debug_info_flags, DI_HAS_REFERENCE_MAP), "must be"); 254 u2 max_register_size = stream->read_u2("maxRegisterSize"); 255 if (!_has_wide_vector && SharedRuntime::is_wide_vector(max_register_size)) { 256 if (SharedRuntime::polling_page_vectors_safepoint_handler_blob() == nullptr) { 257 JVMCI_ERROR_NULL("JVMCI is producing code using vectors larger than the runtime supports%s", stream->context()); 258 } 259 _has_wide_vector = true; 260 } 261 u2 length = stream->read_u2("referenceMap:length"); 262 263 OopMap* map = new OopMap(_total_frame_size, _parameter_count); 264 for (int i = 0; i < length; i++) { 265 bool has_derived = stream->read_bool("hasDerived"); 266 u2 bytes = stream->read_u2("sizeInBytes"); 267 VMReg vmReg = getVMRegFromLocation(stream, _total_frame_size, JVMCI_CHECK_NULL); 268 if (has_derived) { 269 // derived oop 270 if (bytes == LP64_ONLY(8) NOT_LP64(4)) { 271 VMReg baseReg = getVMRegFromLocation(stream, _total_frame_size, JVMCI_CHECK_NULL); 272 map->set_derived_oop(vmReg, baseReg); 273 } else { 274 JVMCI_ERROR_NULL("invalid derived oop size in ReferenceMap: %d%s", bytes, stream->context()); 275 } 276 #ifdef _LP64 277 } else if (bytes == 8) { 278 // wide oop 279 map->set_oop(vmReg); 280 } else if (bytes == 4) { 281 // narrow oop 282 map->set_narrowoop(vmReg); 283 #else 284 } else if (bytes == 4) { 285 map->set_oop(vmReg); 286 #endif 287 } else { 288 JVMCI_ERROR_NULL("invalid oop size in ReferenceMap: %d%s", bytes, stream->context()); 289 } 290 } 291 292 if (is_set(debug_info_flags, DI_HAS_CALLEE_SAVE_INFO)) { 293 length = stream->read_u2("calleeSaveInfo:length"); 294 for (jint i = 0; i < length; i++) { 295 u2 jvmci_reg_number = stream->read_u2("register"); 296 VMReg hotspot_reg = CodeInstaller::get_hotspot_reg(jvmci_reg_number, JVMCI_CHECK_NULL); 297 // HotSpot stack slots are 4 bytes 298 u2 jvmci_slot = stream->read_u2("slot"); 299 jint hotspot_slot = jvmci_slot * VMRegImpl::slots_per_word; 300 VMReg hotspot_slot_as_reg = VMRegImpl::stack2reg(hotspot_slot); 301 map->set_callee_saved(hotspot_slot_as_reg, hotspot_reg); 302 #ifdef _LP64 303 // (copied from generate_oop_map() in c1_Runtime1_x86.cpp) 304 VMReg hotspot_slot_hi_as_reg = VMRegImpl::stack2reg(hotspot_slot + 1); 305 map->set_callee_saved(hotspot_slot_hi_as_reg, hotspot_reg->next()); 306 #endif 307 } 308 } 309 return map; 310 } 311 312 void* CodeInstaller::record_metadata_reference(CodeSection* section, address dest, HotSpotCompiledCodeStream* stream, u1 tag, JVMCI_TRAPS) { 313 /* 314 * This method needs to return a raw (untyped) pointer, since the value of a pointer to the base 315 * class is in general not equal to the pointer of the subclass. When patching metaspace pointers, 316 * the compiler expects a direct pointer to the subclass (Klass* or Method*), not a pointer to the 317 * base class (Metadata* or MetaspaceObj*). 318 */ 319 if (tag == PATCH_KLASS) { 320 Klass* klass = stream->read_klass("patch:klass"); 321 int index = _oop_recorder->find_index(klass); 322 section->relocate(dest, metadata_Relocation::spec(index)); 323 JVMCI_event_3("metadata[%d of %d] = %s", index, _oop_recorder->metadata_count(), klass->name()->as_C_string()); 324 return klass; 325 } else if (tag == PATCH_METHOD) { 326 Method* method = stream->read_method("patch:method"); 327 int index = _oop_recorder->find_index(method); 328 section->relocate(dest, metadata_Relocation::spec(index)); 329 JVMCI_event_3("metadata[%d of %d] = %s", index, _oop_recorder->metadata_count(), method->name()->as_C_string()); 330 return method; 331 } else { 332 JVMCI_ERROR_NULL("unexpected metadata reference tag: %d%s", tag, stream->context()); 333 } 334 } 335 336 #ifdef _LP64 337 narrowKlass CodeInstaller::record_narrow_metadata_reference(CodeSection* section, address dest, HotSpotCompiledCodeStream* stream, u1 tag, JVMCI_TRAPS) { 338 if (tag != PATCH_NARROW_KLASS) { 339 JVMCI_ERROR_0("unexpected compressed pointer tag %d%s", tag, stream->context()); 340 } 341 Klass* klass = stream->read_klass("patch:klass"); 342 int index = _oop_recorder->find_index(klass); 343 section->relocate(dest, metadata_Relocation::spec(index)); 344 JVMCI_event_3("narrowKlass[%d of %d] = %s", index, _oop_recorder->metadata_count(), klass->name()->as_C_string()); 345 return CompressedKlassPointers::encode(klass); 346 } 347 #endif 348 349 ScopeValue* CodeInstaller::to_primitive_value(HotSpotCompiledCodeStream* stream, jlong raw, BasicType type, ScopeValue* &second, JVMCI_TRAPS) { 350 if (type == T_INT || type == T_FLOAT) { 351 jint prim = (jint) raw; 352 switch (prim) { 353 case -1: return _int_m1_scope_value; 354 case 0: return _int_0_scope_value; 355 case 1: return _int_1_scope_value; 356 case 2: return _int_2_scope_value; 357 default: return new ConstantIntValue(prim); 358 } 359 } else if (type == T_LONG || type == T_DOUBLE) { 360 jlong prim = raw; 361 second = _int_1_scope_value; 362 return new ConstantLongValue(prim); 363 } else { 364 JVMCI_ERROR_NULL("unexpected primitive constant type %s%s", basictype_to_str(type), stream->context()); 365 } 366 } 367 368 Handle CodeInstaller::read_oop(HotSpotCompiledCodeStream* stream, u1 tag, JVMCI_TRAPS) { 369 oop obj; 370 if (tag == OBJECT_ID) { 371 obj = stream->get_oop(stream->read_u1("id"), JVMCI_CHECK_(Handle())); 372 } else if (tag == OBJECT_ID2) { 373 obj = stream->get_oop(stream->read_u2("id:2"), JVMCI_CHECK_(Handle())); 374 } else if (tag == JOBJECT) { 375 jlong object_handle = stream->read_u8("jobject"); 376 obj = jvmci_env()->resolve_oop_handle(object_handle); 377 } else { 378 JVMCI_ERROR_(Handle(), "unexpected oop tag: %d", tag) 379 } 380 if (obj == nullptr) { 381 JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly null", Handle()); 382 } else { 383 guarantee(oopDesc::is_oop_or_null(obj), "invalid oop: " INTPTR_FORMAT, p2i((oopDesc*) obj)); 384 } 385 return Handle(stream->thread(), obj); 386 } 387 388 ScopeValue* CodeInstaller::get_scope_value(HotSpotCompiledCodeStream* stream, u1 tag, BasicType type, ScopeValue* &second, JVMCI_TRAPS) { 389 second = nullptr; 390 switch (tag) { 391 case ILLEGAL: { 392 if (type != T_ILLEGAL) { 393 JVMCI_ERROR_NULL("unexpected illegal value, expected %s%s", basictype_to_str(type), stream->context()); 394 } 395 return _illegal_value; 396 } 397 case REGISTER_PRIMITIVE: 398 case REGISTER_NARROW_OOP: 399 case REGISTER_OOP: { 400 u2 number = stream->read_u2("register"); 401 VMReg hotspotRegister = get_hotspot_reg(number, JVMCI_CHECK_NULL); 402 if (is_general_purpose_reg(hotspotRegister)) { 403 Location::Type locationType; 404 if (type == T_OBJECT) { 405 locationType = tag == REGISTER_NARROW_OOP ? Location::narrowoop : Location::oop; 406 } else if (type == T_LONG) { 407 locationType = Location::lng; 408 } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) { 409 locationType = Location::int_in_long; 410 } else { 411 JVMCI_ERROR_NULL("unexpected type %s in CPU register%s", basictype_to_str(type), stream->context()); 412 } 413 ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister)); 414 if (type == T_LONG) { 415 second = value; 416 } 417 return value; 418 } else { 419 Location::Type locationType; 420 if (type == T_FLOAT) { 421 // this seems weird, but the same value is used in c1_LinearScan 422 locationType = Location::normal; 423 } else if (type == T_DOUBLE) { 424 locationType = Location::dbl; 425 } else { 426 JVMCI_ERROR_NULL("unexpected type %s in floating point register%s", basictype_to_str(type), stream->context()); 427 } 428 ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister)); 429 if (type == T_DOUBLE) { 430 second = value; 431 } 432 return value; 433 } 434 } 435 case STACK_SLOT_PRIMITIVE: 436 case STACK_SLOT_NARROW_OOP: 437 case STACK_SLOT_OOP: { 438 jint offset = (jshort) stream->read_s2("offset"); 439 if (stream->read_bool("addRawFrameSize")) { 440 offset += _total_frame_size; 441 } 442 Location::Type locationType; 443 if (type == T_OBJECT) { 444 locationType = tag == STACK_SLOT_NARROW_OOP ? Location::narrowoop : Location::oop; 445 } else if (type == T_LONG) { 446 locationType = Location::lng; 447 } else if (type == T_DOUBLE) { 448 locationType = Location::dbl; 449 } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) { 450 locationType = Location::normal; 451 } else { 452 JVMCI_ERROR_NULL("unexpected type %s in stack slot%s", basictype_to_str(type), stream->context()); 453 } 454 ScopeValue* value = new LocationValue(Location::new_stk_loc(locationType, offset)); 455 if (type == T_DOUBLE || type == T_LONG) { 456 second = value; 457 } 458 return value; 459 } 460 case NULL_CONSTANT: { return _oop_null_scope_value; } 461 case RAW_CONSTANT: { return new ConstantLongValue(stream->read_u8("primitive")); } 462 case PRIMITIVE_0: { ScopeValue* v = to_primitive_value(stream, 0, type, second, JVMCI_CHECK_NULL); return v; } 463 case PRIMITIVE4: { ScopeValue* v = to_primitive_value(stream, stream->read_s4("primitive4"), type, second, JVMCI_CHECK_NULL); return v; } 464 case PRIMITIVE8: { ScopeValue* v = to_primitive_value(stream, stream->read_s8("primitive8"), type, second, JVMCI_CHECK_NULL); return v; } 465 case VIRTUAL_OBJECT_ID: { ScopeValue* v = stream->virtual_object_at(stream->read_u1("id"), JVMCI_CHECK_NULL); return v; } 466 case VIRTUAL_OBJECT_ID2: { ScopeValue* v = stream->virtual_object_at(stream->read_u2("id:2"), JVMCI_CHECK_NULL); return v; } 467 468 case OBJECT_ID: 469 case OBJECT_ID2: 470 case JOBJECT: { 471 Handle obj = read_oop(stream, tag, JVMCI_CHECK_NULL); 472 return new ConstantOopWriteValue(JNIHandles::make_local(obj())); 473 } 474 default: { 475 JVMCI_ERROR_NULL("unexpected tag in scope: %d%s", tag, stream->context()) 476 } 477 } 478 } 479 480 void CodeInstaller::record_object_value(ObjectValue* sv, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) { 481 oop javaMirror = JNIHandles::resolve(sv->klass()->as_ConstantOopWriteValue()->value()); 482 Klass* klass = java_lang_Class::as_Klass(javaMirror); 483 bool isLongArray = klass == Universe::longArrayKlassObj(); 484 bool isByteArray = klass == Universe::byteArrayKlassObj(); 485 486 u2 length = stream->read_u2("values:length"); 487 for (jint i = 0; i < length; i++) { 488 ScopeValue* cur_second = nullptr; 489 BasicType type = (BasicType) stream->read_u1("basicType"); 490 ScopeValue* value; 491 u1 tag = stream->read_u1("tag"); 492 if (tag == ILLEGAL) { 493 if (isByteArray && type == T_ILLEGAL) { 494 /* 495 * The difference between a virtualized large access and a deferred write is the kind stored in the slotKinds 496 * of the virtual object: in the virtualization case, the kind is illegal, in the deferred write case, the kind 497 * is access stack kind (an int). 498 */ 499 value = _virtual_byte_array_marker; 500 } else { 501 value = _illegal_value; 502 if (type == T_DOUBLE || type == T_LONG) { 503 cur_second = _illegal_value; 504 } 505 } 506 } else { 507 value = get_scope_value(stream, tag, type, cur_second, JVMCI_CHECK); 508 } 509 510 if (isLongArray && cur_second == nullptr) { 511 // we're trying to put ints into a long array... this isn't really valid, but it's used for some optimizations. 512 // add an int 0 constant 513 cur_second = _int_0_scope_value; 514 } 515 516 if (isByteArray && cur_second != nullptr && (type == T_DOUBLE || type == T_LONG)) { 517 // we are trying to write a long in a byte Array. We will need to count the illegals to restore the type of 518 // the thing we put inside. 519 cur_second = nullptr; 520 } 521 522 if (cur_second != nullptr) { 523 sv->field_values()->append(cur_second); 524 } 525 assert(value != nullptr, "missing value"); 526 sv->field_values()->append(value); 527 } 528 } 529 530 GrowableArray<ScopeValue*>* CodeInstaller::read_local_or_stack_values(HotSpotCompiledCodeStream* stream, u1 frame_flags, bool is_locals, JVMCI_TRAPS) { 531 u2 length; 532 if (is_locals) { 533 if (!is_set(frame_flags, DIF_HAS_LOCALS)) { 534 return nullptr; 535 } 536 length = stream->read_u2("numLocals"); 537 } else { 538 if (!is_set(frame_flags, DIF_HAS_STACK)) { 539 return nullptr; 540 } 541 length = stream->read_u2("numStack"); 542 } 543 GrowableArray<ScopeValue*>* values = new GrowableArray<ScopeValue*> (length); 544 for (int i = 0; i < length; i++) { 545 ScopeValue* second = nullptr; 546 BasicType type = (BasicType) stream->read_u1("basicType"); 547 u1 tag = stream->read_u1("tag"); 548 ScopeValue* first = get_scope_value(stream, tag, type, second, JVMCI_CHECK_NULL); 549 if (second != nullptr) { 550 if (i == length) { 551 JVMCI_ERROR_NULL("double-slot value not followed by Value.ILLEGAL%s", stream->context()); 552 } 553 i++; 554 stream->read_u1("basicType"); 555 tag = stream->read_u1("tag"); 556 if (tag != ILLEGAL) { 557 JVMCI_ERROR_NULL("double-slot value not followed by Value.ILLEGAL%s", stream->context()); 558 } 559 values->append(second); 560 } 561 values->append(first); 562 } 563 return values; 564 } 565 566 GrowableArray<MonitorValue*>* CodeInstaller::read_monitor_values(HotSpotCompiledCodeStream* stream, u1 frame_flags, JVMCI_TRAPS) { 567 if (!is_set(frame_flags, DIF_HAS_LOCKS)) { 568 return nullptr; 569 } 570 if (!_has_monitors) { 571 _has_monitors = true; 572 } 573 u2 length = stream->read_u2("numLocks"); 574 GrowableArray<MonitorValue*>* monitors = new GrowableArray<MonitorValue*>(length); 575 for (int i = 0; i < length; i++) { 576 bool eliminated = stream->read_bool("isEliminated"); 577 ScopeValue* second = nullptr; 578 ScopeValue* owner_value = get_scope_value(stream, stream->read_u1("tag"), T_OBJECT, second, JVMCI_CHECK_NULL); 579 assert(second == nullptr, "monitor cannot occupy two stack slots"); 580 581 ScopeValue* lock_data_value = get_scope_value(stream, stream->read_u1("tag"), T_LONG, second, JVMCI_CHECK_NULL); 582 assert(second == lock_data_value, "monitor is LONG value that occupies two stack slots"); 583 assert(lock_data_value->is_location(), "invalid monitor location"); 584 Location lock_data_loc = ((LocationValue*) lock_data_value)->location(); 585 586 monitors->append(new MonitorValue(owner_value, lock_data_loc, eliminated)); 587 } 588 return monitors; 589 } 590 591 void CodeInstaller::initialize_dependencies(HotSpotCompiledCodeStream* stream, u1 code_flags, OopRecorder* oop_recorder, JVMCI_TRAPS) { 592 JavaThread* thread = stream->thread(); 593 CompilerThread* compilerThread = thread->is_Compiler_thread() ? CompilerThread::cast(thread) : nullptr; 594 _oop_recorder = oop_recorder; 595 _dependencies = new Dependencies(&_arena, _oop_recorder, compilerThread != nullptr ? compilerThread->log() : nullptr); 596 if (is_set(code_flags, HCC_HAS_ASSUMPTIONS)) { 597 u2 length = stream->read_u2("assumptions:length"); 598 for (int i = 0; i < length; ++i) { 599 u1 tag = stream->read_u1("tag"); 600 switch (tag) { 601 case NO_FINALIZABLE_SUBCLASS: { 602 Klass* receiver_type = stream->read_klass("receiverType"); 603 _dependencies->assert_has_no_finalizable_subclasses(receiver_type); 604 break; 605 } 606 case CONCRETE_SUBTYPE: { 607 Klass* context = stream->read_klass("context"); 608 Klass* subtype = stream->read_klass("subtype"); 609 assert(context->is_abstract(), "must be"); 610 _dependencies->assert_abstract_with_unique_concrete_subtype(context, subtype); 611 break; 612 } 613 case LEAF_TYPE: { 614 Klass* context = stream->read_klass("context"); 615 _dependencies->assert_leaf_type(context); 616 break; 617 } 618 case CONCRETE_METHOD: { 619 Klass* context = stream->read_klass("context"); 620 Method* impl = stream->read_method("impl"); 621 _dependencies->assert_unique_concrete_method(context, impl); 622 break; 623 } 624 case CALLSITE_TARGET_VALUE: { 625 u1 obj_tag = stream->read_u1("tag"); 626 Handle callSite = read_oop(stream, obj_tag, JVMCI_CHECK); 627 obj_tag = stream->read_u1("tag"); 628 Handle methodHandle = read_oop(stream, obj_tag, JVMCI_CHECK); 629 _dependencies->assert_call_site_target_value(callSite(), methodHandle()); 630 break; 631 } 632 default: { 633 JVMCI_ERROR("unexpected assumption tag %d%s", tag, stream->context()); 634 } 635 } 636 } 637 } 638 if (is_set(code_flags, HCC_HAS_METHODS)) { 639 u2 length = stream->read_u2("methods:length"); 640 for (int i = 0; i < length; ++i) { 641 Method* method = stream->read_method("method"); 642 if (JvmtiExport::can_hotswap_or_post_breakpoint()) { 643 _dependencies->assert_evol_method(method); 644 } 645 } 646 } 647 } 648 649 JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler, 650 jlong compiled_code_buffer, 651 bool with_type_info, 652 JVMCIObject compiled_code, 653 objArrayHandle object_pool, 654 CodeBlob*& cb, 655 JVMCIObject installed_code, 656 FailedSpeculation** failed_speculations, 657 char* speculations, 658 int speculations_len, 659 JVMCI_TRAPS) { 660 661 JavaThread* thread = JavaThread::current(); 662 HotSpotCompiledCodeStream* stream = new HotSpotCompiledCodeStream(thread, (const u1*) compiled_code_buffer, with_type_info, object_pool); 663 664 u1 code_flags = stream->read_u1("code:flags"); 665 bool is_nmethod = is_set(code_flags, HCC_IS_NMETHOD); 666 const char* name = stream->read_utf8("name", JVMCI_CHECK_OK); 667 668 methodHandle method; 669 jint entry_bci = -1; 670 JVMCICompileState* compile_state = nullptr; 671 bool has_unsafe_access = false; 672 jint id = -1; 673 674 if (is_nmethod) { 675 method = methodHandle(thread, stream->read_method("method")); 676 entry_bci = is_nmethod ? stream->read_s4("entryBCI") : -1; 677 compile_state = (JVMCICompileState*) stream->read_u8("compileState"); 678 has_unsafe_access = stream->read_bool("hasUnsafeAccess"); 679 id = stream->read_s4("id"); 680 } 681 stream->set_code_desc(name, method); 682 683 CodeBuffer buffer("JVMCI Compiler CodeBuffer"); 684 OopRecorder* recorder = new OopRecorder(&_arena, true); 685 initialize_dependencies(stream, code_flags, recorder, JVMCI_CHECK_OK); 686 687 // Get instructions and constants CodeSections early because we need it. 688 _instructions = buffer.insts(); 689 _constants = buffer.consts(); 690 691 initialize_fields(stream, code_flags, method, buffer, JVMCI_CHECK_OK); 692 JVMCI::CodeInstallResult result = initialize_buffer(compiled_code, buffer, stream, code_flags, JVMCI_CHECK_OK); 693 694 u4 available = stream->available(); 695 if (result == JVMCI::ok && available != 0) { 696 JVMCI_ERROR_OK("%d bytes remaining in stream%s", available, stream->context()); 697 } 698 699 if (result != JVMCI::ok) { 700 return result; 701 } 702 703 int stack_slots = _total_frame_size / HeapWordSize; // conversion to words 704 705 if (!is_nmethod) { 706 if (name == nullptr) { 707 JVMCI_ERROR_OK("stub should have a name"); 708 } 709 name = os::strdup(name); // Note: this leaks. See JDK-8289632 710 cb = RuntimeStub::new_runtime_stub(name, 711 &buffer, 712 _offsets.value(CodeOffsets::Frame_Complete), 713 stack_slots, 714 _debug_recorder->_oopmaps, 715 false); 716 result = JVMCI::ok; 717 } else { 718 if (compile_state != nullptr) { 719 jvmci_env()->set_compile_state(compile_state); 720 } 721 722 if (id == -1) { 723 // Make sure a valid compile_id is associated with every compile 724 id = CompileBroker::assign_compile_id_unlocked(thread, method, entry_bci); 725 jvmci_env()->set_HotSpotCompiledNmethod_id(compiled_code, id); 726 } 727 if (!jvmci_env()->isa_HotSpotNmethod(installed_code)) { 728 JVMCI_THROW_MSG_(IllegalArgumentException, "InstalledCode object must be a HotSpotNmethod when installing a HotSpotCompiledNmethod", JVMCI::ok); 729 } 730 731 // We would like to be strict about the nmethod entry barrier but there are various test 732 // configurations which generate assembly without being a full compiler. So for now we enforce 733 // that JIT compiled methods must have an nmethod barrier. 734 bool install_default = JVMCIENV->get_HotSpotNmethod_isDefault(installed_code) != 0; 735 if (_nmethod_entry_patch_offset == -1 && install_default) { 736 JVMCI_THROW_MSG_(IllegalArgumentException, "nmethod entry barrier is missing", JVMCI::ok); 737 } 738 739 JVMCIObject mirror = installed_code; 740 nmethod* nm = nullptr; // nm is an out parameter of register_method 741 result = runtime()->register_method(jvmci_env(), 742 method, 743 nm, 744 entry_bci, 745 &_offsets, 746 _orig_pc_offset, 747 &buffer, 748 stack_slots, 749 _debug_recorder->_oopmaps, 750 &_exception_handler_table, 751 &_implicit_exception_table, 752 compiler, 753 _debug_recorder, 754 _dependencies, 755 id, 756 _has_monitors, 757 has_unsafe_access, 758 _has_wide_vector, 759 compiled_code, 760 mirror, 761 failed_speculations, 762 speculations, 763 speculations_len, 764 _nmethod_entry_patch_offset); 765 if (result == JVMCI::ok) { 766 cb = nm; 767 if (compile_state == nullptr) { 768 // This compile didn't come through the CompileBroker so perform the printing here 769 DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, compiler); 770 nm->maybe_print_nmethod(directive); 771 DirectivesStack::release(directive); 772 } 773 774 if (nm != nullptr) { 775 if (_nmethod_entry_patch_offset != -1) { 776 err_msg msg(""); 777 BarrierSetNMethod* bs_nm = BarrierSet::barrier_set()->barrier_set_nmethod(); 778 779 if (!bs_nm->verify_barrier(nm, msg)) { 780 JVMCI_THROW_MSG_(IllegalArgumentException, err_msg("nmethod entry barrier is malformed: %s", msg.buffer()), JVMCI::ok); 781 } 782 } 783 } 784 } 785 } 786 787 if (cb != nullptr) { 788 // Make sure the pre-calculated constants section size was correct. 789 guarantee((cb->code_begin() - cb->content_begin()) >= _constants_size, "%d < %d", (int)(cb->code_begin() - cb->content_begin()), _constants_size); 790 } 791 return result; 792 } 793 794 void CodeInstaller::initialize_fields(HotSpotCompiledCodeStream* stream, u1 code_flags, methodHandle& method, CodeBuffer& buffer, JVMCI_TRAPS) { 795 if (!method.is_null()) { 796 _parameter_count = method->size_of_parameters(); 797 JVMCI_event_2("installing code for %s", method->name_and_sig_as_C_string()); 798 } else { 799 // Must be a HotSpotCompiledCode for a stub. 800 // Only used in OopMap constructor for non-product builds 801 _parameter_count = 0; 802 } 803 _sites_count = stream->read_s4("sites:length"); 804 _code_size = stream->read_s4("targetCodeSize"); 805 _total_frame_size = stream->read_s4("totalFrameSize"); 806 if (!is_set(code_flags, HCC_HAS_DEOPT_RESCUE_SLOT)) { 807 _orig_pc_offset = -1; 808 } else { 809 _orig_pc_offset = stream->read_s2("offset"); 810 if (stream->read_bool("addRawFrameSize")) { 811 _orig_pc_offset += _total_frame_size; 812 } 813 if (_orig_pc_offset < 0) { 814 JVMCI_ERROR("invalid deopt rescue slot: %d%s", _orig_pc_offset, stream->context()); 815 } 816 } 817 818 // Pre-calculate the constants section size. This is required for PC-relative addressing. 819 u4 data_section_size = stream->read_u4("dataSectionSize"); 820 u1 data_section_alignment = stream->read_u1("dataSectionAlignment"); 821 buffer.set_const_section_alignment(data_section_alignment); 822 if ((_constants->alignment() % data_section_alignment) != 0) { 823 JVMCI_ERROR("invalid data section alignment: %d [constants alignment: %d]%s", 824 data_section_alignment, _constants->alignment(), stream->context()); 825 } 826 _constants_size = data_section_size; 827 _next_call_type = INVOKE_INVALID; 828 _has_monitors = false; 829 _has_wide_vector = false; 830 _nmethod_entry_patch_offset = -1; 831 } 832 833 u1 CodeInstaller::as_read_oop_tag(HotSpotCompiledCodeStream* stream, u1 patch_object_tag, JVMCI_TRAPS) { 834 switch (patch_object_tag) { 835 case PATCH_OBJECT_ID: 836 case PATCH_NARROW_OBJECT_ID: { 837 return OBJECT_ID; 838 } 839 case PATCH_OBJECT_ID2: 840 case PATCH_NARROW_OBJECT_ID2: { 841 return OBJECT_ID2; 842 } 843 case PATCH_NARROW_JOBJECT: 844 case PATCH_JOBJECT: { 845 return JOBJECT; 846 } 847 default: { 848 JVMCI_ERROR_0("unknown object patch tag: %d%s", patch_object_tag, stream->context()); 849 } 850 } 851 } 852 853 int CodeInstaller::estimate_stubs_size(HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) { 854 // Estimate the number of static call stubs that might be emitted. 855 u2 static_call_stubs = stream->read_u2("numStaticCallStubs"); 856 u2 trampoline_stubs = stream->read_u2("numTrampolineStubs"); 857 int size = static_call_stubs * CompiledStaticCall::to_interp_stub_size(); 858 size += trampoline_stubs * CompiledStaticCall::to_trampoline_stub_size(); 859 return size; 860 } 861 862 // perform data and call relocation on the CodeBuffer 863 JVMCI::CodeInstallResult CodeInstaller::initialize_buffer(JVMCIObject compiled_code, CodeBuffer& buffer, HotSpotCompiledCodeStream* stream, u1 code_flags, JVMCI_TRAPS) { 864 JavaThread* thread = stream->thread(); 865 HandleMark hm(thread); 866 int locs_buffer_size = _sites_count * (relocInfo::length_limit + sizeof(relocInfo)); 867 868 869 // Allocate enough space in the stub section for the static call 870 // stubs. Stubs have extra relocs but they are managed by the stub 871 // section itself so they don't need to be accounted for in the 872 // locs_buffer above. 873 int stubs_size = estimate_stubs_size(stream, JVMCI_CHECK_OK); 874 875 assert((CodeBuffer::SECT_INSTS == CodeBuffer::SECT_STUBS - 1) && 876 (CodeBuffer::SECT_CONSTS == CodeBuffer::SECT_INSTS - 1), "sections order: consts, insts, stubs"); 877 // buffer content: [constants + code_align] + [code + stubs_align] + [stubs] 878 int total_size = align_up(_constants_size, buffer.insts()->alignment()) + 879 align_up(_code_size, buffer.stubs()->alignment()) + 880 stubs_size; 881 882 if (total_size > JVMCINMethodSizeLimit) { 883 return JVMCI::code_too_large; 884 } 885 886 buffer.initialize(total_size, locs_buffer_size); 887 if (buffer.blob() == nullptr) { 888 return JVMCI::cache_full; 889 } 890 buffer.initialize_stubs_size(stubs_size); 891 buffer.initialize_consts_size(_constants_size); 892 893 _debug_recorder = new DebugInformationRecorder(_oop_recorder); 894 _debug_recorder->set_oopmaps(new OopMapSet()); 895 896 buffer.initialize_oop_recorder(_oop_recorder); 897 898 // copy the constant data into the newly created CodeBuffer 899 address end_data = _constants->start() + _constants_size; 900 JVMCIObject data_section = jvmci_env()->get_HotSpotCompiledCode_dataSection(compiled_code); 901 JVMCIENV->copy_bytes_to(data_section, (jbyte*) _constants->start(), 0, _constants_size); 902 _constants->set_end(end_data); 903 904 // copy the code into the newly created CodeBuffer 905 address end_pc = _instructions->start() + _code_size; 906 guarantee(_instructions->allocates2(end_pc), "initialize should have reserved enough space for all the code"); 907 908 JVMCIPrimitiveArray code = jvmci_env()->get_HotSpotCompiledCode_targetCode(compiled_code); 909 JVMCIENV->copy_bytes_to(code, (jbyte*) _instructions->start(), 0, _code_size); 910 _instructions->set_end(end_pc); 911 912 913 u2 length = stream->read_u2("dataSectionPatches:length"); 914 for (int i = 0; i < length; i++) { 915 address dest = _constants->start() + stream->read_u4("patch:pcOffset"); 916 u1 tag = stream->read_u1("tag"); 917 918 switch (tag) { 919 case PATCH_METHOD: 920 case PATCH_KLASS: { 921 *((void**) dest) = record_metadata_reference(_constants, dest, stream, tag, JVMCI_CHECK_OK); 922 break; 923 } 924 case PATCH_NARROW_KLASS: { 925 #ifdef _LP64 926 *((narrowKlass*) dest) = record_narrow_metadata_reference(_constants, dest, stream, tag, JVMCI_CHECK_OK); 927 #else 928 JVMCI_ERROR_OK("unexpected compressed Klass* in 32-bit mode"); 929 #endif 930 break; 931 } 932 case PATCH_OBJECT_ID: 933 case PATCH_OBJECT_ID2: 934 case PATCH_NARROW_OBJECT_ID: 935 case PATCH_NARROW_OBJECT_ID2: 936 case PATCH_JOBJECT: 937 case PATCH_NARROW_JOBJECT: { 938 bool narrow = tag == PATCH_NARROW_OBJECT_ID || tag == PATCH_NARROW_OBJECT_ID2 || tag == PATCH_NARROW_JOBJECT; 939 u1 read_tag = as_read_oop_tag(stream, tag, JVMCI_CHECK_OK); 940 record_oop_patch(stream, dest, read_tag, narrow, JVMCI_CHECK_OK); 941 break; 942 } 943 default: { 944 JVMCI_ERROR_OK("invalid constant tag: %d%s", tag, stream->context()); 945 break; 946 } 947 } 948 } 949 950 jint last_pc_offset = -1; 951 for (int i = 0; i < _sites_count; i++) { 952 u4 pc_offset = stream->read_s4("site:pcOffset"); 953 u1 tag = stream->read_u1("tag"); 954 switch (tag) { 955 case SITE_FOREIGN_CALL: 956 case SITE_FOREIGN_CALL_NO_DEBUG_INFO: 957 case SITE_CALL: { 958 site_Call(buffer, tag, pc_offset, stream, JVMCI_CHECK_OK); 959 break; 960 } 961 case SITE_SAFEPOINT: 962 case SITE_IMPLICIT_EXCEPTION: 963 case SITE_IMPLICIT_EXCEPTION_DISPATCH: { 964 site_Safepoint(buffer, pc_offset, stream, tag, JVMCI_CHECK_OK); 965 break; 966 } 967 case SITE_INFOPOINT: { 968 site_Infopoint(buffer, pc_offset, stream, JVMCI_CHECK_OK); 969 break; 970 } 971 case SITE_MARK: { 972 site_Mark(buffer, pc_offset, stream, JVMCI_CHECK_OK); 973 break; 974 } 975 case SITE_DATA_PATCH: { 976 site_DataPatch(buffer, pc_offset, stream, JVMCI_CHECK_OK); 977 break; 978 } 979 case SITE_EXCEPTION_HANDLER: { 980 site_ExceptionHandler(pc_offset, stream); 981 break; 982 } 983 default: { 984 JVMCI_ERROR_OK("unexpected site tag at " INTPTR_FORMAT ": %d", p2i(stream->pos() - 1), tag); 985 } 986 } 987 988 last_pc_offset = pc_offset; 989 990 if ((i % 32 == 0) && SafepointMechanism::should_process(thread)) { 991 // Force a safepoint to mitigate pause time installing large code 992 ThreadToNativeFromVM ttnfv(thread); 993 } 994 } 995 996 if (is_set(code_flags, HCC_HAS_COMMENTS)) { 997 u2 length = stream->read_u2("comments:length"); 998 for (int i = 0; i < length; i++) { 999 u4 pc_offset = stream->read_u4("comment:pcOffset"); 1000 const char* text = stream->read_utf8("comment:text", JVMCI_CHECK_OK); 1001 #ifndef PRODUCT 1002 buffer.block_comment(pc_offset, text); 1003 #endif 1004 } 1005 } 1006 if (_has_auto_box) { 1007 JavaThread* THREAD = thread; // For exception macros. 1008 JVMCI::ensure_box_caches_initialized(CHECK_(JVMCI::ok)); 1009 } 1010 return JVMCI::ok; 1011 } 1012 1013 void CodeInstaller::record_oop_patch(HotSpotCompiledCodeStream* stream, address dest, u1 read_tag, bool narrow, JVMCI_TRAPS) { 1014 Handle obj = read_oop(stream, read_tag, JVMCI_CHECK); 1015 jobject value = JNIHandles::make_local(obj()); 1016 int oop_index = _oop_recorder->find_index(value); 1017 if (narrow) { 1018 #ifdef _LP64 1019 _constants->relocate(dest, oop_Relocation::spec(oop_index), relocInfo::narrow_oop_in_const); 1020 #else 1021 JVMCI_ERROR("unexpected compressed oop in 32-bit mode"); 1022 #endif 1023 } else { 1024 _constants->relocate(dest, oop_Relocation::spec(oop_index)); 1025 } 1026 } 1027 1028 void CodeInstaller::site_ExceptionHandler(jint pc_offset, HotSpotCompiledCodeStream* stream) { 1029 u4 handler_offset = stream->read_u4("site:handlerPos"); 1030 1031 // Subtable header 1032 _exception_handler_table.add_entry(HandlerTableEntry(1, pc_offset, 0)); 1033 1034 // Subtable entry 1035 _exception_handler_table.add_entry(HandlerTableEntry(-1, handler_offset, 0)); 1036 } 1037 1038 void CodeInstaller::read_virtual_objects(HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) { 1039 u2 length = stream->read_u2("virtualObjects:length"); 1040 if (length == 0) { 1041 return; 1042 } 1043 GrowableArray<ScopeValue*> *objects = new GrowableArray<ScopeValue*>(length, length, nullptr); 1044 stream->set_virtual_objects(objects); 1045 // Create the unique ObjectValues 1046 JavaThread* thread = stream->thread(); 1047 for (int id = 0; id < length; id++) { 1048 Klass* klass = stream->read_klass("type"); 1049 bool is_auto_box = stream->read_bool("isAutoBox"); 1050 if (is_auto_box) { 1051 _has_auto_box = true; 1052 } 1053 oop javaMirror = klass->java_mirror(); 1054 ScopeValue *klass_sv = new ConstantOopWriteValue(JNIHandles::make_local(javaMirror)); 1055 ObjectValue* sv = is_auto_box ? new AutoBoxObjectValue(id, klass_sv) : new ObjectValue(id, klass_sv); 1056 objects->at_put(id, sv); 1057 } 1058 // All the values which could be referenced by the VirtualObjects 1059 // exist, so now describe all the VirtualObjects themselves. 1060 for (int id = 0; id < length; id++) { 1061 record_object_value(objects->at(id)->as_ObjectValue(), stream, JVMCI_CHECK); 1062 } 1063 _debug_recorder->dump_object_pool(objects); 1064 1065 stream->set_virtual_objects(objects); 1066 } 1067 1068 int CodeInstaller::map_jvmci_bci(int bci) { 1069 if (bci < 0) { 1070 switch (bci) { 1071 case BEFORE_BCI: return BeforeBci; 1072 case AFTER_BCI: return AfterBci; 1073 case UNWIND_BCI: return UnwindBci; 1074 case AFTER_EXCEPTION_BCI: return AfterExceptionBci; 1075 case UNKNOWN_BCI: return UnknownBci; 1076 case INVALID_FRAMESTATE_BCI: return InvalidFrameStateBci; 1077 } 1078 ShouldNotReachHere(); 1079 } 1080 return bci; 1081 } 1082 1083 void CodeInstaller::record_scope(jint pc_offset, HotSpotCompiledCodeStream* stream, u1 debug_info_flags, bool full_info, bool is_mh_invoke, bool return_oop, JVMCI_TRAPS) { 1084 if (full_info) { 1085 read_virtual_objects(stream, JVMCI_CHECK); 1086 } 1087 if (is_set(debug_info_flags, DI_HAS_FRAMES)) { 1088 u2 depth = stream->read_u2("depth"); 1089 for (int i = 0; i < depth; i++) { 1090 Thread* thread = Thread::current(); 1091 methodHandle method(thread, stream->read_method("method")); 1092 jint bci = map_jvmci_bci(stream->read_s4("bci")); 1093 if (bci == BEFORE_BCI) { 1094 bci = SynchronizationEntryBCI; 1095 } 1096 1097 JVMCI_event_2("Recording scope pc_offset=%d bci=%d method=%s", pc_offset, bci, method->name_and_sig_as_C_string()); 1098 1099 bool reexecute = false; 1100 bool rethrow_exception = false; 1101 1102 DebugToken* locals_token = nullptr; 1103 DebugToken* stack_token = nullptr; 1104 DebugToken* monitors_token = nullptr; 1105 1106 if (full_info) { 1107 u1 frame_flags = stream->read_u1("flags"); 1108 rethrow_exception = is_set(frame_flags, DIF_RETHROW_EXCEPTION); 1109 1110 if (bci >= 0) { 1111 reexecute = !is_set(frame_flags, DIF_DURING_CALL); 1112 } 1113 1114 GrowableArray<ScopeValue*>* locals = read_local_or_stack_values(stream, frame_flags, true, JVMCI_CHECK); 1115 GrowableArray<ScopeValue*>* stack = read_local_or_stack_values(stream, frame_flags, false, JVMCI_CHECK); 1116 GrowableArray<MonitorValue*>* monitors = read_monitor_values(stream, frame_flags, JVMCI_CHECK); 1117 1118 locals_token = _debug_recorder->create_scope_values(locals); 1119 stack_token = _debug_recorder->create_scope_values(stack); 1120 monitors_token = _debug_recorder->create_monitor_values(monitors); 1121 } 1122 1123 // has_ea_local_in_scope and arg_escape should be added to JVMCI 1124 const bool return_scalarized = false; 1125 const bool has_ea_local_in_scope = false; 1126 const bool arg_escape = false; 1127 _debug_recorder->describe_scope(pc_offset, method, nullptr, bci, reexecute, rethrow_exception, is_mh_invoke, return_oop, 1128 return_scalarized, has_ea_local_in_scope, arg_escape, 1129 locals_token, stack_token, monitors_token); 1130 } 1131 } 1132 if (full_info) { 1133 // Clear the virtual objects as they are specific to one DebugInfo 1134 stream->set_virtual_objects(nullptr); 1135 } 1136 } 1137 1138 void CodeInstaller::site_Safepoint(CodeBuffer& buffer, jint pc_offset, HotSpotCompiledCodeStream* stream, u1 tag, JVMCI_TRAPS) { 1139 u1 flags = stream->read_u1("debugInfo:flags"); 1140 OopMap *map = create_oop_map(stream, flags, JVMCI_CHECK); 1141 _debug_recorder->add_safepoint(pc_offset, map); 1142 record_scope(pc_offset, stream, flags, true, JVMCI_CHECK); 1143 _debug_recorder->end_safepoint(pc_offset); 1144 if (_orig_pc_offset < 0) { 1145 JVMCI_ERROR("method contains safepoint, but has no deopt rescue slot"); 1146 } 1147 if (tag == SITE_IMPLICIT_EXCEPTION_DISPATCH) { 1148 jint dispatch_offset = stream->read_s4("dispatchOffset"); 1149 _implicit_exception_table.append(pc_offset, dispatch_offset); 1150 } else if (tag == SITE_IMPLICIT_EXCEPTION) { 1151 _implicit_exception_table.add_deoptimize(pc_offset); 1152 } 1153 } 1154 1155 void CodeInstaller::site_Infopoint(CodeBuffer& buffer, jint pc_offset, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) { 1156 u1 flags = stream->read_u1("debugInfo:flags"); 1157 _debug_recorder->add_non_safepoint(pc_offset); 1158 record_scope(pc_offset, stream, flags, false, JVMCI_CHECK); 1159 _debug_recorder->end_non_safepoint(pc_offset); 1160 } 1161 1162 void CodeInstaller::site_Call(CodeBuffer& buffer, u1 tag, jint pc_offset, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) { 1163 JavaThread* thread = stream->thread(); 1164 jlong target = stream->read_u8("target"); 1165 methodHandle method; 1166 bool direct_call = false; 1167 if (tag == SITE_CALL) { 1168 method = methodHandle(thread, (Method*) target); 1169 assert(Method::is_valid_method(method()), "invalid method"); 1170 direct_call = stream->read_bool("direct"); 1171 if (method.is_null()) { 1172 JVMCI_THROW(NullPointerException); 1173 } 1174 } 1175 1176 NativeInstruction* inst = nativeInstruction_at(_instructions->start() + pc_offset); 1177 jint next_pc_offset = CodeInstaller::pd_next_offset(inst, pc_offset, JVMCI_CHECK); 1178 1179 if (tag != SITE_FOREIGN_CALL_NO_DEBUG_INFO) { 1180 u1 flags = stream->read_u1("debugInfo:flags"); 1181 OopMap *map = create_oop_map(stream, flags, JVMCI_CHECK); 1182 _debug_recorder->add_safepoint(next_pc_offset, map); 1183 1184 if (!method.is_null()) { 1185 vmIntrinsics::ID iid = method->intrinsic_id(); 1186 bool is_mh_invoke = false; 1187 if (direct_call) { 1188 is_mh_invoke = !method->is_static() && (iid == vmIntrinsics::_compiledLambdaForm || 1189 (MethodHandles::is_signature_polymorphic(iid) && MethodHandles::is_signature_polymorphic_intrinsic(iid))); 1190 } 1191 bool return_oop = method->is_returning_oop(); 1192 record_scope(next_pc_offset, stream, flags, true, is_mh_invoke, return_oop, JVMCI_CHECK); 1193 } else { 1194 record_scope(next_pc_offset, stream, flags, true, JVMCI_CHECK); 1195 } 1196 } 1197 1198 if (tag != SITE_CALL) { 1199 jlong foreign_call_destination = target; 1200 CodeInstaller::pd_relocate_ForeignCall(inst, foreign_call_destination, JVMCI_CHECK); 1201 } else { 1202 CodeInstaller::pd_relocate_JavaMethod(buffer, method, pc_offset, JVMCI_CHECK); 1203 if (_next_call_type == INVOKESTATIC || _next_call_type == INVOKESPECIAL) { 1204 // Need a static call stub for transitions from compiled to interpreted. 1205 if (CompiledStaticCall::emit_to_interp_stub(buffer, _instructions->start() + pc_offset) == nullptr) { 1206 JVMCI_ERROR("could not emit to_interp stub - code cache is full"); 1207 } 1208 } 1209 } 1210 1211 _next_call_type = INVOKE_INVALID; 1212 1213 if (tag != SITE_FOREIGN_CALL_NO_DEBUG_INFO) { 1214 _debug_recorder->end_safepoint(next_pc_offset); 1215 } 1216 } 1217 1218 void CodeInstaller::site_DataPatch(CodeBuffer& buffer, jint pc_offset, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) { 1219 u1 tag = stream->read_u1("tag"); 1220 switch (tag) { 1221 case PATCH_OBJECT_ID: 1222 case PATCH_OBJECT_ID2: 1223 case PATCH_NARROW_OBJECT_ID: 1224 case PATCH_NARROW_OBJECT_ID2: 1225 case PATCH_JOBJECT: 1226 case PATCH_NARROW_JOBJECT: { 1227 bool narrow = tag == PATCH_NARROW_OBJECT_ID || tag == PATCH_NARROW_OBJECT_ID2 || tag == PATCH_NARROW_JOBJECT; 1228 u1 read_tag = as_read_oop_tag(stream, tag, JVMCI_CHECK); 1229 Handle obj = read_oop(stream, read_tag, JVMCI_CHECK); 1230 pd_patch_OopConstant(pc_offset, obj, narrow, JVMCI_CHECK); 1231 break; 1232 } 1233 case PATCH_METHOD: 1234 case PATCH_KLASS: 1235 case PATCH_NARROW_KLASS: { 1236 pd_patch_MetaspaceConstant(pc_offset, stream, tag, JVMCI_CHECK); 1237 break; 1238 } 1239 case PATCH_DATA_SECTION_REFERENCE: { 1240 int data_offset = stream->read_u4("data:offset"); 1241 if (0 <= data_offset && data_offset < _constants_size) { 1242 if (!is_aligned(data_offset, CompilerToVM::Data::get_data_section_item_alignment())) { 1243 JVMCI_ERROR("data offset 0x%x is not %d-byte aligned%s", data_offset, relocInfo::addr_unit(), stream->context()); 1244 } 1245 pd_patch_DataSectionReference(pc_offset, data_offset, JVMCI_CHECK); 1246 } else { 1247 JVMCI_ERROR("data offset 0x%x points outside data section (size 0x%x)%s", data_offset, _constants_size, stream->context()); 1248 } 1249 break; 1250 } 1251 default: { 1252 JVMCI_ERROR("unknown data patch tag: %d%s", tag, stream->context()); 1253 } 1254 } 1255 } 1256 1257 void CodeInstaller::site_Mark(CodeBuffer& buffer, jint pc_offset, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) { 1258 u1 id = stream->read_u1("mark:id"); 1259 address pc = _instructions->start() + pc_offset; 1260 1261 switch (id) { 1262 case UNVERIFIED_ENTRY: 1263 _offsets.set_value(CodeOffsets::Entry, pc_offset); 1264 break; 1265 case VERIFIED_ENTRY: 1266 _offsets.set_value(CodeOffsets::Verified_Entry, pc_offset); 1267 _offsets.set_value(CodeOffsets::Verified_Inline_Entry, pc_offset); 1268 _offsets.set_value(CodeOffsets::Verified_Inline_Entry_RO, pc_offset); 1269 break; 1270 case OSR_ENTRY: 1271 _offsets.set_value(CodeOffsets::OSR_Entry, pc_offset); 1272 break; 1273 case EXCEPTION_HANDLER_ENTRY: 1274 _offsets.set_value(CodeOffsets::Exceptions, pc_offset); 1275 break; 1276 case DEOPT_HANDLER_ENTRY: 1277 _offsets.set_value(CodeOffsets::Deopt, pc_offset); 1278 break; 1279 case DEOPT_MH_HANDLER_ENTRY: 1280 _offsets.set_value(CodeOffsets::DeoptMH, pc_offset); 1281 break; 1282 case FRAME_COMPLETE: 1283 _offsets.set_value(CodeOffsets::Frame_Complete, pc_offset); 1284 break; 1285 case ENTRY_BARRIER_PATCH: 1286 _nmethod_entry_patch_offset = pc_offset; 1287 break; 1288 case INVOKEVIRTUAL: 1289 case INVOKEINTERFACE: 1290 case INLINE_INVOKE: 1291 case INVOKESTATIC: 1292 case INVOKESPECIAL: 1293 _next_call_type = (MarkId) id; 1294 _invoke_mark_pc = pc; 1295 break; 1296 case POLL_NEAR: 1297 case POLL_FAR: 1298 case POLL_RETURN_NEAR: 1299 case POLL_RETURN_FAR: 1300 pd_relocate_poll(pc, id, JVMCI_CHECK); 1301 break; 1302 case CARD_TABLE_SHIFT: 1303 case CARD_TABLE_ADDRESS: 1304 case HEAP_TOP_ADDRESS: 1305 case HEAP_END_ADDRESS: 1306 case NARROW_KLASS_BASE_ADDRESS: 1307 case NARROW_OOP_BASE_ADDRESS: 1308 case CRC_TABLE_ADDRESS: 1309 case LOG_OF_HEAP_REGION_GRAIN_BYTES: 1310 case INLINE_CONTIGUOUS_ALLOCATION_SUPPORTED: 1311 case VERIFY_OOPS: 1312 case VERIFY_OOP_BITS: 1313 case VERIFY_OOP_MASK: 1314 case VERIFY_OOP_COUNT_ADDRESS: 1315 break; 1316 default: 1317 JVMCI_ERROR("invalid mark id: %d%s", id, stream->context()); 1318 break; 1319 } 1320 }