1 /* 2 * Copyright (c) 2011, 2019, 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 "code/compiledIC.hpp" 26 #include "compiler/compileBroker.hpp" 27 #include "jvmci/jvmciCodeInstaller.hpp" 28 #include "jvmci/jvmciCompilerToVM.hpp" 29 #include "jvmci/jvmciRuntime.hpp" 30 #include "memory/universe.hpp" 31 #include "oops/compressedOops.inline.hpp" 32 #include "runtime/interfaceSupport.inline.hpp" 33 #include "runtime/jniHandles.inline.hpp" 34 #include "runtime/sharedRuntime.hpp" 35 #include "utilities/align.hpp" 36 37 // frequently used constants 38 // Allocate them with new so they are never destroyed (otherwise, a 39 // forced exit could destroy these objects while they are still in 40 // use). 41 ConstantOopWriteValue* CodeInstaller::_oop_null_scope_value = new (ResourceObj::C_HEAP, mtJVMCI) ConstantOopWriteValue(NULL); 42 ConstantIntValue* CodeInstaller::_int_m1_scope_value = new (ResourceObj::C_HEAP, mtJVMCI) ConstantIntValue(-1); 43 ConstantIntValue* CodeInstaller::_int_0_scope_value = new (ResourceObj::C_HEAP, mtJVMCI) ConstantIntValue((jint)0); 44 ConstantIntValue* CodeInstaller::_int_1_scope_value = new (ResourceObj::C_HEAP, mtJVMCI) ConstantIntValue(1); 45 ConstantIntValue* CodeInstaller::_int_2_scope_value = new (ResourceObj::C_HEAP, mtJVMCI) ConstantIntValue(2); 46 LocationValue* CodeInstaller::_illegal_value = new (ResourceObj::C_HEAP, mtJVMCI) LocationValue(Location()); 47 48 VMReg CodeInstaller::getVMRegFromLocation(JVMCIObject location, int total_frame_size, JVMCI_TRAPS) { 49 if (location.is_null()) { 50 JVMCI_THROW_NULL(NullPointerException); 51 } 52 53 JVMCIObject reg = jvmci_env()->get_code_Location_reg(location); 54 jint offset = jvmci_env()->get_code_Location_offset(location); 55 56 if (reg.is_non_null()) { 57 // register 58 jint number = jvmci_env()->get_code_Register_number(reg); 59 VMReg vmReg = CodeInstaller::get_hotspot_reg(number, JVMCI_CHECK_NULL); 60 if (offset % 4 == 0) { 61 return vmReg->next(offset / 4); 62 } else { 63 JVMCI_ERROR_NULL("unaligned subregister offset %d in oop map", offset); 64 } 65 } else { 66 // stack slot 67 if (offset % 4 == 0) { 68 VMReg vmReg = VMRegImpl::stack2reg(offset / 4); 69 if (!OopMapValue::legal_vm_reg_name(vmReg)) { 70 // This restriction only applies to VMRegs that are used in OopMap but 71 // since that's the only use of VMRegs it's simplest to put this test 72 // here. This test should also be equivalent legal_vm_reg_name but JVMCI 73 // clients can use max_oop_map_stack_stack_offset to detect this problem 74 // directly. The asserts just ensure that the tests are in agreement. 75 assert(offset > CompilerToVM::Data::max_oop_map_stack_offset(), "illegal VMReg"); 76 JVMCI_ERROR_NULL("stack offset %d is too large to be encoded in OopMap (max %d)", 77 offset, CompilerToVM::Data::max_oop_map_stack_offset()); 78 } 79 assert(OopMapValue::legal_vm_reg_name(vmReg), "illegal VMReg"); 80 return vmReg; 81 } else { 82 JVMCI_ERROR_NULL("unaligned stack offset %d in oop map", offset); 83 } 84 } 85 } 86 87 // creates a HotSpot oop map out of the byte arrays provided by DebugInfo 88 OopMap* CodeInstaller::create_oop_map(JVMCIObject debug_info, JVMCI_TRAPS) { 89 JVMCIObject reference_map = jvmci_env()->get_DebugInfo_referenceMap(debug_info); 90 if (reference_map.is_null()) { 91 JVMCI_THROW_NULL(NullPointerException); 92 } 93 if (!jvmci_env()->isa_HotSpotReferenceMap(reference_map)) { 94 JVMCI_ERROR_NULL("unknown reference map: %s", jvmci_env()->klass_name(reference_map)); 95 } 96 if (!_has_wide_vector && SharedRuntime::is_wide_vector(jvmci_env()->get_HotSpotReferenceMap_maxRegisterSize(reference_map))) { 97 if (SharedRuntime::polling_page_vectors_safepoint_handler_blob() == NULL) { 98 JVMCI_ERROR_NULL("JVMCI is producing code using vectors larger than the runtime supports"); 99 } 100 _has_wide_vector = true; 101 } 102 OopMap* map = new OopMap(_total_frame_size, _parameter_count); 103 JVMCIObjectArray objects = jvmci_env()->get_HotSpotReferenceMap_objects(reference_map); 104 JVMCIObjectArray derivedBase = jvmci_env()->get_HotSpotReferenceMap_derivedBase(reference_map); 105 JVMCIPrimitiveArray sizeInBytes = jvmci_env()->get_HotSpotReferenceMap_sizeInBytes(reference_map); 106 if (objects.is_null() || derivedBase.is_null() || sizeInBytes.is_null()) { 107 JVMCI_THROW_NULL(NullPointerException); 108 } 109 if (JVMCIENV->get_length(objects) != JVMCIENV->get_length(derivedBase) || JVMCIENV->get_length(objects) != JVMCIENV->get_length(sizeInBytes)) { 110 JVMCI_ERROR_NULL("arrays in reference map have different sizes: %d %d %d", JVMCIENV->get_length(objects), JVMCIENV->get_length(derivedBase), JVMCIENV->get_length(sizeInBytes)); 111 } 112 for (int i = 0; i < JVMCIENV->get_length(objects); i++) { 113 JVMCIObject location = JVMCIENV->get_object_at(objects, i); 114 JVMCIObject baseLocation = JVMCIENV->get_object_at(derivedBase, i); 115 jint bytes = JVMCIENV->get_int_at(sizeInBytes, i); 116 117 VMReg vmReg = getVMRegFromLocation(location, _total_frame_size, JVMCI_CHECK_NULL); 118 if (baseLocation.is_non_null()) { 119 // derived oop 120 #ifdef _LP64 121 if (bytes == 8) { 122 #else 123 if (bytes == 4) { 124 #endif 125 VMReg baseReg = getVMRegFromLocation(baseLocation, _total_frame_size, JVMCI_CHECK_NULL); 126 map->set_derived_oop(vmReg, baseReg); 127 } else { 128 JVMCI_ERROR_NULL("invalid derived oop size in ReferenceMap: %d", bytes); 129 } 130 #ifdef _LP64 131 } else if (bytes == 8) { 132 // wide oop 133 map->set_oop(vmReg); 134 } else if (bytes == 4) { 135 // narrow oop 136 map->set_narrowoop(vmReg); 137 #else 138 } else if (bytes == 4) { 139 map->set_oop(vmReg); 140 #endif 141 } else { 142 JVMCI_ERROR_NULL("invalid oop size in ReferenceMap: %d", bytes); 143 } 144 } 145 146 JVMCIObject callee_save_info = jvmci_env()->get_DebugInfo_calleeSaveInfo(debug_info); 147 if (callee_save_info.is_non_null()) { 148 JVMCIObjectArray registers = jvmci_env()->get_RegisterSaveLayout_registers(callee_save_info); 149 JVMCIPrimitiveArray slots = jvmci_env()->get_RegisterSaveLayout_slots(callee_save_info); 150 for (jint i = 0; i < JVMCIENV->get_length(slots); i++) { 151 JVMCIObject jvmci_reg = JVMCIENV->get_object_at(registers, i); 152 jint jvmci_reg_number = jvmci_env()->get_code_Register_number(jvmci_reg); 153 VMReg hotspot_reg = CodeInstaller::get_hotspot_reg(jvmci_reg_number, JVMCI_CHECK_NULL); 154 // HotSpot stack slots are 4 bytes 155 jint jvmci_slot = JVMCIENV->get_int_at(slots, i); 156 jint hotspot_slot = jvmci_slot * VMRegImpl::slots_per_word; 157 VMReg hotspot_slot_as_reg = VMRegImpl::stack2reg(hotspot_slot); 158 map->set_callee_saved(hotspot_slot_as_reg, hotspot_reg); 159 #ifdef _LP64 160 // (copied from generate_oop_map() in c1_Runtime1_x86.cpp) 161 VMReg hotspot_slot_hi_as_reg = VMRegImpl::stack2reg(hotspot_slot + 1); 162 map->set_callee_saved(hotspot_slot_hi_as_reg, hotspot_reg->next()); 163 #endif 164 } 165 } 166 return map; 167 } 168 169 #if INCLUDE_AOT 170 AOTOopRecorder::AOTOopRecorder(CodeInstaller* code_inst, Arena* arena, bool deduplicate) : OopRecorder(arena, deduplicate) { 171 _code_inst = code_inst; 172 _meta_refs = new GrowableArray<jobject>(); 173 } 174 175 int AOTOopRecorder::nr_meta_refs() const { 176 return _meta_refs->length(); 177 } 178 179 jobject AOTOopRecorder::meta_element(int pos) const { 180 return _meta_refs->at(pos); 181 } 182 183 int AOTOopRecorder::find_index(Metadata* h) { 184 JavaThread* THREAD = JavaThread::current(); 185 JVMCIEnv* JVMCIENV = _code_inst->jvmci_env(); 186 int oldCount = metadata_count(); 187 int index = this->OopRecorder::find_index(h); 188 int newCount = metadata_count(); 189 190 if (oldCount == newCount) { 191 // found a match 192 return index; 193 } 194 195 vmassert(index + 1 == newCount, "must be last"); 196 197 JVMCIKlassHandle klass(THREAD); 198 JVMCIObject result; 199 guarantee(h != NULL, 200 "If DebugInformationRecorder::describe_scope passes NULL oldCount == newCount must hold."); 201 if (h->is_klass()) { 202 klass = (Klass*) h; 203 result = JVMCIENV->get_jvmci_type(klass, JVMCI_CATCH); 204 } else if (h->is_method()) { 205 Method* method = (Method*) h; 206 methodHandle mh(method); 207 result = JVMCIENV->get_jvmci_method(method, JVMCI_CATCH); 208 } 209 jobject ref = JVMCIENV->get_jobject(result); 210 record_meta_ref(ref, index); 211 212 return index; 213 } 214 215 int AOTOopRecorder::find_index(jobject h) { 216 if (h == NULL) { 217 return 0; 218 } 219 oop javaMirror = JNIHandles::resolve(h); 220 Klass* klass = java_lang_Class::as_Klass(javaMirror); 221 return find_index(klass); 222 } 223 224 void AOTOopRecorder::record_meta_ref(jobject o, int index) { 225 assert(index > 0, "must be 1..n"); 226 index -= 1; // reduce by one to convert to array index 227 228 assert(index == _meta_refs->length(), "must be last"); 229 _meta_refs->append(o); 230 } 231 #endif // INCLUDE_AOT 232 233 void* CodeInstaller::record_metadata_reference(CodeSection* section, address dest, JVMCIObject constant, JVMCI_TRAPS) { 234 /* 235 * This method needs to return a raw (untyped) pointer, since the value of a pointer to the base 236 * class is in general not equal to the pointer of the subclass. When patching metaspace pointers, 237 * the compiler expects a direct pointer to the subclass (Klass* or Method*), not a pointer to the 238 * base class (Metadata* or MetaspaceObj*). 239 */ 240 JVMCIObject obj = jvmci_env()->get_HotSpotMetaspaceConstantImpl_metaspaceObject(constant); 241 if (jvmci_env()->isa_HotSpotResolvedObjectTypeImpl(obj)) { 242 Klass* klass = JVMCIENV->asKlass(obj); 243 assert(!jvmci_env()->get_HotSpotMetaspaceConstantImpl_compressed(constant), "unexpected compressed klass pointer %s @ " INTPTR_FORMAT, klass->name()->as_C_string(), p2i(klass)); 244 int index = _oop_recorder->find_index(klass); 245 section->relocate(dest, metadata_Relocation::spec(index)); 246 TRACE_jvmci_3("metadata[%d of %d] = %s", index, _oop_recorder->metadata_count(), klass->name()->as_C_string()); 247 return klass; 248 } else if (jvmci_env()->isa_HotSpotResolvedJavaMethodImpl(obj)) { 249 Method* method = jvmci_env()->asMethod(obj); 250 assert(!jvmci_env()->get_HotSpotMetaspaceConstantImpl_compressed(constant), "unexpected compressed method pointer %s @ " INTPTR_FORMAT, method->name()->as_C_string(), p2i(method)); 251 int index = _oop_recorder->find_index(method); 252 section->relocate(dest, metadata_Relocation::spec(index)); 253 TRACE_jvmci_3("metadata[%d of %d] = %s", index, _oop_recorder->metadata_count(), method->name()->as_C_string()); 254 return method; 255 } else { 256 JVMCI_ERROR_NULL("unexpected metadata reference for constant of type %s", jvmci_env()->klass_name(obj)); 257 } 258 } 259 260 #ifdef _LP64 261 narrowKlass CodeInstaller::record_narrow_metadata_reference(CodeSection* section, address dest, JVMCIObject constant, JVMCI_TRAPS) { 262 JVMCIObject obj = jvmci_env()->get_HotSpotMetaspaceConstantImpl_metaspaceObject(constant); 263 assert(jvmci_env()->get_HotSpotMetaspaceConstantImpl_compressed(constant), "unexpected uncompressed pointer"); 264 265 if (!jvmci_env()->isa_HotSpotResolvedObjectTypeImpl(obj)) { 266 JVMCI_ERROR_0("unexpected compressed pointer of type %s", jvmci_env()->klass_name(obj)); 267 } 268 269 Klass* klass = JVMCIENV->asKlass(obj); 270 int index = _oop_recorder->find_index(klass); 271 section->relocate(dest, metadata_Relocation::spec(index)); 272 TRACE_jvmci_3("narrowKlass[%d of %d] = %s", index, _oop_recorder->metadata_count(), klass->name()->as_C_string()); 273 return CompressedKlassPointers::encode(klass); 274 } 275 #endif 276 277 Location::Type CodeInstaller::get_oop_type(JVMCIObject value) { 278 JVMCIObject valueKind = jvmci_env()->get_Value_valueKind(value); 279 JVMCIObject platformKind = jvmci_env()->get_ValueKind_platformKind(valueKind); 280 281 if (jvmci_env()->equals(platformKind, word_kind())) { 282 return Location::oop; 283 } else { 284 return Location::narrowoop; 285 } 286 } 287 288 ScopeValue* CodeInstaller::get_scope_value(JVMCIObject value, BasicType type, GrowableArray<ScopeValue*>* objects, ScopeValue* &second, JVMCI_TRAPS) { 289 second = NULL; 290 if (value.is_null()) { 291 JVMCI_THROW_NULL(NullPointerException); 292 } else if (JVMCIENV->equals(value, jvmci_env()->get_Value_ILLEGAL())) { 293 if (type != T_ILLEGAL) { 294 JVMCI_ERROR_NULL("unexpected illegal value, expected %s", basictype_to_str(type)); 295 } 296 return _illegal_value; 297 } else if (jvmci_env()->isa_RegisterValue(value)) { 298 JVMCIObject reg = jvmci_env()->get_RegisterValue_reg(value); 299 jint number = jvmci_env()->get_code_Register_number(reg); 300 VMReg hotspotRegister = get_hotspot_reg(number, JVMCI_CHECK_NULL); 301 if (is_general_purpose_reg(hotspotRegister)) { 302 Location::Type locationType; 303 if (type == T_OBJECT) { 304 locationType = get_oop_type(value); 305 } else if (type == T_LONG) { 306 locationType = Location::lng; 307 } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) { 308 locationType = Location::int_in_long; 309 } else { 310 JVMCI_ERROR_NULL("unexpected type %s in cpu register", basictype_to_str(type)); 311 } 312 ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister)); 313 if (type == T_LONG) { 314 second = value; 315 } 316 return value; 317 } else { 318 Location::Type locationType; 319 if (type == T_FLOAT) { 320 // this seems weird, but the same value is used in c1_LinearScan 321 locationType = Location::normal; 322 } else if (type == T_DOUBLE) { 323 locationType = Location::dbl; 324 } else { 325 JVMCI_ERROR_NULL("unexpected type %s in floating point register", basictype_to_str(type)); 326 } 327 ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister)); 328 if (type == T_DOUBLE) { 329 second = value; 330 } 331 return value; 332 } 333 } else if (jvmci_env()->isa_StackSlot(value)) { 334 jint offset = jvmci_env()->get_StackSlot_offset(value); 335 if (jvmci_env()->get_StackSlot_addFrameSize(value)) { 336 offset += _total_frame_size; 337 } 338 339 Location::Type locationType; 340 if (type == T_OBJECT) { 341 locationType = get_oop_type(value); 342 } else if (type == T_LONG) { 343 locationType = Location::lng; 344 } else if (type == T_DOUBLE) { 345 locationType = Location::dbl; 346 } else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) { 347 locationType = Location::normal; 348 } else { 349 JVMCI_ERROR_NULL("unexpected type %s in stack slot", basictype_to_str(type)); 350 } 351 ScopeValue* value = new LocationValue(Location::new_stk_loc(locationType, offset)); 352 if (type == T_DOUBLE || type == T_LONG) { 353 second = value; 354 } 355 return value; 356 } else if (jvmci_env()->isa_JavaConstant(value)) { 357 if (jvmci_env()->isa_PrimitiveConstant(value)) { 358 if (jvmci_env()->isa_RawConstant(value)) { 359 jlong prim = jvmci_env()->get_PrimitiveConstant_primitive(value); 360 return new ConstantLongValue(prim); 361 } else { 362 BasicType constantType = jvmci_env()->kindToBasicType(jvmci_env()->get_PrimitiveConstant_kind(value), JVMCI_CHECK_NULL); 363 if (type != constantType) { 364 JVMCI_ERROR_NULL("primitive constant type doesn't match, expected %s but got %s", basictype_to_str(type), basictype_to_str(constantType)); 365 } 366 if (type == T_INT || type == T_FLOAT) { 367 jint prim = (jint)jvmci_env()->get_PrimitiveConstant_primitive(value); 368 switch (prim) { 369 case -1: return _int_m1_scope_value; 370 case 0: return _int_0_scope_value; 371 case 1: return _int_1_scope_value; 372 case 2: return _int_2_scope_value; 373 default: return new ConstantIntValue(prim); 374 } 375 } else if (type == T_LONG || type == T_DOUBLE) { 376 jlong prim = jvmci_env()->get_PrimitiveConstant_primitive(value); 377 second = _int_1_scope_value; 378 return new ConstantLongValue(prim); 379 } else { 380 JVMCI_ERROR_NULL("unexpected primitive constant type %s", basictype_to_str(type)); 381 } 382 } 383 } else if (jvmci_env()->isa_NullConstant(value) || jvmci_env()->isa_HotSpotCompressedNullConstant(value)) { 384 if (type == T_OBJECT) { 385 return _oop_null_scope_value; 386 } else { 387 JVMCI_ERROR_NULL("unexpected null constant, expected %s", basictype_to_str(type)); 388 } 389 } else if (jvmci_env()->isa_HotSpotObjectConstantImpl(value)) { 390 if (type == T_OBJECT) { 391 Handle obj = jvmci_env()->asConstant(value, JVMCI_CHECK_NULL); 392 if (obj == NULL) { 393 JVMCI_ERROR_NULL("null value must be in NullConstant"); 394 } 395 return new ConstantOopWriteValue(JNIHandles::make_local(obj())); 396 } else { 397 JVMCI_ERROR_NULL("unexpected object constant, expected %s", basictype_to_str(type)); 398 } 399 } 400 } else if (jvmci_env()->isa_VirtualObject(value)) { 401 if (type == T_OBJECT) { 402 int id = jvmci_env()->get_VirtualObject_id(value); 403 if (0 <= id && id < objects->length()) { 404 ScopeValue* object = objects->at(id); 405 if (object != NULL) { 406 return object; 407 } 408 } 409 JVMCI_ERROR_NULL("unknown virtual object id %d", id); 410 } else { 411 JVMCI_ERROR_NULL("unexpected virtual object, expected %s", basictype_to_str(type)); 412 } 413 } 414 415 JVMCI_ERROR_NULL("unexpected value in scope: %s", jvmci_env()->klass_name(value)) 416 } 417 418 void CodeInstaller::record_object_value(ObjectValue* sv, JVMCIObject value, GrowableArray<ScopeValue*>* objects, JVMCI_TRAPS) { 419 JVMCIObject type = jvmci_env()->get_VirtualObject_type(value); 420 int id = jvmci_env()->get_VirtualObject_id(value); 421 Klass* klass = JVMCIENV->asKlass(type); 422 bool isLongArray = klass == Universe::longArrayKlassObj(); 423 424 JVMCIObjectArray values = jvmci_env()->get_VirtualObject_values(value); 425 JVMCIObjectArray slotKinds = jvmci_env()->get_VirtualObject_slotKinds(value); 426 for (jint i = 0; i < JVMCIENV->get_length(values); i++) { 427 ScopeValue* cur_second = NULL; 428 JVMCIObject object = JVMCIENV->get_object_at(values, i); 429 BasicType type = jvmci_env()->kindToBasicType(JVMCIENV->get_object_at(slotKinds, i), JVMCI_CHECK); 430 ScopeValue* value = get_scope_value(object, type, objects, cur_second, JVMCI_CHECK); 431 432 if (isLongArray && cur_second == NULL) { 433 // we're trying to put ints into a long array... this isn't really valid, but it's used for some optimizations. 434 // add an int 0 constant 435 cur_second = _int_0_scope_value; 436 } 437 438 if (cur_second != NULL) { 439 sv->field_values()->append(cur_second); 440 } 441 assert(value != NULL, "missing value"); 442 sv->field_values()->append(value); 443 } 444 } 445 446 MonitorValue* CodeInstaller::get_monitor_value(JVMCIObject value, GrowableArray<ScopeValue*>* objects, JVMCI_TRAPS) { 447 if (value.is_null()) { 448 JVMCI_THROW_NULL(NullPointerException); 449 } 450 if (!jvmci_env()->isa_StackLockValue(value)) { 451 JVMCI_ERROR_NULL("Monitors must be of type StackLockValue, got %s", jvmci_env()->klass_name(value)); 452 } 453 454 ScopeValue* second = NULL; 455 ScopeValue* owner_value = get_scope_value(jvmci_env()->get_StackLockValue_owner(value), T_OBJECT, objects, second, JVMCI_CHECK_NULL); 456 assert(second == NULL, "monitor cannot occupy two stack slots"); 457 458 ScopeValue* lock_data_value = get_scope_value(jvmci_env()->get_StackLockValue_slot(value), T_LONG, objects, second, JVMCI_CHECK_NULL); 459 assert(second == lock_data_value, "monitor is LONG value that occupies two stack slots"); 460 assert(lock_data_value->is_location(), "invalid monitor location"); 461 Location lock_data_loc = ((LocationValue*)lock_data_value)->location(); 462 463 bool eliminated = false; 464 if (jvmci_env()->get_StackLockValue_eliminated(value)) { 465 eliminated = true; 466 } 467 468 return new MonitorValue(owner_value, lock_data_loc, eliminated); 469 } 470 471 void CodeInstaller::initialize_dependencies(JVMCIObject compiled_code, OopRecorder* oop_recorder, JVMCI_TRAPS) { 472 JavaThread* thread = JavaThread::current(); 473 CompilerThread* compilerThread = thread->is_Compiler_thread() ? thread->as_CompilerThread() : NULL; 474 _oop_recorder = oop_recorder; 475 _dependencies = new Dependencies(&_arena, _oop_recorder, compilerThread != NULL ? compilerThread->log() : NULL); 476 JVMCIObjectArray assumptions = jvmci_env()->get_HotSpotCompiledCode_assumptions(compiled_code); 477 if (assumptions.is_non_null()) { 478 int length = JVMCIENV->get_length(assumptions); 479 for (int i = 0; i < length; ++i) { 480 JVMCIObject assumption = JVMCIENV->get_object_at(assumptions, i); 481 if (assumption.is_non_null()) { 482 if (jvmci_env()->isa_Assumptions_NoFinalizableSubclass(assumption)) { 483 assumption_NoFinalizableSubclass(assumption); 484 } else if (jvmci_env()->isa_Assumptions_ConcreteSubtype(assumption)) { 485 assumption_ConcreteSubtype(assumption); 486 } else if (jvmci_env()->isa_Assumptions_LeafType(assumption)) { 487 assumption_LeafType(assumption); 488 } else if (jvmci_env()->isa_Assumptions_ConcreteMethod(assumption)) { 489 assumption_ConcreteMethod(assumption); 490 } else if (jvmci_env()->isa_Assumptions_CallSiteTargetValue(assumption)) { 491 assumption_CallSiteTargetValue(assumption, JVMCI_CHECK); 492 } else { 493 JVMCI_ERROR("unexpected Assumption subclass %s", jvmci_env()->klass_name(assumption)); 494 } 495 } 496 } 497 } 498 if (JvmtiExport::can_hotswap_or_post_breakpoint()) { 499 JVMCIObjectArray methods = jvmci_env()->get_HotSpotCompiledCode_methods(compiled_code); 500 if (methods.is_non_null()) { 501 int length = JVMCIENV->get_length(methods); 502 for (int i = 0; i < length; ++i) { 503 JVMCIObject method_handle = JVMCIENV->get_object_at(methods, i); 504 methodHandle method = jvmci_env()->asMethod(method_handle); 505 _dependencies->assert_evol_method(method()); 506 } 507 } 508 } 509 } 510 511 #if INCLUDE_AOT 512 RelocBuffer::~RelocBuffer() { 513 if (_buffer != NULL) { 514 FREE_C_HEAP_ARRAY(char, _buffer); 515 } 516 } 517 518 address RelocBuffer::begin() const { 519 if (_buffer != NULL) { 520 return (address) _buffer; 521 } 522 return (address) _static_buffer; 523 } 524 525 void RelocBuffer::set_size(size_t bytes) { 526 assert(bytes <= _size, "can't grow in size!"); 527 _size = bytes; 528 } 529 530 void RelocBuffer::ensure_size(size_t bytes) { 531 assert(_buffer == NULL, "can only be used once"); 532 assert(_size == 0, "can only be used once"); 533 if (bytes >= RelocBuffer::stack_size) { 534 _buffer = NEW_C_HEAP_ARRAY(char, bytes, mtJVMCI); 535 } 536 _size = bytes; 537 } 538 539 JVMCI::CodeInstallResult CodeInstaller::gather_metadata(JVMCIObject target, JVMCIObject compiled_code, CodeMetadata& metadata, JVMCI_TRAPS) { 540 assert(JVMCIENV->is_hotspot(), "AOT code is executed only in HotSpot mode"); 541 CodeBuffer buffer("JVMCI Compiler CodeBuffer for Metadata"); 542 AOTOopRecorder* recorder = new AOTOopRecorder(this, &_arena, true); 543 initialize_dependencies(compiled_code, recorder, JVMCI_CHECK_OK); 544 545 metadata.set_oop_recorder(recorder); 546 547 // Get instructions and constants CodeSections early because we need it. 548 _instructions = buffer.insts(); 549 _constants = buffer.consts(); 550 buffer.set_immutable_PIC(_immutable_pic_compilation); 551 552 initialize_fields(target, compiled_code, JVMCI_CHECK_OK); 553 JVMCI::CodeInstallResult result = initialize_buffer(buffer, false, JVMCI_CHECK_OK); 554 if (result != JVMCI::ok) { 555 return result; 556 } 557 558 _debug_recorder->pcs_size(); // create the sentinel record 559 560 assert(_debug_recorder->pcs_length() >= 2, "must be at least 2"); 561 562 metadata.set_pc_desc(_debug_recorder->pcs(), _debug_recorder->pcs_length()); 563 metadata.set_scopes(_debug_recorder->stream()->buffer(), _debug_recorder->data_size()); 564 metadata.set_exception_table(&_exception_handler_table); 565 metadata.set_implicit_exception_table(&_implicit_exception_table); 566 567 RelocBuffer* reloc_buffer = metadata.get_reloc_buffer(); 568 569 reloc_buffer->ensure_size(buffer.total_relocation_size()); 570 size_t size = (size_t) buffer.copy_relocations_to(reloc_buffer->begin(), (CodeBuffer::csize_t) reloc_buffer->size(), true); 571 reloc_buffer->set_size(size); 572 return JVMCI::ok; 573 } 574 #endif // INCLUDE_AOT 575 576 // constructor used to create a method 577 JVMCI::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler, 578 JVMCIObject target, 579 JVMCIObject compiled_code, 580 CodeBlob*& cb, 581 JVMCIObject installed_code, 582 FailedSpeculation** failed_speculations, 583 char* speculations, 584 int speculations_len, 585 JVMCI_TRAPS) { 586 587 CodeBuffer buffer("JVMCI Compiler CodeBuffer"); 588 OopRecorder* recorder = new OopRecorder(&_arena, true); 589 initialize_dependencies(compiled_code, recorder, JVMCI_CHECK_OK); 590 591 // Get instructions and constants CodeSections early because we need it. 592 _instructions = buffer.insts(); 593 _constants = buffer.consts(); 594 #if INCLUDE_AOT 595 buffer.set_immutable_PIC(_immutable_pic_compilation); 596 #endif 597 598 initialize_fields(target, compiled_code, JVMCI_CHECK_OK); 599 JVMCI::CodeInstallResult result = initialize_buffer(buffer, true, JVMCI_CHECK_OK); 600 if (result != JVMCI::ok) { 601 return result; 602 } 603 604 int stack_slots = _total_frame_size / HeapWordSize; // conversion to words 605 606 if (!jvmci_env()->isa_HotSpotCompiledNmethod(compiled_code)) { 607 JVMCIObject stubName = jvmci_env()->get_HotSpotCompiledCode_name(compiled_code); 608 if (stubName.is_null()) { 609 JVMCI_ERROR_OK("stub should have a name"); 610 } 611 char* name = strdup(jvmci_env()->as_utf8_string(stubName)); 612 cb = RuntimeStub::new_runtime_stub(name, 613 &buffer, 614 CodeOffsets::frame_never_safe, 615 stack_slots, 616 _debug_recorder->_oopmaps, 617 false); 618 result = JVMCI::ok; 619 } else { 620 JVMCICompileState* compile_state = (JVMCICompileState*) (address) jvmci_env()->get_HotSpotCompiledNmethod_compileState(compiled_code); 621 if (compile_state != NULL) { 622 jvmci_env()->set_compile_state(compile_state); 623 } 624 625 methodHandle method = jvmci_env()->asMethod(jvmci_env()->get_HotSpotCompiledNmethod_method(compiled_code)); 626 jint entry_bci = jvmci_env()->get_HotSpotCompiledNmethod_entryBCI(compiled_code); 627 bool has_unsafe_access = jvmci_env()->get_HotSpotCompiledNmethod_hasUnsafeAccess(compiled_code) == JNI_TRUE; 628 jint id = jvmci_env()->get_HotSpotCompiledNmethod_id(compiled_code); 629 if (id == -1) { 630 // Make sure a valid compile_id is associated with every compile 631 id = CompileBroker::assign_compile_id_unlocked(Thread::current(), method, entry_bci); 632 jvmci_env()->set_HotSpotCompiledNmethod_id(compiled_code, id); 633 } 634 if (!jvmci_env()->isa_HotSpotNmethod(installed_code)) { 635 JVMCI_THROW_MSG_(IllegalArgumentException, "InstalledCode object must be a HotSpotNmethod when installing a HotSpotCompiledNmethod", JVMCI::ok); 636 } 637 638 JVMCIObject mirror = installed_code; 639 nmethod* nm = NULL; 640 result = runtime()->register_method(jvmci_env(), method, nm, entry_bci, &_offsets, _orig_pc_offset, &buffer, 641 stack_slots, _debug_recorder->_oopmaps, &_exception_handler_table, &_implicit_exception_table, 642 compiler, _debug_recorder, _dependencies, id, 643 has_unsafe_access, _has_wide_vector, compiled_code, mirror, 644 failed_speculations, speculations, speculations_len); 645 cb = nm->as_codeblob_or_null(); 646 if (nm != NULL && compile_state == NULL) { 647 DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, compiler); 648 bool printnmethods = directive->PrintAssemblyOption || directive->PrintNMethodsOption; 649 if (!printnmethods && (PrintDebugInfo || PrintRelocations || PrintDependencies || PrintExceptionHandlers)) { 650 nm->print_nmethod(printnmethods); 651 } 652 DirectivesStack::release(directive); 653 } 654 } 655 656 if (cb != NULL) { 657 // Make sure the pre-calculated constants section size was correct. 658 guarantee((cb->code_begin() - cb->content_begin()) >= _constants_size, "%d < %d", (int)(cb->code_begin() - cb->content_begin()), _constants_size); 659 } 660 return result; 661 } 662 663 void CodeInstaller::initialize_fields(JVMCIObject target, JVMCIObject compiled_code, JVMCI_TRAPS) { 664 if (jvmci_env()->isa_HotSpotCompiledNmethod(compiled_code)) { 665 JVMCIObject hotspotJavaMethod = jvmci_env()->get_HotSpotCompiledNmethod_method(compiled_code); 666 methodHandle method = jvmci_env()->asMethod(hotspotJavaMethod); 667 _parameter_count = method->size_of_parameters(); 668 TRACE_jvmci_2("installing code for %s", method->name_and_sig_as_C_string()); 669 } else { 670 // Must be a HotSpotCompiledRuntimeStub. 671 // Only used in OopMap constructor for non-product builds 672 _parameter_count = 0; 673 } 674 _sites_handle = jvmci_env()->get_HotSpotCompiledCode_sites(compiled_code); 675 676 _code_handle = jvmci_env()->get_HotSpotCompiledCode_targetCode(compiled_code); 677 _code_size = jvmci_env()->get_HotSpotCompiledCode_targetCodeSize(compiled_code); 678 _total_frame_size = jvmci_env()->get_HotSpotCompiledCode_totalFrameSize(compiled_code); 679 680 JVMCIObject deoptRescueSlot = jvmci_env()->get_HotSpotCompiledCode_deoptRescueSlot(compiled_code); 681 if (deoptRescueSlot.is_null()) { 682 _orig_pc_offset = -1; 683 } else { 684 _orig_pc_offset = jvmci_env()->get_StackSlot_offset(deoptRescueSlot); 685 if (jvmci_env()->get_StackSlot_addFrameSize(deoptRescueSlot)) { 686 _orig_pc_offset += _total_frame_size; 687 } 688 if (_orig_pc_offset < 0) { 689 JVMCI_ERROR("invalid deopt rescue slot: %d", _orig_pc_offset); 690 } 691 } 692 693 // Pre-calculate the constants section size. This is required for PC-relative addressing. 694 _data_section_handle = jvmci_env()->get_HotSpotCompiledCode_dataSection(compiled_code); 695 if ((_constants->alignment() % jvmci_env()->get_HotSpotCompiledCode_dataSectionAlignment(compiled_code)) != 0) { 696 JVMCI_ERROR("invalid data section alignment: %d", jvmci_env()->get_HotSpotCompiledCode_dataSectionAlignment(compiled_code)); 697 } 698 _constants_size = JVMCIENV->get_length(data_section()); 699 700 _data_section_patches_handle = jvmci_env()->get_HotSpotCompiledCode_dataSectionPatches(compiled_code); 701 702 #ifndef PRODUCT 703 _comments_handle = jvmci_env()->get_HotSpotCompiledCode_comments(compiled_code); 704 #endif 705 706 _next_call_type = INVOKE_INVALID; 707 708 _has_wide_vector = false; 709 710 JVMCIObject arch = jvmci_env()->get_TargetDescription_arch(target); 711 _word_kind_handle = jvmci_env()->get_Architecture_wordKind(arch); 712 } 713 714 int CodeInstaller::estimate_stubs_size(JVMCI_TRAPS) { 715 // Estimate the number of static and aot call stubs that might be emitted. 716 int static_call_stubs = 0; 717 int aot_call_stubs = 0; 718 int trampoline_stubs = 0; 719 JVMCIObjectArray sites = this->sites(); 720 for (int i = 0; i < JVMCIENV->get_length(sites); i++) { 721 JVMCIObject site = JVMCIENV->get_object_at(sites, i); 722 if (!site.is_null()) { 723 if (jvmci_env()->isa_site_Mark(site)) { 724 JVMCIObject id_obj = jvmci_env()->get_site_Mark_id(site); 725 if (id_obj.is_non_null()) { 726 if (!jvmci_env()->is_boxing_object(T_INT, id_obj)) { 727 JVMCI_ERROR_0("expected Integer id, got %s", jvmci_env()->klass_name(id_obj)); 728 } 729 jint id = jvmci_env()->get_boxed_value(T_INT, id_obj).i; 730 switch (id) { 731 case INVOKEINTERFACE: 732 case INVOKEVIRTUAL: 733 trampoline_stubs++; 734 break; 735 case INVOKESTATIC: 736 case INVOKESPECIAL: 737 static_call_stubs++; 738 trampoline_stubs++; 739 break; 740 default: 741 break; 742 } 743 } 744 } 745 #if INCLUDE_AOT 746 if (UseAOT && jvmci_env()->isa_site_Call(site)) { 747 JVMCIObject target = jvmci_env()-> get_site_Call_target(site); 748 if (!jvmci_env()->isa_HotSpotForeignCallTarget(target)) { 749 // Add far aot trampolines. 750 aot_call_stubs++; 751 } 752 } 753 #endif 754 } 755 } 756 int size = static_call_stubs * CompiledStaticCall::to_interp_stub_size(); 757 size += trampoline_stubs * CompiledStaticCall::to_trampoline_stub_size(); 758 #if INCLUDE_AOT 759 size += aot_call_stubs * CompiledStaticCall::to_aot_stub_size(); 760 #endif 761 return size; 762 } 763 764 // perform data and call relocation on the CodeBuffer 765 JVMCI::CodeInstallResult CodeInstaller::initialize_buffer(CodeBuffer& buffer, bool check_size, JVMCI_TRAPS) { 766 HandleMark hm; 767 JVMCIObjectArray sites = this->sites(); 768 int locs_buffer_size = JVMCIENV->get_length(sites) * (relocInfo::length_limit + sizeof(relocInfo)); 769 770 // Allocate enough space in the stub section for the static call 771 // stubs. Stubs have extra relocs but they are managed by the stub 772 // section itself so they don't need to be accounted for in the 773 // locs_buffer above. 774 int stubs_size = estimate_stubs_size(JVMCI_CHECK_OK); 775 int total_size = align_up(_code_size, buffer.insts()->alignment()) + align_up(_constants_size, buffer.consts()->alignment()) + align_up(stubs_size, buffer.stubs()->alignment()); 776 777 if (check_size && total_size > JVMCINMethodSizeLimit) { 778 return JVMCI::code_too_large; 779 } 780 781 buffer.initialize(total_size, locs_buffer_size); 782 if (buffer.blob() == NULL) { 783 return JVMCI::cache_full; 784 } 785 buffer.initialize_stubs_size(stubs_size); 786 buffer.initialize_consts_size(_constants_size); 787 788 _debug_recorder = new DebugInformationRecorder(_oop_recorder); 789 _debug_recorder->set_oopmaps(new OopMapSet()); 790 791 buffer.initialize_oop_recorder(_oop_recorder); 792 793 // copy the constant data into the newly created CodeBuffer 794 address end_data = _constants->start() + _constants_size; 795 JVMCIENV->copy_bytes_to(data_section(), (jbyte*) _constants->start(), 0, _constants_size); 796 _constants->set_end(end_data); 797 798 // copy the code into the newly created CodeBuffer 799 address end_pc = _instructions->start() + _code_size; 800 guarantee(_instructions->allocates2(end_pc), "initialize should have reserved enough space for all the code"); 801 JVMCIENV->copy_bytes_to(code(), (jbyte*) _instructions->start(), 0, _code_size); 802 _instructions->set_end(end_pc); 803 804 for (int i = 0; i < JVMCIENV->get_length(data_section_patches()); i++) { 805 // HandleMark hm(THREAD); 806 JVMCIObject patch = JVMCIENV->get_object_at(data_section_patches(), i); 807 if (patch.is_null()) { 808 JVMCI_THROW_(NullPointerException, JVMCI::ok); 809 } 810 JVMCIObject reference = jvmci_env()->get_site_DataPatch_reference(patch); 811 if (reference.is_null()) { 812 JVMCI_THROW_(NullPointerException, JVMCI::ok); 813 } 814 if (!jvmci_env()->isa_site_ConstantReference(reference)) { 815 JVMCI_ERROR_OK("invalid patch in data section: %s", jvmci_env()->klass_name(reference)); 816 } 817 JVMCIObject constant = jvmci_env()->get_site_ConstantReference_constant(reference); 818 if (constant.is_null()) { 819 JVMCI_THROW_(NullPointerException, JVMCI::ok); 820 } 821 address dest = _constants->start() + jvmci_env()->get_site_Site_pcOffset(patch); 822 if (jvmci_env()->isa_HotSpotMetaspaceConstantImpl(constant)) { 823 if (jvmci_env()->get_HotSpotMetaspaceConstantImpl_compressed(constant)) { 824 #ifdef _LP64 825 *((narrowKlass*) dest) = record_narrow_metadata_reference(_constants, dest, constant, JVMCI_CHECK_OK); 826 #else 827 JVMCI_ERROR_OK("unexpected compressed Klass* in 32-bit mode"); 828 #endif 829 } else { 830 *((void**) dest) = record_metadata_reference(_constants, dest, constant, JVMCI_CHECK_OK); 831 } 832 } else if (jvmci_env()->isa_HotSpotObjectConstantImpl(constant)) { 833 Handle obj = jvmci_env()->asConstant(constant, JVMCI_CHECK_OK); 834 jobject value = JNIHandles::make_local(obj()); 835 int oop_index = _oop_recorder->find_index(value); 836 837 if (jvmci_env()->get_HotSpotObjectConstantImpl_compressed(constant)) { 838 #ifdef _LP64 839 _constants->relocate(dest, oop_Relocation::spec(oop_index), relocInfo::narrow_oop_in_const); 840 #else 841 JVMCI_ERROR_OK("unexpected compressed oop in 32-bit mode"); 842 #endif 843 } else { 844 _constants->relocate(dest, oop_Relocation::spec(oop_index)); 845 } 846 } else { 847 JVMCI_ERROR_OK("invalid constant in data section: %s", jvmci_env()->klass_name(constant)); 848 } 849 } 850 jint last_pc_offset = -1; 851 for (int i = 0; i < JVMCIENV->get_length(sites); i++) { 852 // HandleMark hm(THREAD); 853 JVMCIObject site = JVMCIENV->get_object_at(sites, i); 854 if (site.is_null()) { 855 JVMCI_THROW_(NullPointerException, JVMCI::ok); 856 } 857 858 jint pc_offset = jvmci_env()->get_site_Site_pcOffset(site); 859 860 if (jvmci_env()->isa_site_Call(site)) { 861 TRACE_jvmci_4("call at %i", pc_offset); 862 site_Call(buffer, pc_offset, site, JVMCI_CHECK_OK); 863 } else if (jvmci_env()->isa_site_Infopoint(site)) { 864 // three reasons for infopoints denote actual safepoints 865 JVMCIObject reason = jvmci_env()->get_site_Infopoint_reason(site); 866 if (JVMCIENV->equals(reason, jvmci_env()->get_site_InfopointReason_SAFEPOINT()) || 867 JVMCIENV->equals(reason, jvmci_env()->get_site_InfopointReason_CALL()) || 868 JVMCIENV->equals(reason, jvmci_env()->get_site_InfopointReason_IMPLICIT_EXCEPTION())) { 869 TRACE_jvmci_4("safepoint at %i", pc_offset); 870 site_Safepoint(buffer, pc_offset, site, JVMCI_CHECK_OK); 871 if (_orig_pc_offset < 0) { 872 JVMCI_ERROR_OK("method contains safepoint, but has no deopt rescue slot"); 873 } 874 if (JVMCIENV->equals(reason, jvmci_env()->get_site_InfopointReason_IMPLICIT_EXCEPTION())) { 875 TRACE_jvmci_4("implicit exception at %i", pc_offset); 876 _implicit_exception_table.add_deoptimize(pc_offset); 877 } 878 } else { 879 TRACE_jvmci_4("infopoint at %i", pc_offset); 880 site_Infopoint(buffer, pc_offset, site, JVMCI_CHECK_OK); 881 } 882 } else if (jvmci_env()->isa_site_DataPatch(site)) { 883 TRACE_jvmci_4("datapatch at %i", pc_offset); 884 site_DataPatch(buffer, pc_offset, site, JVMCI_CHECK_OK); 885 } else if (jvmci_env()->isa_site_Mark(site)) { 886 TRACE_jvmci_4("mark at %i", pc_offset); 887 site_Mark(buffer, pc_offset, site, JVMCI_CHECK_OK); 888 } else if (jvmci_env()->isa_site_ExceptionHandler(site)) { 889 TRACE_jvmci_4("exceptionhandler at %i", pc_offset); 890 site_ExceptionHandler(pc_offset, site); 891 } else { 892 JVMCI_ERROR_OK("unexpected site subclass: %s", jvmci_env()->klass_name(site)); 893 } 894 last_pc_offset = pc_offset; 895 896 JavaThread* thread = JavaThread::current(); 897 if (SafepointMechanism::should_block(thread)) { 898 // this is a hacky way to force a safepoint check but nothing else was jumping out at me. 899 ThreadToNativeFromVM ttnfv(thread); 900 } 901 } 902 903 #ifndef PRODUCT 904 if (comments().is_non_null()) { 905 for (int i = 0; i < JVMCIENV->get_length(comments()); i++) { 906 JVMCIObject comment = JVMCIENV->get_object_at(comments(), i); 907 assert(jvmci_env()->isa_HotSpotCompiledCode_Comment(comment), "cce"); 908 jint offset = jvmci_env()->get_HotSpotCompiledCode_Comment_pcOffset(comment); 909 const char* text = jvmci_env()->as_utf8_string(jvmci_env()->get_HotSpotCompiledCode_Comment_text(comment)); 910 buffer.block_comment(offset, text); 911 } 912 } 913 #endif 914 return JVMCI::ok; 915 } 916 917 void CodeInstaller::assumption_NoFinalizableSubclass(JVMCIObject assumption) { 918 JVMCIObject receiverType_handle = jvmci_env()->get_Assumptions_NoFinalizableSubclass_receiverType(assumption); 919 Klass* receiverType = jvmci_env()->asKlass(receiverType_handle); 920 _dependencies->assert_has_no_finalizable_subclasses(receiverType); 921 } 922 923 void CodeInstaller::assumption_ConcreteSubtype(JVMCIObject assumption) { 924 JVMCIObject context_handle = jvmci_env()->get_Assumptions_ConcreteSubtype_context(assumption); 925 JVMCIObject subtype_handle = jvmci_env()->get_Assumptions_ConcreteSubtype_subtype(assumption); 926 Klass* context = jvmci_env()->asKlass(context_handle); 927 Klass* subtype = jvmci_env()->asKlass(subtype_handle); 928 929 assert(context->is_abstract(), ""); 930 _dependencies->assert_abstract_with_unique_concrete_subtype(context, subtype); 931 } 932 933 void CodeInstaller::assumption_LeafType(JVMCIObject assumption) { 934 JVMCIObject context_handle = jvmci_env()->get_Assumptions_LeafType_context(assumption); 935 Klass* context = jvmci_env()->asKlass(context_handle); 936 937 _dependencies->assert_leaf_type(context); 938 } 939 940 void CodeInstaller::assumption_ConcreteMethod(JVMCIObject assumption) { 941 JVMCIObject impl_handle = jvmci_env()->get_Assumptions_ConcreteMethod_impl(assumption); 942 JVMCIObject context_handle = jvmci_env()->get_Assumptions_ConcreteMethod_context(assumption); 943 944 methodHandle impl = jvmci_env()->asMethod(impl_handle); 945 Klass* context = jvmci_env()->asKlass(context_handle); 946 947 _dependencies->assert_unique_concrete_method(context, impl()); 948 } 949 950 void CodeInstaller::assumption_CallSiteTargetValue(JVMCIObject assumption, JVMCI_TRAPS) { 951 JVMCIObject callSiteConstant = jvmci_env()->get_Assumptions_CallSiteTargetValue_callSite(assumption); 952 Handle callSite = jvmci_env()->asConstant(callSiteConstant, JVMCI_CHECK); 953 JVMCIObject methodConstant = jvmci_env()->get_Assumptions_CallSiteTargetValue_methodHandle(assumption); 954 Handle methodHandle = jvmci_env()->asConstant(methodConstant, JVMCI_CHECK); 955 _dependencies->assert_call_site_target_value(callSite(), methodHandle()); 956 } 957 958 void CodeInstaller::site_ExceptionHandler(jint pc_offset, JVMCIObject exc) { 959 jint handler_offset = jvmci_env()->get_site_ExceptionHandler_handlerPos(exc); 960 961 // Subtable header 962 _exception_handler_table.add_entry(HandlerTableEntry(1, pc_offset, 0)); 963 964 // Subtable entry 965 _exception_handler_table.add_entry(HandlerTableEntry(-1, handler_offset, 0)); 966 } 967 968 // If deoptimization happens, the interpreter should reexecute these bytecodes. 969 // This function mainly helps the compilers to set up the reexecute bit. 970 static bool bytecode_should_reexecute(Bytecodes::Code code) { 971 switch (code) { 972 case Bytecodes::_invokedynamic: 973 case Bytecodes::_invokevirtual: 974 case Bytecodes::_invokeinterface: 975 case Bytecodes::_invokespecial: 976 case Bytecodes::_invokestatic: 977 return false; 978 default: 979 return true; 980 } 981 return true; 982 } 983 984 GrowableArray<ScopeValue*>* CodeInstaller::record_virtual_objects(JVMCIObject debug_info, JVMCI_TRAPS) { 985 JVMCIObjectArray virtualObjects = jvmci_env()->get_DebugInfo_virtualObjectMapping(debug_info); 986 if (virtualObjects.is_null()) { 987 return NULL; 988 } 989 GrowableArray<ScopeValue*>* objects = new GrowableArray<ScopeValue*>(JVMCIENV->get_length(virtualObjects), JVMCIENV->get_length(virtualObjects), NULL); 990 // Create the unique ObjectValues 991 for (int i = 0; i < JVMCIENV->get_length(virtualObjects); i++) { 992 // HandleMark hm(THREAD); 993 JVMCIObject value = JVMCIENV->get_object_at(virtualObjects, i); 994 int id = jvmci_env()->get_VirtualObject_id(value); 995 JVMCIObject type = jvmci_env()->get_VirtualObject_type(value); 996 bool is_auto_box = jvmci_env()->get_VirtualObject_isAutoBox(value); 997 Klass* klass = jvmci_env()->asKlass(type); 998 oop javaMirror = klass->java_mirror(); 999 ScopeValue *klass_sv = new ConstantOopWriteValue(JNIHandles::make_local(Thread::current(), javaMirror)); 1000 ObjectValue* sv = is_auto_box ? new AutoBoxObjectValue(id, klass_sv) : new ObjectValue(id, klass_sv); 1001 if (id < 0 || id >= objects->length()) { 1002 JVMCI_ERROR_NULL("virtual object id %d out of bounds", id); 1003 } 1004 if (objects->at(id) != NULL) { 1005 JVMCI_ERROR_NULL("duplicate virtual object id %d", id); 1006 } 1007 objects->at_put(id, sv); 1008 } 1009 // All the values which could be referenced by the VirtualObjects 1010 // exist, so now describe all the VirtualObjects themselves. 1011 for (int i = 0; i < JVMCIENV->get_length(virtualObjects); i++) { 1012 // HandleMark hm(THREAD); 1013 JVMCIObject value = JVMCIENV->get_object_at(virtualObjects, i); 1014 int id = jvmci_env()->get_VirtualObject_id(value); 1015 record_object_value(objects->at(id)->as_ObjectValue(), value, objects, JVMCI_CHECK_NULL); 1016 } 1017 _debug_recorder->dump_object_pool(objects); 1018 return objects; 1019 } 1020 1021 void CodeInstaller::record_scope(jint pc_offset, JVMCIObject debug_info, ScopeMode scope_mode, bool return_oop, JVMCI_TRAPS) { 1022 JVMCIObject position = jvmci_env()->get_DebugInfo_bytecodePosition(debug_info); 1023 if (position.is_null()) { 1024 // Stubs do not record scope info, just oop maps 1025 return; 1026 } 1027 1028 GrowableArray<ScopeValue*>* objectMapping; 1029 if (scope_mode == CodeInstaller::FullFrame) { 1030 objectMapping = record_virtual_objects(debug_info, JVMCI_CHECK); 1031 } else { 1032 objectMapping = NULL; 1033 } 1034 record_scope(pc_offset, position, scope_mode, objectMapping, return_oop, JVMCI_CHECK); 1035 } 1036 1037 int CodeInstaller::map_jvmci_bci(int bci) { 1038 if (bci < 0) { 1039 if (bci == jvmci_env()->get_BytecodeFrame_BEFORE_BCI()) { 1040 return BeforeBci; 1041 } else if (bci == jvmci_env()->get_BytecodeFrame_AFTER_BCI()) { 1042 return AfterBci; 1043 } else if (bci == jvmci_env()->get_BytecodeFrame_UNWIND_BCI()) { 1044 return UnwindBci; 1045 } else if (bci == jvmci_env()->get_BytecodeFrame_AFTER_EXCEPTION_BCI()) { 1046 return AfterExceptionBci; 1047 } else if (bci == jvmci_env()->get_BytecodeFrame_UNKNOWN_BCI()) { 1048 return UnknownBci; 1049 } else if (bci == jvmci_env()->get_BytecodeFrame_INVALID_FRAMESTATE_BCI()) { 1050 return InvalidFrameStateBci; 1051 } 1052 ShouldNotReachHere(); 1053 } 1054 return bci; 1055 } 1056 1057 void CodeInstaller::record_scope(jint pc_offset, JVMCIObject position, ScopeMode scope_mode, GrowableArray<ScopeValue*>* objects, bool return_oop, JVMCI_TRAPS) { 1058 JVMCIObject frame; 1059 if (scope_mode == CodeInstaller::FullFrame) { 1060 if (!jvmci_env()->isa_BytecodeFrame(position)) { 1061 JVMCI_ERROR("Full frame expected for debug info at %i", pc_offset); 1062 } 1063 frame = position; 1064 } 1065 JVMCIObject caller_frame = jvmci_env()->get_BytecodePosition_caller(position); 1066 if (caller_frame.is_non_null()) { 1067 record_scope(pc_offset, caller_frame, scope_mode, objects, return_oop, JVMCI_CHECK); 1068 } 1069 1070 JVMCIObject hotspot_method = jvmci_env()->get_BytecodePosition_method(position); 1071 Method* method = jvmci_env()->asMethod(hotspot_method); 1072 jint bci = map_jvmci_bci(jvmci_env()->get_BytecodePosition_bci(position)); 1073 if (bci == jvmci_env()->get_BytecodeFrame_BEFORE_BCI()) { 1074 bci = SynchronizationEntryBCI; 1075 } 1076 1077 TRACE_jvmci_2("Recording scope pc_offset=%d bci=%d method=%s", pc_offset, bci, method->name_and_sig_as_C_string()); 1078 1079 bool reexecute = false; 1080 if (frame.is_non_null()) { 1081 if (bci < 0){ 1082 reexecute = false; 1083 } else { 1084 Bytecodes::Code code = Bytecodes::java_code_at(method, method->bcp_from(bci)); 1085 reexecute = bytecode_should_reexecute(code); 1086 if (frame.is_non_null()) { 1087 reexecute = (jvmci_env()->get_BytecodeFrame_duringCall(frame) == JNI_FALSE); 1088 } 1089 } 1090 } 1091 1092 DebugToken* locals_token = NULL; 1093 DebugToken* expressions_token = NULL; 1094 DebugToken* monitors_token = NULL; 1095 bool throw_exception = false; 1096 1097 if (frame.is_non_null()) { 1098 jint local_count = jvmci_env()->get_BytecodeFrame_numLocals(frame); 1099 jint expression_count = jvmci_env()->get_BytecodeFrame_numStack(frame); 1100 jint monitor_count = jvmci_env()->get_BytecodeFrame_numLocks(frame); 1101 JVMCIObjectArray values = jvmci_env()->get_BytecodeFrame_values(frame); 1102 JVMCIObjectArray slotKinds = jvmci_env()->get_BytecodeFrame_slotKinds(frame); 1103 1104 if (values.is_null() || slotKinds.is_null()) { 1105 JVMCI_THROW(NullPointerException); 1106 } 1107 if (local_count + expression_count + monitor_count != JVMCIENV->get_length(values)) { 1108 JVMCI_ERROR("unexpected values length %d in scope (%d locals, %d expressions, %d monitors)", JVMCIENV->get_length(values), local_count, expression_count, monitor_count); 1109 } 1110 if (local_count + expression_count != JVMCIENV->get_length(slotKinds)) { 1111 JVMCI_ERROR("unexpected slotKinds length %d in scope (%d locals, %d expressions)", JVMCIENV->get_length(slotKinds), local_count, expression_count); 1112 } 1113 1114 GrowableArray<ScopeValue*>* locals = local_count > 0 ? new GrowableArray<ScopeValue*> (local_count) : NULL; 1115 GrowableArray<ScopeValue*>* expressions = expression_count > 0 ? new GrowableArray<ScopeValue*> (expression_count) : NULL; 1116 GrowableArray<MonitorValue*>* monitors = monitor_count > 0 ? new GrowableArray<MonitorValue*> (monitor_count) : NULL; 1117 1118 TRACE_jvmci_2("Scope at bci %d with %d values", bci, JVMCIENV->get_length(values)); 1119 TRACE_jvmci_2("%d locals %d expressions, %d monitors", local_count, expression_count, monitor_count); 1120 1121 for (jint i = 0; i < JVMCIENV->get_length(values); i++) { 1122 // HandleMark hm(THREAD); 1123 ScopeValue* second = NULL; 1124 JVMCIObject value = JVMCIENV->get_object_at(values, i); 1125 if (i < local_count) { 1126 BasicType type = jvmci_env()->kindToBasicType(JVMCIENV->get_object_at(slotKinds, i), JVMCI_CHECK); 1127 ScopeValue* first = get_scope_value(value, type, objects, second, JVMCI_CHECK); 1128 if (second != NULL) { 1129 locals->append(second); 1130 } 1131 locals->append(first); 1132 } else if (i < local_count + expression_count) { 1133 BasicType type = jvmci_env()->kindToBasicType(JVMCIENV->get_object_at(slotKinds, i), JVMCI_CHECK); 1134 ScopeValue* first = get_scope_value(value, type, objects, second, JVMCI_CHECK); 1135 if (second != NULL) { 1136 expressions->append(second); 1137 } 1138 expressions->append(first); 1139 } else { 1140 MonitorValue *monitor = get_monitor_value(value, objects, JVMCI_CHECK); 1141 monitors->append(monitor); 1142 } 1143 if (second != NULL) { 1144 i++; 1145 if (i >= JVMCIENV->get_length(values) || !JVMCIENV->equals(JVMCIENV->get_object_at(values, i), jvmci_env()->get_Value_ILLEGAL())) { 1146 JVMCI_ERROR("double-slot value not followed by Value.ILLEGAL"); 1147 } 1148 } 1149 } 1150 1151 locals_token = _debug_recorder->create_scope_values(locals); 1152 expressions_token = _debug_recorder->create_scope_values(expressions); 1153 monitors_token = _debug_recorder->create_monitor_values(monitors); 1154 1155 throw_exception = jvmci_env()->get_BytecodeFrame_rethrowException(frame) == JNI_TRUE; 1156 } 1157 1158 _debug_recorder->describe_scope(pc_offset, method, NULL, bci, reexecute, throw_exception, false, return_oop, 1159 locals_token, expressions_token, monitors_token); 1160 } 1161 1162 void CodeInstaller::site_Safepoint(CodeBuffer& buffer, jint pc_offset, JVMCIObject site, JVMCI_TRAPS) { 1163 JVMCIObject debug_info = jvmci_env()->get_site_Infopoint_debugInfo(site); 1164 if (debug_info.is_null()) { 1165 JVMCI_ERROR("debug info expected at safepoint at %i", pc_offset); 1166 } 1167 1168 // address instruction = _instructions->start() + pc_offset; 1169 // jint next_pc_offset = Assembler::locate_next_instruction(instruction) - _instructions->start(); 1170 OopMap *map = create_oop_map(debug_info, JVMCI_CHECK); 1171 _debug_recorder->add_safepoint(pc_offset, map); 1172 record_scope(pc_offset, debug_info, CodeInstaller::FullFrame, JVMCI_CHECK); 1173 _debug_recorder->end_safepoint(pc_offset); 1174 } 1175 1176 void CodeInstaller::site_Infopoint(CodeBuffer& buffer, jint pc_offset, JVMCIObject site, JVMCI_TRAPS) { 1177 JVMCIObject debug_info = jvmci_env()->get_site_Infopoint_debugInfo(site); 1178 if (debug_info.is_null()) { 1179 JVMCI_ERROR("debug info expected at infopoint at %i", pc_offset); 1180 } 1181 1182 // We'd like to check that pc_offset is greater than the 1183 // last pc recorded with _debug_recorder (raising an exception if not) 1184 // but DebugInformationRecorder doesn't have sufficient public API. 1185 1186 _debug_recorder->add_non_safepoint(pc_offset); 1187 record_scope(pc_offset, debug_info, CodeInstaller::BytecodePosition, JVMCI_CHECK); 1188 _debug_recorder->end_non_safepoint(pc_offset); 1189 } 1190 1191 void CodeInstaller::site_Call(CodeBuffer& buffer, jint pc_offset, JVMCIObject site, JVMCI_TRAPS) { 1192 JVMCIObject target = jvmci_env()->get_site_Call_target(site); 1193 JVMCIObject hotspot_method; // JavaMethod 1194 JVMCIObject foreign_call; 1195 1196 if (jvmci_env()->isa_HotSpotForeignCallTarget(target)) { 1197 foreign_call = target; 1198 } else { 1199 hotspot_method = target; 1200 } 1201 1202 JVMCIObject debug_info = jvmci_env()->get_site_Infopoint_debugInfo(site); 1203 1204 assert(hotspot_method.is_non_null() ^ foreign_call.is_non_null(), "Call site needs exactly one type"); 1205 1206 NativeInstruction* inst = nativeInstruction_at(_instructions->start() + pc_offset); 1207 jint next_pc_offset = CodeInstaller::pd_next_offset(inst, pc_offset, hotspot_method, JVMCI_CHECK); 1208 1209 if (debug_info.is_non_null()) { 1210 OopMap *map = create_oop_map(debug_info, JVMCI_CHECK); 1211 _debug_recorder->add_safepoint(next_pc_offset, map); 1212 1213 bool return_oop = hotspot_method.is_non_null() && jvmci_env()->asMethod(hotspot_method)->is_returning_oop(); 1214 1215 record_scope(next_pc_offset, debug_info, CodeInstaller::FullFrame, return_oop, JVMCI_CHECK); 1216 } 1217 1218 if (foreign_call.is_non_null()) { 1219 jlong foreign_call_destination = jvmci_env()->get_HotSpotForeignCallTarget_address(foreign_call); 1220 if (_immutable_pic_compilation) { 1221 // Use fake short distance during PIC compilation. 1222 foreign_call_destination = (jlong)(_instructions->start() + pc_offset); 1223 } 1224 CodeInstaller::pd_relocate_ForeignCall(inst, foreign_call_destination, JVMCI_CHECK); 1225 } else { // method != NULL 1226 if (debug_info.is_null()) { 1227 JVMCI_ERROR("debug info expected at call at %i", pc_offset); 1228 } 1229 1230 TRACE_jvmci_3("method call"); 1231 CodeInstaller::pd_relocate_JavaMethod(buffer, hotspot_method, pc_offset, JVMCI_CHECK); 1232 if (_next_call_type == INVOKESTATIC || _next_call_type == INVOKESPECIAL) { 1233 // Need a static call stub for transitions from compiled to interpreted. 1234 CompiledStaticCall::emit_to_interp_stub(buffer, _instructions->start() + pc_offset); 1235 } 1236 #if INCLUDE_AOT 1237 // Trampoline to far aot code. 1238 CompiledStaticCall::emit_to_aot_stub(buffer, _instructions->start() + pc_offset); 1239 #endif 1240 } 1241 1242 _next_call_type = INVOKE_INVALID; 1243 1244 if (debug_info.is_non_null()) { 1245 _debug_recorder->end_safepoint(next_pc_offset); 1246 } 1247 } 1248 1249 void CodeInstaller::site_DataPatch(CodeBuffer& buffer, jint pc_offset, JVMCIObject site, JVMCI_TRAPS) { 1250 JVMCIObject reference = jvmci_env()->get_site_DataPatch_reference(site); 1251 if (reference.is_null()) { 1252 JVMCI_THROW(NullPointerException); 1253 } else if (jvmci_env()->isa_site_ConstantReference(reference)) { 1254 JVMCIObject constant = jvmci_env()->get_site_ConstantReference_constant(reference); 1255 if (constant.is_null()) { 1256 JVMCI_THROW(NullPointerException); 1257 } else if (jvmci_env()->isa_DirectHotSpotObjectConstantImpl(constant)) { 1258 if (!JVMCIENV->is_hotspot()) { 1259 JVMCIObject string = JVMCIENV->call_HotSpotJVMCIRuntime_callToString(constant, JVMCI_CHECK); 1260 const char* to_string = JVMCIENV->as_utf8_string(string); 1261 JVMCI_THROW_MSG(IllegalArgumentException, err_msg("Direct object constant reached the backend: %s", to_string)); 1262 } 1263 if (!_immutable_pic_compilation) { 1264 // Do not patch during PIC compilation. 1265 pd_patch_OopConstant(pc_offset, constant, JVMCI_CHECK); 1266 } 1267 } else if (jvmci_env()->isa_IndirectHotSpotObjectConstantImpl(constant)) { 1268 if (!_immutable_pic_compilation) { 1269 // Do not patch during PIC compilation. 1270 pd_patch_OopConstant(pc_offset, constant, JVMCI_CHECK); 1271 } 1272 } else if (jvmci_env()->isa_HotSpotMetaspaceConstantImpl(constant)) { 1273 if (!_immutable_pic_compilation) { 1274 pd_patch_MetaspaceConstant(pc_offset, constant, JVMCI_CHECK); 1275 } 1276 #if INCLUDE_AOT 1277 } else if (jvmci_env()->isa_HotSpotSentinelConstant(constant)) { 1278 if (!_immutable_pic_compilation) { 1279 JVMCI_ERROR("sentinel constant not supported for normal compiles: %s", jvmci_env()->klass_name(constant)); 1280 } 1281 #endif 1282 } else { 1283 JVMCI_ERROR("unknown constant type in data patch: %s", jvmci_env()->klass_name(constant)); 1284 } 1285 } else if (jvmci_env()->isa_site_DataSectionReference(reference)) { 1286 int data_offset = jvmci_env()->get_site_DataSectionReference_offset(reference); 1287 if (0 <= data_offset && data_offset < _constants_size) { 1288 pd_patch_DataSectionReference(pc_offset, data_offset, JVMCI_CHECK); 1289 } else { 1290 JVMCI_ERROR("data offset 0x%X points outside data section (size 0x%X)", data_offset, _constants_size); 1291 } 1292 } else { 1293 JVMCI_ERROR("unknown data patch type: %s", jvmci_env()->klass_name(reference)); 1294 } 1295 } 1296 1297 void CodeInstaller::site_Mark(CodeBuffer& buffer, jint pc_offset, JVMCIObject site, JVMCI_TRAPS) { 1298 JVMCIObject id_obj = jvmci_env()->get_site_Mark_id(site); 1299 1300 if (id_obj.is_non_null()) { 1301 if (!jvmci_env()->is_boxing_object(T_INT, id_obj)) { 1302 JVMCI_ERROR("expected Integer id, got %s", jvmci_env()->klass_name(id_obj)); 1303 } 1304 jint id = jvmci_env()->get_boxed_value(T_INT, id_obj).i; 1305 1306 address pc = _instructions->start() + pc_offset; 1307 1308 switch (id) { 1309 case UNVERIFIED_ENTRY: 1310 _offsets.set_value(CodeOffsets::Entry, pc_offset); 1311 break; 1312 case VERIFIED_ENTRY: 1313 _offsets.set_value(CodeOffsets::Verified_Entry, pc_offset); 1314 break; 1315 case OSR_ENTRY: 1316 _offsets.set_value(CodeOffsets::OSR_Entry, pc_offset); 1317 break; 1318 case EXCEPTION_HANDLER_ENTRY: 1319 _offsets.set_value(CodeOffsets::Exceptions, pc_offset); 1320 break; 1321 case DEOPT_HANDLER_ENTRY: 1322 _offsets.set_value(CodeOffsets::Deopt, pc_offset); 1323 break; 1324 case INVOKEVIRTUAL: 1325 case INVOKEINTERFACE: 1326 case INLINE_INVOKE: 1327 case INVOKESTATIC: 1328 case INVOKESPECIAL: 1329 _next_call_type = (MarkId) id; 1330 _invoke_mark_pc = pc; 1331 break; 1332 case POLL_NEAR: 1333 case POLL_FAR: 1334 case POLL_RETURN_NEAR: 1335 case POLL_RETURN_FAR: 1336 pd_relocate_poll(pc, id, JVMCI_CHECK); 1337 break; 1338 case CARD_TABLE_SHIFT: 1339 case CARD_TABLE_ADDRESS: 1340 case HEAP_TOP_ADDRESS: 1341 case HEAP_END_ADDRESS: 1342 case NARROW_KLASS_BASE_ADDRESS: 1343 case NARROW_OOP_BASE_ADDRESS: 1344 case CRC_TABLE_ADDRESS: 1345 case LOG_OF_HEAP_REGION_GRAIN_BYTES: 1346 case INLINE_CONTIGUOUS_ALLOCATION_SUPPORTED: 1347 break; 1348 default: 1349 JVMCI_ERROR("invalid mark id: %d", id); 1350 break; 1351 } 1352 } 1353 }