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