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/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   return CompressedKlassPointers::encode(klass);
 347 }
 348 #endif
 349 
 350 ScopeValue* CodeInstaller::to_primitive_value(HotSpotCompiledCodeStream* stream, jlong raw, BasicType type, ScopeValue* &second, JVMCI_TRAPS) {
 351   if (type == T_INT || type == T_FLOAT) {
 352     jint prim = (jint) raw;
 353     switch (prim) {
 354       case -1: return _int_m1_scope_value;
 355       case  0: return _int_0_scope_value;
 356       case  1: return _int_1_scope_value;
 357       case  2: return _int_2_scope_value;
 358       default: return new ConstantIntValue(prim);
 359     }
 360   } else if (type == T_LONG || type == T_DOUBLE) {
 361     jlong prim = raw;
 362     second = _int_1_scope_value;
 363     return new ConstantLongValue(prim);
 364   } else {
 365     JVMCI_ERROR_NULL("unexpected primitive constant type %s%s", basictype_to_str(type), stream->context());
 366   }
 367 }
 368 
 369 Handle CodeInstaller::read_oop(HotSpotCompiledCodeStream* stream, u1 tag, JVMCI_TRAPS) {
 370   oop obj;
 371   if (tag == OBJECT_ID) {
 372     obj = stream->get_oop(stream->read_u1("id"), JVMCI_CHECK_(Handle()));
 373   } else if (tag == OBJECT_ID2) {
 374     obj = stream->get_oop(stream->read_u2("id:2"), JVMCI_CHECK_(Handle()));
 375   } else if (tag == JOBJECT) {
 376     jlong object_handle = stream->read_u8("jobject");
 377     obj = jvmci_env()->resolve_oop_handle(object_handle);
 378   } else {
 379     JVMCI_ERROR_(Handle(), "unexpected oop tag: %d", tag)
 380   }
 381   if (obj == nullptr) {
 382     JVMCI_THROW_MSG_(InternalError, "Constant was unexpectedly null", Handle());
 383   } else {
 384     guarantee(oopDesc::is_oop_or_null(obj), "invalid oop: " INTPTR_FORMAT, p2i((oopDesc*) obj));
 385   }
 386   return Handle(stream->thread(), obj);
 387 }
 388 
 389 ScopeValue* CodeInstaller::get_scope_value(HotSpotCompiledCodeStream* stream, u1 tag, BasicType type, ScopeValue* &second, JVMCI_TRAPS) {
 390   second = nullptr;
 391   switch (tag) {
 392     case ILLEGAL: {
 393       if (type != T_ILLEGAL) {
 394         JVMCI_ERROR_NULL("unexpected illegal value, expected %s%s", basictype_to_str(type), stream->context());
 395       }
 396       return _illegal_value;
 397     }
 398     case REGISTER_PRIMITIVE:
 399     case REGISTER_NARROW_OOP:
 400     case REGISTER_OOP:
 401     case REGISTER_VECTOR: {
 402       u2 number = stream->read_u2("register");
 403       VMReg hotspotRegister = get_hotspot_reg(number, JVMCI_CHECK_NULL);
 404       if (is_general_purpose_reg(hotspotRegister)) {
 405         Location::Type locationType;
 406         if (type == T_OBJECT) {
 407           locationType = tag == REGISTER_NARROW_OOP ? Location::narrowoop : Location::oop;
 408         } else if (type == T_LONG) {
 409           locationType = Location::lng;
 410         } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) {
 411           locationType = Location::int_in_long;
 412         } else {
 413           JVMCI_ERROR_NULL("unexpected type %s in CPU register%s", basictype_to_str(type), stream->context());
 414         }
 415         ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));
 416         if (type == T_LONG) {
 417           second = value;
 418         }
 419         return value;
 420       } else {
 421         Location::Type locationType;
 422         if (type == T_FLOAT) {
 423           // this seems weird, but the same value is used in c1_LinearScan
 424           locationType = Location::normal;
 425         } else if (type == T_DOUBLE) {
 426           locationType = Location::dbl;
 427         } else if (type == T_OBJECT && tag == REGISTER_VECTOR) {
 428           locationType = Location::vector;
 429         } else {
 430           JVMCI_ERROR_NULL("unexpected type %s in floating point register%s", basictype_to_str(type), stream->context());
 431         }
 432         ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));
 433         if (type == T_DOUBLE) {
 434           second = value;
 435         }
 436         return value;
 437       }
 438     }
 439     case STACK_SLOT_PRIMITIVE:
 440     case STACK_SLOT_NARROW_OOP:
 441     case STACK_SLOT_OOP:
 442     case STACK_SLOT_VECTOR: {
 443       jint offset = (jshort) stream->read_s2("offset");
 444       if (stream->read_bool("addRawFrameSize")) {
 445         offset += _total_frame_size;
 446       }
 447       Location::Type locationType;
 448       if (type == T_OBJECT) {
 449         locationType = tag == STACK_SLOT_VECTOR ? Location::vector : tag == STACK_SLOT_NARROW_OOP ? Location::narrowoop : Location::oop;
 450       } else if (type == T_LONG) {
 451         locationType = Location::lng;
 452       } else if (type == T_DOUBLE) {
 453         locationType = Location::dbl;
 454       } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) {
 455         locationType = Location::normal;
 456       } else {
 457         JVMCI_ERROR_NULL("unexpected type %s in stack slot%s", basictype_to_str(type), stream->context());
 458       }
 459       ScopeValue* value = new LocationValue(Location::new_stk_loc(locationType, offset));
 460       if (type == T_DOUBLE || type == T_LONG) {
 461         second = value;
 462       }
 463       return value;
 464     }
 465     case NULL_CONSTANT:      { return _oop_null_scope_value; }
 466     case RAW_CONSTANT:       { return new ConstantLongValue(stream->read_u8("primitive")); }
 467     case PRIMITIVE_0:        { ScopeValue* v = to_primitive_value(stream, 0, type, second, JVMCI_CHECK_NULL); return v; }
 468     case PRIMITIVE4:         { ScopeValue* v = to_primitive_value(stream, stream->read_s4("primitive4"), type, second, JVMCI_CHECK_NULL); return v; }
 469     case PRIMITIVE8:         { ScopeValue* v = to_primitive_value(stream, stream->read_s8("primitive8"), type, second, JVMCI_CHECK_NULL); return v; }
 470     case VIRTUAL_OBJECT_ID:  { ScopeValue* v = stream->virtual_object_at(stream->read_u1("id"),   JVMCI_CHECK_NULL); return v; }
 471     case VIRTUAL_OBJECT_ID2: { ScopeValue* v = stream->virtual_object_at(stream->read_u2("id:2"), JVMCI_CHECK_NULL); return v; }
 472 
 473     case OBJECT_ID:
 474     case OBJECT_ID2:
 475     case JOBJECT: {
 476       Handle obj = read_oop(stream, tag, JVMCI_CHECK_NULL);
 477       return new ConstantOopWriteValue(JNIHandles::make_local(obj()));
 478     }
 479     default: {
 480       JVMCI_ERROR_NULL("unexpected tag in scope: %d%s", tag, stream->context())
 481     }
 482   }
 483 }
 484 
 485 void CodeInstaller::record_object_value(ObjectValue* sv, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) {
 486   oop javaMirror = JNIHandles::resolve(sv->klass()->as_ConstantOopWriteValue()->value());
 487   Klass* klass = java_lang_Class::as_Klass(javaMirror);
 488   bool isLongArray = klass == Universe::longArrayKlass();
 489   bool isByteArray = klass == Universe::byteArrayKlass();
 490 
 491   u2 length = stream->read_u2("values:length");
 492   for (jint i = 0; i < length; i++) {
 493     ScopeValue* cur_second = nullptr;
 494     BasicType type = (BasicType) stream->read_u1("basicType");
 495     ScopeValue* value;
 496     u1 tag = stream->read_u1("tag");
 497     if (tag == ILLEGAL) {
 498       if (isByteArray && type == T_ILLEGAL) {
 499         /*
 500          * The difference between a virtualized large access and a deferred write is the kind stored in the slotKinds
 501          * of the virtual object: in the virtualization case, the kind is illegal, in the deferred write case, the kind
 502          * is access stack kind (an int).
 503          */
 504         value = _virtual_byte_array_marker;
 505       } else {
 506         value = _illegal_value;
 507         if (type == T_DOUBLE || type == T_LONG) {
 508             cur_second = _illegal_value;
 509         }
 510       }
 511     } else {
 512       value = get_scope_value(stream, tag, type, cur_second, JVMCI_CHECK);
 513     }
 514 
 515     if (isLongArray && cur_second == nullptr) {
 516       // we're trying to put ints into a long array... this isn't really valid, but it's used for some optimizations.
 517       // add an int 0 constant
 518       cur_second = _int_0_scope_value;
 519     }
 520 
 521     if (isByteArray && cur_second != nullptr && (type == T_DOUBLE || type == T_LONG)) {
 522       // we are trying to write a long in a byte Array. We will need to count the illegals to restore the type of
 523       // the thing we put inside.
 524       cur_second = nullptr;
 525     }
 526 
 527     if (cur_second != nullptr) {
 528       sv->field_values()->append(cur_second);
 529     }
 530     assert(value != nullptr, "missing value");
 531     sv->field_values()->append(value);
 532   }
 533 }
 534 
 535 GrowableArray<ScopeValue*>* CodeInstaller::read_local_or_stack_values(HotSpotCompiledCodeStream* stream, u1 frame_flags, bool is_locals, JVMCI_TRAPS) {
 536   u2 length;
 537   if (is_locals) {
 538     if (!is_set(frame_flags, DIF_HAS_LOCALS)) {
 539       return nullptr;
 540     }
 541     length = stream->read_u2("numLocals");
 542   } else {
 543     if (!is_set(frame_flags, DIF_HAS_STACK)) {
 544       return nullptr;
 545     }
 546     length = stream->read_u2("numStack");
 547   }
 548   GrowableArray<ScopeValue*>* values = new GrowableArray<ScopeValue*> (length);
 549   for (int i = 0; i < length; i++) {
 550     ScopeValue* second = nullptr;
 551     BasicType type = (BasicType) stream->read_u1("basicType");
 552     u1 tag = stream->read_u1("tag");
 553     ScopeValue* first = get_scope_value(stream, tag, type, second, JVMCI_CHECK_NULL);
 554     if (second != nullptr) {
 555       if (i == length) {
 556         JVMCI_ERROR_NULL("double-slot value not followed by Value.ILLEGAL%s", stream->context());
 557       }
 558       i++;
 559       stream->read_u1("basicType");
 560       tag = stream->read_u1("tag");
 561       if (tag != ILLEGAL) {
 562         JVMCI_ERROR_NULL("double-slot value not followed by Value.ILLEGAL%s", stream->context());
 563       }
 564       values->append(second);
 565     }
 566     values->append(first);
 567   }
 568   return values;
 569 }
 570 
 571 GrowableArray<MonitorValue*>* CodeInstaller::read_monitor_values(HotSpotCompiledCodeStream* stream, u1 frame_flags, JVMCI_TRAPS) {
 572   if (!is_set(frame_flags, DIF_HAS_LOCKS)) {
 573     return nullptr;
 574   }
 575   if (!_has_monitors) {
 576     _has_monitors = true;
 577   }
 578   u2 length = stream->read_u2("numLocks");
 579   GrowableArray<MonitorValue*>* monitors = new GrowableArray<MonitorValue*>(length);
 580   for (int i = 0; i < length; i++) {
 581     bool eliminated = stream->read_bool("isEliminated");
 582     ScopeValue* second = nullptr;
 583     ScopeValue* owner_value = get_scope_value(stream, stream->read_u1("tag"), T_OBJECT, second, JVMCI_CHECK_NULL);
 584     assert(second == nullptr, "monitor cannot occupy two stack slots");
 585 
 586     ScopeValue* lock_data_value = get_scope_value(stream, stream->read_u1("tag"), T_LONG, second, JVMCI_CHECK_NULL);
 587     assert(second == lock_data_value, "monitor is LONG value that occupies two stack slots");
 588     assert(lock_data_value->is_location(), "invalid monitor location");
 589     Location lock_data_loc = ((LocationValue*) lock_data_value)->location();
 590 
 591     monitors->append(new MonitorValue(owner_value, lock_data_loc, eliminated));
 592   }
 593   return monitors;
 594 }
 595 
 596 void CodeInstaller::initialize_dependencies(HotSpotCompiledCodeStream* stream, u1 code_flags, OopRecorder* oop_recorder, JVMCI_TRAPS) {
 597   JavaThread* thread = stream->thread();
 598   CompilerThread* compilerThread = thread->is_Compiler_thread() ? CompilerThread::cast(thread) : nullptr;
 599   _oop_recorder = oop_recorder;
 600   _dependencies = new Dependencies(&_arena, _oop_recorder, compilerThread != nullptr ? compilerThread->log() : nullptr);
 601   if (is_set(code_flags, HCC_HAS_ASSUMPTIONS)) {
 602     u2 length = stream->read_u2("assumptions:length");
 603     for (int i = 0; i < length; ++i) {
 604       u1 tag = stream->read_u1("tag");
 605       switch (tag) {
 606         case NO_FINALIZABLE_SUBCLASS: {
 607           Klass* receiver_type = stream->read_klass("receiverType");
 608           _dependencies->assert_has_no_finalizable_subclasses(receiver_type);
 609           break;
 610         }
 611         case CONCRETE_SUBTYPE: {
 612           Klass* context = stream->read_klass("context");
 613           Klass* subtype = stream->read_klass("subtype");
 614           assert(context->is_abstract(), "must be");
 615           _dependencies->assert_abstract_with_unique_concrete_subtype(context, subtype);
 616           break;
 617         }
 618         case LEAF_TYPE: {
 619           Klass* context = stream->read_klass("context");
 620           _dependencies->assert_leaf_type(context);
 621           break;
 622         }
 623         case CONCRETE_METHOD: {
 624           Klass* context = stream->read_klass("context");
 625           Method* impl = stream->read_method("impl");
 626           _dependencies->assert_unique_concrete_method(context, impl);
 627           break;
 628         }
 629         case CALLSITE_TARGET_VALUE: {
 630           u1 obj_tag = stream->read_u1("tag");
 631           Handle callSite = read_oop(stream, obj_tag, JVMCI_CHECK);
 632           obj_tag = stream->read_u1("tag");
 633           Handle methodHandle = read_oop(stream, obj_tag, JVMCI_CHECK);
 634           _dependencies->assert_call_site_target_value(callSite(), methodHandle());
 635           break;
 636         }
 637         default: {
 638           JVMCI_ERROR("unexpected assumption tag %d%s", tag, stream->context());
 639         }
 640       }
 641     }
 642   }
 643   if (is_set(code_flags, HCC_HAS_METHODS)) {
 644     u2 length = stream->read_u2("methods:length");
 645     for (int i = 0; i < length; ++i) {
 646       Method* method = stream->read_method("method");
 647       if (JvmtiExport::can_hotswap_or_post_breakpoint()) {
 648         _dependencies->assert_evol_method(method);
 649       }
 650     }
 651   }
 652 }
 653 
 654 JVMCI::CodeInstallResult CodeInstaller::install_runtime_stub(CodeBlob*& cb,
 655                                                              const char* name,
 656                                                              CodeBuffer* buffer,
 657                                                              int stack_slots,
 658                                                              JVMCI_TRAPS) {
 659   if (name == nullptr) {
 660     JVMCI_ERROR_OK("stub should have a name");
 661   }
 662 
 663   name = os::strdup(name);
 664   GrowableArray<RuntimeStub*> *stubs_to_free = nullptr;
 665 #ifdef ASSERT
 666   const char* val = Arguments::PropertyList_get_value(Arguments::system_properties(), "test.jvmci.forceRuntimeStubAllocFail");
 667   if (val != nullptr && strstr(name , val) != 0) {
 668     stubs_to_free = new GrowableArray<RuntimeStub*>();
 669     JVMCI_event_1("forcing allocation of %s in code cache to fail", name);
 670   }
 671 #endif
 672 
 673   do {
 674     RuntimeStub* stub = RuntimeStub::new_runtime_stub(name,
 675                                        buffer,
 676                                        _offsets.value(CodeOffsets::Frame_Complete),
 677                                        stack_slots,
 678                                        _debug_recorder->_oopmaps,
 679                                        /* caller_must_gc_arguments */ false,
 680                                        /* alloc_fail_is_fatal */ false);
 681     cb = stub;
 682     if (stub == nullptr) {
 683       // Allocation failed
 684 #ifdef ASSERT
 685       if (stubs_to_free != nullptr) {
 686         JVMCI_event_1("allocation of %s in code cache failed, freeing %d stubs", name, stubs_to_free->length());
 687         for (GrowableArrayIterator<RuntimeStub*> iter = stubs_to_free->begin(); iter != stubs_to_free->end(); ++iter) {
 688           RuntimeStub::free(*iter);
 689         }
 690       }
 691 #endif
 692       return JVMCI::cache_full;
 693     }
 694     if (stubs_to_free == nullptr) {
 695       return JVMCI::ok;
 696     }
 697     stubs_to_free->append(stub);
 698   } while (true);
 699 }
 700 
 701 JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler,
 702     jlong compiled_code_buffer,
 703     bool with_type_info,
 704     JVMCIObject compiled_code,
 705     objArrayHandle object_pool,
 706     CodeBlob*& cb,
 707     JVMCINMethodHandle& nmethod_handle,
 708     JVMCIObject installed_code,
 709     FailedSpeculation** failed_speculations,
 710     char* speculations,
 711     int speculations_len,
 712     JVMCI_TRAPS) {
 713 
 714   JavaThread* thread = JavaThread::current();
 715   HotSpotCompiledCodeStream* stream = new HotSpotCompiledCodeStream(thread, (const u1*) compiled_code_buffer, with_type_info, object_pool);
 716 
 717   u1 code_flags = stream->read_u1("code:flags");
 718   bool is_nmethod = is_set(code_flags, HCC_IS_NMETHOD);
 719   const char* name = stream->read_utf8("name", JVMCI_CHECK_OK);
 720 
 721   methodHandle method;
 722   jint entry_bci = -1;
 723   JVMCICompileState* compile_state = nullptr;
 724   bool has_unsafe_access = false;
 725   jint id = -1;
 726 
 727   if (is_nmethod) {
 728     method = methodHandle(thread, stream->read_method("method"));
 729     entry_bci = is_nmethod ? stream->read_s4("entryBCI") : -1;
 730     compile_state = (JVMCICompileState*) stream->read_u8("compileState");
 731     has_unsafe_access = stream->read_bool("hasUnsafeAccess");
 732     id = stream->read_s4("id");
 733   }
 734   stream->set_code_desc(name, method);
 735 
 736   CodeBuffer buffer("JVMCI Compiler CodeBuffer");
 737   OopRecorder* recorder = new OopRecorder(&_arena, true);
 738   initialize_dependencies(stream, code_flags, recorder, JVMCI_CHECK_OK);
 739 
 740   // Get instructions and constants CodeSections early because we need it.
 741   _instructions = buffer.insts();
 742   _constants = buffer.consts();
 743 
 744   initialize_fields(stream, code_flags, method, buffer, JVMCI_CHECK_OK);
 745   JVMCI::CodeInstallResult result = initialize_buffer(compiled_code, buffer, stream, code_flags, JVMCI_CHECK_OK);
 746 
 747   u4 available = stream->available();
 748   if (result == JVMCI::ok && available != 0) {
 749     JVMCI_ERROR_OK("%d bytes remaining in stream%s", available, stream->context());
 750   }
 751 
 752   if (result != JVMCI::ok) {
 753     return result;
 754   }
 755 
 756   int stack_slots = _total_frame_size / HeapWordSize; // conversion to words
 757 
 758   if (!is_nmethod) {
 759     return install_runtime_stub(cb, name, &buffer, stack_slots, JVMCI_CHECK_OK);
 760   } else {
 761     if (compile_state != nullptr) {
 762       jvmci_env()->set_compile_state(compile_state);
 763     }
 764 
 765     if (id == -1) {
 766       // Make sure a valid compile_id is associated with every compile
 767       id = CompileBroker::assign_compile_id_unlocked(thread, method, entry_bci);
 768       jvmci_env()->set_HotSpotCompiledNmethod_id(compiled_code, id);
 769     }
 770     if (!jvmci_env()->isa_HotSpotNmethod(installed_code)) {
 771       JVMCI_THROW_MSG_(IllegalArgumentException, "InstalledCode object must be a HotSpotNmethod when installing a HotSpotCompiledNmethod", JVMCI::ok);
 772     }
 773 
 774     // Enforce that compiled methods have an nmethod barrier.
 775     if (_nmethod_entry_patch_offset == -1) {
 776       JVMCI_THROW_MSG_(IllegalArgumentException, "nmethod entry barrier is missing", JVMCI::ok);
 777     }
 778 
 779     JVMCIObject mirror = installed_code;
 780     nmethod* nm = nullptr; // nm is an out parameter of register_method
 781     result = runtime()->register_method(jvmci_env(),
 782                                         method,
 783                                         nm,
 784                                         entry_bci,
 785                                         &_offsets,
 786                                         _orig_pc_offset,
 787                                         &buffer,
 788                                         stack_slots,
 789                                         _debug_recorder->_oopmaps,
 790                                         &_exception_handler_table,
 791                                         &_implicit_exception_table,
 792                                         compiler,
 793                                         _debug_recorder,
 794                                         _dependencies,
 795                                         id,
 796                                         _has_monitors,
 797                                         has_unsafe_access,
 798                                         _has_wide_vector,
 799                                         compiled_code,
 800                                         mirror,
 801                                         failed_speculations,
 802                                         speculations,
 803                                         speculations_len,
 804                                         _nmethod_entry_patch_offset);
 805     if (result == JVMCI::ok) {
 806       guarantee(nm != nullptr, "successful compile must produce an nmethod");
 807       nmethod_handle.set_nmethod(nm);
 808       cb = nm;
 809       if (compile_state == nullptr) {
 810         // This compile didn't come through the CompileBroker so perform the printing here
 811         DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, compiler);
 812         nm->maybe_print_nmethod(directive);
 813         DirectivesStack::release(directive);
 814       }
 815 
 816       BarrierSetNMethod* bs_nm = BarrierSet::barrier_set()->barrier_set_nmethod();
 817 
 818       // an empty error buffer for use by the verify_barrier code
 819       err_msg msg("");
 820       if (!bs_nm->verify_barrier(nm, msg)) {
 821         JVMCI_THROW_MSG_(IllegalArgumentException, err_msg("nmethod entry barrier is malformed: %s", msg.buffer()), JVMCI::ok);
 822       }
 823     }
 824   }
 825 
 826   if (cb != nullptr) {
 827     // Make sure the pre-calculated constants section size was correct.
 828     guarantee((cb->code_begin() - cb->content_begin()) >= _constants_size, "%d < %d", (int)(cb->code_begin() - cb->content_begin()), _constants_size);
 829   }
 830   return result;
 831 }
 832 
 833 void CodeInstaller::initialize_fields(HotSpotCompiledCodeStream* stream, u1 code_flags, methodHandle& method, CodeBuffer& buffer, JVMCI_TRAPS) {
 834   if (!method.is_null()) {
 835     _parameter_count = method->size_of_parameters();
 836     JVMCI_event_2("installing code for %s", method->name_and_sig_as_C_string());
 837   } else {
 838     // Must be a HotSpotCompiledCode for a stub.
 839     // Only used in OopMap constructor for non-product builds
 840     _parameter_count = 0;
 841   }
 842   _sites_count = stream->read_s4("sites:length");
 843   _code_size = stream->read_s4("targetCodeSize");
 844   _total_frame_size = stream->read_s4("totalFrameSize");
 845   if (!is_set(code_flags, HCC_HAS_DEOPT_RESCUE_SLOT)) {
 846     _orig_pc_offset = -1;
 847   } else {
 848     _orig_pc_offset = stream->read_s2("offset");
 849     if (stream->read_bool("addRawFrameSize")) {
 850       _orig_pc_offset += _total_frame_size;
 851     }
 852     if (_orig_pc_offset < 0) {
 853       JVMCI_ERROR("invalid deopt rescue slot: %d%s", _orig_pc_offset, stream->context());
 854     }
 855   }
 856 
 857   // Pre-calculate the constants section size.  This is required for PC-relative addressing.
 858   u4 data_section_size = stream->read_u4("dataSectionSize");
 859   u1 data_section_alignment = stream->read_u1("dataSectionAlignment");
 860   buffer.set_const_section_alignment(data_section_alignment);
 861   if ((_constants->alignment() % data_section_alignment) != 0) {
 862     JVMCI_ERROR("invalid data section alignment: %d [constants alignment: %d]%s",
 863         data_section_alignment, _constants->alignment(), stream->context());
 864   }
 865   _constants_size = data_section_size;
 866   _next_call_type = INVOKE_INVALID;
 867   _has_monitors = false;
 868   _has_wide_vector = false;
 869   _nmethod_entry_patch_offset = -1;
 870 }
 871 
 872 u1 CodeInstaller::as_read_oop_tag(HotSpotCompiledCodeStream* stream, u1 patch_object_tag, JVMCI_TRAPS) {
 873   switch (patch_object_tag) {
 874     case PATCH_OBJECT_ID:
 875     case PATCH_NARROW_OBJECT_ID: {
 876       return OBJECT_ID;
 877     }
 878     case PATCH_OBJECT_ID2:
 879     case PATCH_NARROW_OBJECT_ID2: {
 880       return OBJECT_ID2;
 881     }
 882     case PATCH_NARROW_JOBJECT:
 883     case PATCH_JOBJECT: {
 884       return JOBJECT;
 885     }
 886     default: {
 887       JVMCI_ERROR_0("unknown object patch tag: %d%s", patch_object_tag, stream->context());
 888     }
 889   }
 890 }
 891 
 892 int CodeInstaller::estimate_stubs_size(HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) {
 893   // Estimate the number of static call stubs that might be emitted.
 894   u2 static_call_stubs = stream->read_u2("numStaticCallStubs");
 895   u2 trampoline_stubs = stream->read_u2("numTrampolineStubs");
 896   int size = static_call_stubs * CompiledDirectCall::to_interp_stub_size();
 897   size += trampoline_stubs * CompiledDirectCall::to_trampoline_stub_size();
 898   return size;
 899 }
 900 
 901 // perform data and call relocation on the CodeBuffer
 902 JVMCI::CodeInstallResult CodeInstaller::initialize_buffer(JVMCIObject compiled_code, CodeBuffer& buffer, HotSpotCompiledCodeStream* stream, u1 code_flags, JVMCI_TRAPS) {
 903   JavaThread* thread = stream->thread();
 904   HandleMark hm(thread);
 905   int locs_buffer_size = _sites_count * (relocInfo::length_limit + sizeof(relocInfo));
 906 
 907 
 908   // Allocate enough space in the stub section for the static call
 909   // stubs.  Stubs have extra relocs but they are managed by the stub
 910   // section itself so they don't need to be accounted for in the
 911   // locs_buffer above.
 912   int stubs_size = estimate_stubs_size(stream, JVMCI_CHECK_OK);
 913 
 914   assert((CodeBuffer::SECT_INSTS == CodeBuffer::SECT_STUBS - 1) &&
 915          (CodeBuffer::SECT_CONSTS == CodeBuffer::SECT_INSTS - 1), "sections order: consts, insts, stubs");
 916   // buffer content: [constants + code_align] + [code + stubs_align] + [stubs]
 917   int total_size = align_up(_constants_size, buffer.insts()->alignment()) +
 918                    align_up(_code_size, buffer.stubs()->alignment()) +
 919                    stubs_size;
 920 
 921   if (total_size > JVMCINMethodSizeLimit) {
 922     return JVMCI::code_too_large;
 923   }
 924 
 925   buffer.initialize(total_size, locs_buffer_size);
 926   if (buffer.blob() == nullptr) {
 927     return JVMCI::cache_full;
 928   }
 929   buffer.initialize_stubs_size(stubs_size);
 930   buffer.initialize_consts_size(_constants_size);
 931 
 932   _debug_recorder = new DebugInformationRecorder(_oop_recorder);
 933   _debug_recorder->set_oopmaps(new OopMapSet());
 934 
 935   buffer.initialize_oop_recorder(_oop_recorder);
 936 
 937   // copy the constant data into the newly created CodeBuffer
 938   address end_data = _constants->start() + _constants_size;
 939   JVMCIObject data_section = jvmci_env()->get_HotSpotCompiledCode_dataSection(compiled_code);
 940   JVMCIENV->copy_bytes_to(data_section, (jbyte*) _constants->start(), 0, _constants_size);
 941   _constants->set_end(end_data);
 942 
 943   // copy the code into the newly created CodeBuffer
 944   address end_pc = _instructions->start() + _code_size;
 945   guarantee(_instructions->allocates2(end_pc), "initialize should have reserved enough space for all the code");
 946 
 947   JVMCIPrimitiveArray code = jvmci_env()->get_HotSpotCompiledCode_targetCode(compiled_code);
 948   JVMCIENV->copy_bytes_to(code, (jbyte*) _instructions->start(), 0, _code_size);
 949   _instructions->set_end(end_pc);
 950 
 951 
 952   u2 length = stream->read_u2("dataSectionPatches:length");
 953   for (int i = 0; i < length; i++) {
 954     address dest = _constants->start() + stream->read_u4("patch:pcOffset");
 955     u1 tag = stream->read_u1("tag");
 956 
 957     switch (tag) {
 958       case PATCH_METHOD:
 959       case PATCH_KLASS: {
 960         *((void**) dest) = record_metadata_reference(_constants, dest, stream, tag, JVMCI_CHECK_OK);
 961         break;
 962       }
 963       case PATCH_NARROW_KLASS: {
 964 #ifdef _LP64
 965         *((narrowKlass*) dest) = record_narrow_metadata_reference(_constants, dest, stream, tag, JVMCI_CHECK_OK);
 966 #else
 967         JVMCI_ERROR_OK("unexpected compressed Klass* in 32-bit mode");
 968 #endif
 969         break;
 970       }
 971       case PATCH_OBJECT_ID:
 972       case PATCH_OBJECT_ID2:
 973       case PATCH_NARROW_OBJECT_ID:
 974       case PATCH_NARROW_OBJECT_ID2:
 975       case PATCH_JOBJECT:
 976       case PATCH_NARROW_JOBJECT: {
 977         bool narrow = tag == PATCH_NARROW_OBJECT_ID || tag == PATCH_NARROW_OBJECT_ID2  || tag == PATCH_NARROW_JOBJECT;
 978         u1 read_tag = as_read_oop_tag(stream, tag, JVMCI_CHECK_OK);
 979         record_oop_patch(stream, dest, read_tag, narrow, JVMCI_CHECK_OK);
 980         break;
 981       }
 982       default: {
 983         JVMCI_ERROR_OK("invalid constant tag: %d%s", tag, stream->context());
 984         break;
 985       }
 986     }
 987   }
 988 
 989   jint last_pc_offset = -1;
 990   for (int i = 0; i < _sites_count; i++) {
 991     u4 pc_offset = stream->read_s4("site:pcOffset");
 992     u1 tag = stream->read_u1("tag");
 993     switch (tag) {
 994       case SITE_FOREIGN_CALL:
 995       case SITE_FOREIGN_CALL_NO_DEBUG_INFO:
 996       case SITE_CALL: {
 997         site_Call(buffer, tag, pc_offset, stream, JVMCI_CHECK_OK);
 998         break;
 999       }
1000       case SITE_SAFEPOINT:
1001       case SITE_IMPLICIT_EXCEPTION:
1002       case SITE_IMPLICIT_EXCEPTION_DISPATCH: {
1003         site_Safepoint(buffer, pc_offset, stream, tag, JVMCI_CHECK_OK);
1004         break;
1005       }
1006       case SITE_INFOPOINT: {
1007         site_Infopoint(buffer, pc_offset, stream, JVMCI_CHECK_OK);
1008         break;
1009       }
1010       case SITE_MARK: {
1011         site_Mark(buffer, pc_offset, stream, JVMCI_CHECK_OK);
1012         break;
1013       }
1014       case SITE_DATA_PATCH: {
1015         site_DataPatch(buffer, pc_offset, stream, JVMCI_CHECK_OK);
1016         break;
1017       }
1018       case SITE_EXCEPTION_HANDLER: {
1019         site_ExceptionHandler(pc_offset, stream);
1020         break;
1021       }
1022       default: {
1023         JVMCI_ERROR_OK("unexpected site tag at " INTPTR_FORMAT ": %d", p2i(stream->pos() - 1), tag);
1024       }
1025     }
1026 
1027     last_pc_offset = pc_offset;
1028 
1029     if ((i % 32 == 0) && SafepointMechanism::should_process(thread)) {
1030       // Force a safepoint to mitigate pause time installing large code
1031       ThreadToNativeFromVM ttnfv(thread);
1032     }
1033   }
1034 
1035   if (is_set(code_flags, HCC_HAS_COMMENTS)) {
1036     u2 length = stream->read_u2("comments:length");
1037     for (int i = 0; i < length; i++) {
1038       u4 pc_offset = stream->read_u4("comment:pcOffset");
1039       const char* text = stream->read_utf8("comment:text", JVMCI_CHECK_OK);
1040 #ifndef PRODUCT
1041       buffer.block_comment(pc_offset, text);
1042 #endif
1043     }
1044   }
1045   if (_has_auto_box) {
1046     JavaThread* THREAD = thread; // For exception macros.
1047     JVMCI::ensure_box_caches_initialized(CHECK_(JVMCI::ok));
1048   }
1049   return JVMCI::ok;
1050 }
1051 
1052 void CodeInstaller::record_oop_patch(HotSpotCompiledCodeStream* stream, address dest, u1 read_tag, bool narrow, JVMCI_TRAPS) {
1053   Handle obj = read_oop(stream, read_tag, JVMCI_CHECK);
1054   jobject value = JNIHandles::make_local(obj());
1055   int oop_index = _oop_recorder->find_index(value);
1056   if (narrow) {
1057 #ifdef _LP64
1058     _constants->relocate(dest, oop_Relocation::spec(oop_index), relocInfo::narrow_oop_in_const);
1059 #else
1060     JVMCI_ERROR("unexpected compressed oop in 32-bit mode");
1061 #endif
1062   } else {
1063     _constants->relocate(dest, oop_Relocation::spec(oop_index));
1064   }
1065 }
1066 
1067 void CodeInstaller::site_ExceptionHandler(jint pc_offset, HotSpotCompiledCodeStream* stream) {
1068   u4 handler_offset = stream->read_u4("site:handlerPos");
1069 
1070   // Subtable header
1071   _exception_handler_table.add_entry(HandlerTableEntry(1, pc_offset, 0));
1072 
1073   // Subtable entry
1074   _exception_handler_table.add_entry(HandlerTableEntry(-1, handler_offset, 0));
1075 }
1076 
1077 void CodeInstaller::read_virtual_objects(HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) {
1078   u2 length = stream->read_u2("virtualObjects:length");
1079   if (length == 0) {
1080     return;
1081   }
1082   GrowableArray<ScopeValue*> *objects = new GrowableArray<ScopeValue*>(length, length, nullptr);
1083   stream->set_virtual_objects(objects);
1084   // Create the unique ObjectValues
1085   JavaThread* thread = stream->thread();
1086   for (int id = 0; id < length; id++) {
1087     Klass* klass = stream->read_klass("type");
1088     bool is_auto_box = stream->read_bool("isAutoBox");
1089     if (is_auto_box) {
1090       _has_auto_box = true;
1091     }
1092     oop javaMirror = klass->java_mirror();
1093     ScopeValue *klass_sv = new ConstantOopWriteValue(JNIHandles::make_local(javaMirror));
1094     ObjectValue* sv = is_auto_box ? new AutoBoxObjectValue(id, klass_sv) : new ObjectValue(id, klass_sv);
1095     objects->at_put(id, sv);
1096   }
1097   // All the values which could be referenced by the VirtualObjects
1098   // exist, so now describe all the VirtualObjects themselves.
1099   for (int id = 0; id < length; id++) {
1100     record_object_value(objects->at(id)->as_ObjectValue(), stream, JVMCI_CHECK);
1101   }
1102   _debug_recorder->dump_object_pool(objects);
1103 
1104   stream->set_virtual_objects(objects);
1105 }
1106 
1107 int CodeInstaller::map_jvmci_bci(int bci) {
1108   if (bci < 0) {
1109     switch (bci) {
1110       case BEFORE_BCI: return BeforeBci;
1111       case AFTER_BCI: return AfterBci;
1112       case UNWIND_BCI: return UnwindBci;
1113       case AFTER_EXCEPTION_BCI: return AfterExceptionBci;
1114       case UNKNOWN_BCI: return UnknownBci;
1115       case INVALID_FRAMESTATE_BCI: return InvalidFrameStateBci;
1116     }
1117     ShouldNotReachHere();
1118   }
1119   return bci;
1120 }
1121 
1122 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) {
1123   if (full_info) {
1124     read_virtual_objects(stream, JVMCI_CHECK);
1125   }
1126   if (is_set(debug_info_flags, DI_HAS_FRAMES)) {
1127     u2 depth = stream->read_u2("depth");
1128     for (int i = 0; i < depth; i++) {
1129       Thread* thread = Thread::current();
1130       methodHandle method(thread, stream->read_method("method"));
1131       jint bci = map_jvmci_bci(stream->read_s4("bci"));
1132       if (bci == BEFORE_BCI) {
1133         bci = SynchronizationEntryBCI;
1134       }
1135 
1136       JVMCI_event_2("Recording scope pc_offset=%d bci=%d method=%s", pc_offset, bci, method->name_and_sig_as_C_string());
1137 
1138       bool reexecute = false;
1139       bool rethrow_exception = false;
1140 
1141       DebugToken* locals_token = nullptr;
1142       DebugToken* stack_token = nullptr;
1143       DebugToken* monitors_token = nullptr;
1144 
1145       if (full_info) {
1146         u1 frame_flags = stream->read_u1("flags");
1147         rethrow_exception = is_set(frame_flags, DIF_RETHROW_EXCEPTION);
1148 
1149         if (bci >= 0) {
1150           reexecute = !is_set(frame_flags, DIF_DURING_CALL);
1151         }
1152 
1153         GrowableArray<ScopeValue*>* locals = read_local_or_stack_values(stream, frame_flags, true, JVMCI_CHECK);
1154         GrowableArray<ScopeValue*>* stack = read_local_or_stack_values(stream, frame_flags, false, JVMCI_CHECK);
1155         GrowableArray<MonitorValue*>* monitors = read_monitor_values(stream, frame_flags, JVMCI_CHECK);
1156 
1157         locals_token = _debug_recorder->create_scope_values(locals);
1158         stack_token = _debug_recorder->create_scope_values(stack);
1159         monitors_token = _debug_recorder->create_monitor_values(monitors);
1160       }
1161 
1162       // has_ea_local_in_scope and arg_escape should be added to JVMCI
1163       const bool return_scalarized     = false;
1164       const bool has_ea_local_in_scope = false;
1165       const bool arg_escape            = false;
1166       _debug_recorder->describe_scope(pc_offset, method, nullptr, bci, reexecute, rethrow_exception, is_mh_invoke, return_oop,
1167                                       return_scalarized, has_ea_local_in_scope, arg_escape,
1168                                       locals_token, stack_token, monitors_token);
1169     }
1170   }
1171   if (full_info) {
1172     // Clear the virtual objects as they are specific to one DebugInfo
1173     stream->set_virtual_objects(nullptr);
1174   }
1175 }
1176 
1177 void CodeInstaller::site_Safepoint(CodeBuffer& buffer, jint pc_offset, HotSpotCompiledCodeStream* stream, u1 tag, JVMCI_TRAPS) {
1178   u1 flags = stream->read_u1("debugInfo:flags");
1179   OopMap *map = create_oop_map(stream, flags, JVMCI_CHECK);
1180   _debug_recorder->add_safepoint(pc_offset, map);
1181   record_scope(pc_offset, stream, flags, true, JVMCI_CHECK);
1182   _debug_recorder->end_safepoint(pc_offset);
1183   if (_orig_pc_offset < 0) {
1184     JVMCI_ERROR("method contains safepoint, but has no deopt rescue slot");
1185   }
1186   if (tag == SITE_IMPLICIT_EXCEPTION_DISPATCH) {
1187     jint dispatch_offset = stream->read_s4("dispatchOffset");
1188     _implicit_exception_table.append(pc_offset, dispatch_offset);
1189   } else if (tag == SITE_IMPLICIT_EXCEPTION) {
1190     _implicit_exception_table.add_deoptimize(pc_offset);
1191   }
1192 }
1193 
1194 void CodeInstaller::site_Infopoint(CodeBuffer& buffer, jint pc_offset, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) {
1195   u1 flags = stream->read_u1("debugInfo:flags");
1196   _debug_recorder->add_non_safepoint(pc_offset);
1197   record_scope(pc_offset, stream, flags, false, JVMCI_CHECK);
1198   _debug_recorder->end_non_safepoint(pc_offset);
1199 }
1200 
1201 void CodeInstaller::site_Call(CodeBuffer& buffer, u1 tag, jint pc_offset, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) {
1202   JavaThread* thread = stream->thread();
1203   jlong target = stream->read_u8("target");
1204   methodHandle method;
1205   bool direct_call = false;
1206   if (tag == SITE_CALL) {
1207     method = methodHandle(thread, (Method*) target);
1208     assert(Method::is_valid_method(method()), "invalid method");
1209     direct_call = stream->read_bool("direct");
1210     if (method.is_null()) {
1211       JVMCI_THROW(NullPointerException);
1212     }
1213   }
1214 
1215   NativeInstruction* inst = nativeInstruction_at(_instructions->start() + pc_offset);
1216   jint next_pc_offset = CodeInstaller::pd_next_offset(inst, pc_offset, JVMCI_CHECK);
1217 
1218   if (tag != SITE_FOREIGN_CALL_NO_DEBUG_INFO) {
1219     u1 flags = stream->read_u1("debugInfo:flags");
1220     OopMap *map = create_oop_map(stream, flags, JVMCI_CHECK);
1221     _debug_recorder->add_safepoint(next_pc_offset, map);
1222 
1223     if (!method.is_null()) {
1224       vmIntrinsics::ID iid = method->intrinsic_id();
1225       bool is_mh_invoke = false;
1226       if (direct_call) {
1227         is_mh_invoke = !method->is_static() && (iid == vmIntrinsics::_compiledLambdaForm ||
1228                 (MethodHandles::is_signature_polymorphic(iid) && MethodHandles::is_signature_polymorphic_intrinsic(iid)));
1229       }
1230       bool return_oop = method->is_returning_oop();
1231       record_scope(next_pc_offset, stream, flags, true, is_mh_invoke, return_oop, JVMCI_CHECK);
1232     } else {
1233       record_scope(next_pc_offset, stream, flags, true, JVMCI_CHECK);
1234     }
1235   }
1236 
1237   if (tag != SITE_CALL) {
1238     jlong foreign_call_destination = target;
1239     CodeInstaller::pd_relocate_ForeignCall(inst, foreign_call_destination, JVMCI_CHECK);
1240   } else {
1241     CodeInstaller::pd_relocate_JavaMethod(buffer, method, pc_offset, JVMCI_CHECK);
1242     if (_next_call_type == INVOKESTATIC || _next_call_type == INVOKESPECIAL) {
1243       // Need a static call stub for transitions from compiled to interpreted.
1244       MacroAssembler masm(&buffer);
1245       if (CompiledDirectCall::emit_to_interp_stub(&masm, _instructions->start() + pc_offset) == nullptr) {
1246         JVMCI_ERROR("could not emit to_interp stub - code cache is full");
1247       }
1248     }
1249   }
1250 
1251   _next_call_type = INVOKE_INVALID;
1252 
1253   if (tag != SITE_FOREIGN_CALL_NO_DEBUG_INFO) {
1254     _debug_recorder->end_safepoint(next_pc_offset);
1255   }
1256 }
1257 
1258 void CodeInstaller::site_DataPatch(CodeBuffer& buffer, jint pc_offset, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) {
1259   u1 tag = stream->read_u1("tag");
1260   switch (tag) {
1261     case PATCH_OBJECT_ID:
1262     case PATCH_OBJECT_ID2:
1263     case PATCH_NARROW_OBJECT_ID:
1264     case PATCH_NARROW_OBJECT_ID2:
1265     case PATCH_JOBJECT:
1266     case PATCH_NARROW_JOBJECT: {
1267       bool narrow = tag == PATCH_NARROW_OBJECT_ID || tag == PATCH_NARROW_OBJECT_ID2  || tag == PATCH_NARROW_JOBJECT;
1268       u1 read_tag = as_read_oop_tag(stream, tag, JVMCI_CHECK);
1269       Handle obj = read_oop(stream, read_tag, JVMCI_CHECK);
1270       pd_patch_OopConstant(pc_offset, obj, narrow, JVMCI_CHECK);
1271       break;
1272     }
1273     case PATCH_METHOD:
1274     case PATCH_KLASS:
1275     case PATCH_NARROW_KLASS: {
1276       pd_patch_MetaspaceConstant(pc_offset, stream, tag, JVMCI_CHECK);
1277       break;
1278     }
1279     case PATCH_DATA_SECTION_REFERENCE: {
1280       int data_offset = stream->read_u4("data:offset");
1281       if (0 <= data_offset && data_offset < _constants_size) {
1282         if (!is_aligned(data_offset, CompilerToVM::Data::get_data_section_item_alignment())) {
1283           JVMCI_ERROR("data offset 0x%x is not %d-byte aligned%s", data_offset, relocInfo::addr_unit(), stream->context());
1284         }
1285         pd_patch_DataSectionReference(pc_offset, data_offset, JVMCI_CHECK);
1286       } else {
1287         JVMCI_ERROR("data offset 0x%x points outside data section (size 0x%x)%s", data_offset, _constants_size, stream->context());
1288       }
1289       break;
1290     }
1291     default: {
1292       JVMCI_ERROR("unknown data patch tag: %d%s", tag, stream->context());
1293     }
1294   }
1295 }
1296 
1297 void CodeInstaller::site_Mark(CodeBuffer& buffer, jint pc_offset, HotSpotCompiledCodeStream* stream, JVMCI_TRAPS) {
1298   u1 id = stream->read_u1("mark:id");
1299   address pc = _instructions->start() + pc_offset;
1300 
1301   switch (id) {
1302     case UNVERIFIED_ENTRY:
1303       _offsets.set_value(CodeOffsets::Entry, pc_offset);
1304       break;
1305     case VERIFIED_ENTRY:
1306       _offsets.set_value(CodeOffsets::Verified_Entry, pc_offset);
1307       _offsets.set_value(CodeOffsets::Verified_Inline_Entry, pc_offset);
1308       _offsets.set_value(CodeOffsets::Verified_Inline_Entry_RO, pc_offset);
1309       break;
1310     case OSR_ENTRY:
1311       _offsets.set_value(CodeOffsets::OSR_Entry, pc_offset);
1312       break;
1313     case EXCEPTION_HANDLER_ENTRY:
1314       _offsets.set_value(CodeOffsets::Exceptions, pc_offset);
1315       break;
1316     case DEOPT_HANDLER_ENTRY:
1317       _offsets.set_value(CodeOffsets::Deopt, pc_offset);
1318       break;
1319     case DEOPT_MH_HANDLER_ENTRY:
1320       _offsets.set_value(CodeOffsets::DeoptMH, pc_offset);
1321       break;
1322     case FRAME_COMPLETE:
1323       _offsets.set_value(CodeOffsets::Frame_Complete, pc_offset);
1324       break;
1325     case ENTRY_BARRIER_PATCH:
1326       _nmethod_entry_patch_offset = pc_offset;
1327       break;
1328     case INVOKEVIRTUAL:
1329     case INVOKEINTERFACE:
1330     case INLINE_INVOKE:
1331     case INVOKESTATIC:
1332     case INVOKESPECIAL:
1333       _next_call_type = (MarkId) id;
1334       _invoke_mark_pc = pc;
1335       break;
1336     case POLL_NEAR:
1337     case POLL_FAR:
1338     case POLL_RETURN_NEAR:
1339     case POLL_RETURN_FAR:
1340       pd_relocate_poll(pc, id, JVMCI_CHECK);
1341       break;
1342     case CARD_TABLE_SHIFT:
1343     case CARD_TABLE_ADDRESS:
1344     case HEAP_TOP_ADDRESS:
1345     case HEAP_END_ADDRESS:
1346     case NARROW_KLASS_BASE_ADDRESS:
1347     case NARROW_OOP_BASE_ADDRESS:
1348     case CRC_TABLE_ADDRESS:
1349     case LOG_OF_HEAP_REGION_GRAIN_BYTES:
1350     case INLINE_CONTIGUOUS_ALLOCATION_SUPPORTED:
1351     case VERIFY_OOPS:
1352     case VERIFY_OOP_BITS:
1353     case VERIFY_OOP_MASK:
1354     case VERIFY_OOP_COUNT_ADDRESS:
1355       break;
1356     default:
1357       JVMCI_ERROR("invalid mark id: %d%s", id, stream->context());
1358       break;
1359   }
1360 }