stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8139589: [JVMCI] throw exceptions in faulty code installation operations

Browse Source 
Reviewed-by: twisti
This commit is contained in:
Roland Schatz 2015-11-06 10:06:51 -10:00 committed by Christian Thalinger
parent 7e827560be
commit 26f02e4686
15 changed files with 1084 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
hotspot/src/cpu/aarch64/vm/jvmciCodeInstaller_aarch64.cpp
View File

@ -29,16 +29,16 @@
#include "runtime/sharedRuntime.hpp"
#include "vmreg_aarch64.inline.hpp"
jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, oop method) {
jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, Handle method, TRAPS) {
Unimplemented();
return 0;
}
void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle& constant) {
void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle constant, TRAPS) {
Unimplemented();
}
void CodeInstaller::pd_patch_MetaspaceConstant(int pc_offset, Handle& constant) {
void CodeInstaller::pd_patch_MetaspaceConstant(int pc_offset, Handle constant, TRAPS) {
Unimplemented();
}
@ -46,20 +46,20 @@ void CodeInstaller::pd_patch_DataSectionReference(int pc_offset, int data_offset
Unimplemented();
}
void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination) {
void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination, TRAPS) {
Unimplemented();
}
void CodeInstaller::pd_relocate_JavaMethod(oop hotspot_method, jint pc_offset) {
void CodeInstaller::pd_relocate_JavaMethod(Handle hotspot_method, jint pc_offset, TRAPS) {
Unimplemented();
}
void CodeInstaller::pd_relocate_poll(address pc, jint mark) {
void CodeInstaller::pd_relocate_poll(address pc, jint mark, TRAPS) {
Unimplemented();
}
// convert JVMCI register indices (as used in oop maps) to HotSpot registers
VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg) {
VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg, TRAPS) {
return NULL;
}

14
hotspot/src/cpu/ppc/vm/jvmciCodeInstaller_ppc.cpp
View File

@ -29,16 +29,16 @@
#include "runtime/sharedRuntime.hpp"
#include "vmreg_ppc.inline.hpp"
jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, oop method) {
jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, Handle method, TRAPS) {
Unimplemented();
return 0;
}
void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle& constant) {
void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle constant, TRAPS) {
Unimplemented();
}
void CodeInstaller::pd_patch_MetaspaceConstant(int pc_offset, Handle& constant) {
void CodeInstaller::pd_patch_MetaspaceConstant(int pc_offset, Handle constant, TRAPS) {
Unimplemented();
}
@ -46,20 +46,20 @@ void CodeInstaller::pd_patch_DataSectionReference(int pc_offset, int data_offset
Unimplemented();
}
void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination) {
void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination, TRAPS) {
Unimplemented();
}
void CodeInstaller::pd_relocate_JavaMethod(oop hotspot_method, jint pc_offset) {
void CodeInstaller::pd_relocate_JavaMethod(Handle hotspot_method, jint pc_offset, TRAPS) {
Unimplemented();
}
void CodeInstaller::pd_relocate_poll(address pc, jint mark) {
void CodeInstaller::pd_relocate_poll(address pc, jint mark, TRAPS) {
Unimplemented();
}
// convert JVMCI register indices (as used in oop maps) to HotSpot registers
VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg) {
VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg, TRAPS) {
return NULL;
}

38
hotspot/src/cpu/sparc/vm/jvmciCodeInstaller_sparc.cpp
View File

@ -29,7 +29,7 @@
#include "runtime/sharedRuntime.hpp"
#include "vmreg_sparc.inline.hpp"
jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, oop method) {
jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, Handle method, TRAPS) {
if (inst->is_call() || inst->is_jump()) {
return pc_offset + NativeCall::instruction_size;
} else if (inst->is_call_reg()) {
@ -37,12 +37,12 @@ jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, oop
} else if (inst->is_sethi()) {
return pc_offset + NativeFarCall::instruction_size;
} else {
fatal("unsupported type of instruction for call site");
JVMCI_ERROR_0("unsupported type of instruction for call site");
return 0;
}
}
void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle& constant) {
void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle constant, TRAPS) {
address pc = _instructions->start() + pc_offset;
Handle obj = HotSpotObjectConstantImpl::object(constant);
jobject value = JNIHandles::make_local(obj());
@ -52,7 +52,7 @@ void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle& constant) {
RelocationHolder rspec = oop_Relocation::spec(oop_index);
_instructions->relocate(pc, rspec, 1);
#else
fatal("compressed oop on 32bit");
JVMCI_ERROR("compressed oop on 32bit");
#endif
} else {
NativeMovConstReg* move = nativeMovConstReg_at(pc);
@ -66,20 +66,20 @@ void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle& constant) {
}
}
void CodeInstaller::pd_patch_MetaspaceConstant(int pc_offset, Handle& constant) {
void CodeInstaller::pd_patch_MetaspaceConstant(int pc_offset, Handle constant, TRAPS) {
address pc = _instructions->start() + pc_offset;
if (HotSpotMetaspaceConstantImpl::compressed(constant)) {
#ifdef _LP64
NativeMovConstReg32* move = nativeMovConstReg32_at(pc);
narrowKlass narrowOop = record_narrow_metadata_reference(constant);
narrowKlass narrowOop = record_narrow_metadata_reference(constant, CHECK);
move->set_data((intptr_t)narrowOop);
TRACE_jvmci_3("relocating (narrow metaspace constant) at %p/%p", pc, narrowOop);
#else
fatal("compressed Klass* on 32bit");
JVMCI_ERROR("compressed Klass* on 32bit");
#endif
} else {
NativeMovConstReg* move = nativeMovConstReg_at(pc);
Metadata* reference = record_metadata_reference(constant);
Metadata* reference = record_metadata_reference(constant, CHECK);
move->set_data((intptr_t)reference);
TRACE_jvmci_3("relocating (metaspace constant) at %p/%p", pc, reference);
}
@ -106,7 +106,7 @@ void CodeInstaller::pd_patch_DataSectionReference(int pc_offset, int data_offset
}
}
void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination) {
void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination, TRAPS) {
address pc = (address) inst;
if (inst->is_call()) {
NativeCall* call = nativeCall_at(pc);
@ -117,17 +117,17 @@ void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong forei
jump->set_jump_destination((address) foreign_call_destination);
_instructions->relocate(jump->instruction_address(), runtime_call_Relocation::spec());
} else {
fatal(err_msg("unknown call or jump instruction at " PTR_FORMAT, p2i(pc)));
JVMCI_ERROR("unknown call or jump instruction at " PTR_FORMAT, p2i(pc));
}
TRACE_jvmci_3("relocating (foreign call) at " PTR_FORMAT, p2i(inst));
}
void CodeInstaller::pd_relocate_JavaMethod(oop hotspot_method, jint pc_offset) {
void CodeInstaller::pd_relocate_JavaMethod(Handle hotspot_method, jint pc_offset, TRAPS) {
#ifdef ASSERT
Method* method = NULL;
// we need to check, this might also be an unresolved method
if (hotspot_method->is_a(HotSpotResolvedJavaMethodImpl::klass())) {
method = getMethodFromHotSpotMethod(hotspot_method);
method = getMethodFromHotSpotMethod(hotspot_method());
}
#endif
switch (_next_call_type) {
@ -156,33 +156,33 @@ void CodeInstaller::pd_relocate_JavaMethod(oop hotspot_method, jint pc_offset) {
break;
}
default:
fatal("invalid _next_call_type value");
JVMCI_ERROR("invalid _next_call_type value");
break;
}
}
void CodeInstaller::pd_relocate_poll(address pc, jint mark) {
void CodeInstaller::pd_relocate_poll(address pc, jint mark, TRAPS) {
switch (mark) {
case POLL_NEAR:
fatal("unimplemented");
JVMCI_ERROR("unimplemented");
break;
case POLL_FAR:
_instructions->relocate(pc, relocInfo::poll_type);
break;
case POLL_RETURN_NEAR:
fatal("unimplemented");
JVMCI_ERROR("unimplemented");
break;
case POLL_RETURN_FAR:
_instructions->relocate(pc, relocInfo::poll_return_type);
break;
default:
fatal("invalid mark value");
JVMCI_ERROR("invalid mark value");
break;
}
}
// convert JVMCI register indices (as used in oop maps) to HotSpot registers
VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg) {
VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg, TRAPS) {
// JVMCI Registers are numbered as follows:
// 0..31: Thirty-two General Purpose registers (CPU Registers)
// 32..63: Thirty-two single precision float registers
@ -199,7 +199,7 @@ VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg) {
} else if(jvmci_reg < 112) {
floatRegisterNumber = 4 * (jvmci_reg - 96);
} else {
fatal("Unknown jvmci register");
JVMCI_ERROR_NULL("invalid register number: %d", jvmci_reg);
}
return as_FloatRegister(floatRegisterNumber)->as_VMReg();
}

37
hotspot/src/cpu/x86/vm/jvmciCodeInstaller_x86.cpp
View File

@ -36,7 +36,7 @@
#include "code/vmreg.hpp"
#include "vmreg_x86.inline.hpp"
jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, oop method) {
jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, Handle method, TRAPS) {
if (inst->is_call() || inst->is_jump()) {
assert(NativeCall::instruction_size == (int)NativeJump::instruction_size, "unexpected size");
return (pc_offset + NativeCall::instruction_size);
@ -53,18 +53,17 @@ jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, oop
return (offset);
} else if (inst->is_call_reg()) {
// the inlined vtable stub contains a "call register" instruction
assert(method != NULL, "only valid for virtual calls");
assert(method.not_null(), "only valid for virtual calls");
return (pc_offset + ((NativeCallReg *) inst)->next_instruction_offset());
} else if (inst->is_cond_jump()) {
address pc = (address) (inst);
return pc_offset + (jint) (Assembler::locate_next_instruction(pc) - pc);
} else {
fatal("unsupported type of instruction for call site");
return 0;
JVMCI_ERROR_0("unsupported type of instruction for call site");
}
}
void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle& constant) {
void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle constant, TRAPS) {
address pc = _instructions->start() + pc_offset;
Handle obj = HotSpotObjectConstantImpl::object(constant);
jobject value = JNIHandles::make_local(obj());
@ -75,7 +74,7 @@ void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle& constant) {
_instructions->relocate(pc, oop_Relocation::spec(oop_index), Assembler::narrow_oop_operand);
TRACE_jvmci_3("relocating (narrow oop constant) at " PTR_FORMAT "/" PTR_FORMAT, p2i(pc), p2i(operand));
#else
fatal("compressed oop on 32bit");
JVMCI_ERROR("compressed oop on 32bit");
#endif
} else {
address operand = Assembler::locate_operand(pc, Assembler::imm_operand);
@ -85,19 +84,19 @@ void CodeInstaller::pd_patch_OopConstant(int pc_offset, Handle& constant) {
}
}
void CodeInstaller::pd_patch_MetaspaceConstant(int pc_offset, Handle& constant) {
void CodeInstaller::pd_patch_MetaspaceConstant(int pc_offset, Handle constant, TRAPS) {
address pc = _instructions->start() + pc_offset;
if (HotSpotMetaspaceConstantImpl::compressed(constant)) {
#ifdef _LP64
address operand = Assembler::locate_operand(pc, Assembler::narrow_oop_operand);
*((narrowKlass*) operand) = record_narrow_metadata_reference(constant);
*((narrowKlass*) operand) = record_narrow_metadata_reference(constant, CHECK);
TRACE_jvmci_3("relocating (narrow metaspace constant) at " PTR_FORMAT "/" PTR_FORMAT, p2i(pc), p2i(operand));
#else
fatal("compressed Klass* on 32bit");
JVMCI_ERROR("compressed Klass* on 32bit");
#endif
} else {
address operand = Assembler::locate_operand(pc, Assembler::imm_operand);
*((Metadata**) operand) = record_metadata_reference(constant);
*((Metadata**) operand) = record_metadata_reference(constant, CHECK);
TRACE_jvmci_3("relocating (metaspace constant) at " PTR_FORMAT "/" PTR_FORMAT, p2i(pc), p2i(operand));
}
}
@ -117,7 +116,7 @@ void CodeInstaller::pd_patch_DataSectionReference(int pc_offset, int data_offset
TRACE_jvmci_3("relocating at " PTR_FORMAT "/" PTR_FORMAT " with destination at " PTR_FORMAT " (%d)", p2i(pc), p2i(operand), p2i(dest), data_offset);
}
void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination) {
void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination, TRAPS) {
address pc = (address) inst;
if (inst->is_call()) {
// NOTE: for call without a mov, the offset must fit a 32-bit immediate
@ -139,18 +138,18 @@ void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong forei
*(jint*) disp += ((address) foreign_call_destination) - old_dest;
_instructions->relocate(pc, runtime_call_Relocation::spec(), Assembler::call32_operand);
} else {
fatal("unsupported relocation for foreign call");
JVMCI_ERROR("unsupported relocation for foreign call");
}
TRACE_jvmci_3("relocating (foreign call) at " PTR_FORMAT, p2i(inst));
}
void CodeInstaller::pd_relocate_JavaMethod(oop hotspot_method, jint pc_offset) {
void CodeInstaller::pd_relocate_JavaMethod(Handle hotspot_method, jint pc_offset, TRAPS) {
#ifdef ASSERT
Method* method = NULL;
// we need to check, this might also be an unresolved method
if (hotspot_method->is_a(HotSpotResolvedJavaMethodImpl::klass())) {
method = getMethodFromHotSpotMethod(hotspot_method);
method = getMethodFromHotSpotMethod(hotspot_method());
}
#endif
switch (_next_call_type) {
@ -185,6 +184,7 @@ void CodeInstaller::pd_relocate_JavaMethod(oop hotspot_method, jint pc_offset) {
break;
}
default:
JVMCI_ERROR("invalid _next_call_type value");
break;
}
}
@ -198,7 +198,7 @@ static void relocate_poll_near(address pc) {
}
void CodeInstaller::pd_relocate_poll(address pc, jint mark) {
void CodeInstaller::pd_relocate_poll(address pc, jint mark, TRAPS) {
switch (mark) {
case POLL_NEAR: {
relocate_poll_near(pc);
@ -222,13 +222,13 @@ void CodeInstaller::pd_relocate_poll(address pc, jint mark) {
_instructions->relocate(pc, relocInfo::poll_return_type, Assembler::imm_operand);
break;
default:
fatal("invalid mark value");
JVMCI_ERROR("invalid mark value: %d", mark);
break;
}
}
// convert JVMCI register indices (as used in oop maps) to HotSpot registers
VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg) {
VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg, TRAPS) {
if (jvmci_reg < RegisterImpl::number_of_registers) {
return as_Register(jvmci_reg)->as_VMReg();
} else {
@ -236,8 +236,7 @@ VMReg CodeInstaller::get_hotspot_reg(jint jvmci_reg) {
if (floatRegisterNumber < XMMRegisterImpl::number_of_registers) {
return as_XMMRegister(floatRegisterNumber)->as_VMReg();
}
ShouldNotReachHere();
return NULL;
JVMCI_ERROR_NULL("invalid register number: %d", jvmci_reg);
}
}

3
hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/CompilerToVM.java
View File

@ -32,6 +32,7 @@ import java.lang.reflect.Method;
import jdk.vm.ci.code.InstalledCode;
import jdk.vm.ci.code.InvalidInstalledCodeException;
import jdk.vm.ci.code.TargetDescription;
import jdk.vm.ci.common.JVMCIError;
import jdk.vm.ci.hotspotvmconfig.HotSpotVMField;
import jdk.vm.ci.inittimer.InitTimer;
import jdk.vm.ci.meta.JavaType;
@ -308,6 +309,8 @@ final class CompilerToVM {
* {@link HotSpotVMConfig#codeInstallResultCodeTooLarge},
* {@link HotSpotVMConfig#codeInstallResultDependenciesFailed} or
* {@link HotSpotVMConfig#codeInstallResultDependenciesInvalid}.
* @throws JVMCIError if there is something wrong with the compiled code or the associated
* metadata.
*/
native int installCode(TargetDescription target, HotSpotCompiledCode compiledCode, InstalledCode code, HotSpotSpeculationLog speculationLog);

529
hotspot/src/share/vm/jvmci/jvmciCodeInstaller.cpp
View File

@ -71,62 +71,97 @@ Method* getMethodFromHotSpotMethod(oop hotspot_method) {
return CompilerToVM::asMethod(hotspot_method);
}
VMReg getVMRegFromLocation(oop location, int total_frame_size) {
oop reg = code_Location::reg(location);
VMReg getVMRegFromLocation(Handle location, int total_frame_size, TRAPS) {
if (location.is_null()) {
THROW_NULL(vmSymbols::java_lang_NullPointerException());
}
Handle reg = code_Location::reg(location);
jint offset = code_Location::offset(location);
if (reg != NULL) {
if (reg.not_null()) {
// register
jint number = code_Register::number(reg);
VMReg vmReg = CodeInstaller::get_hotspot_reg(number);
assert(offset % 4 == 0, "must be aligned");
return vmReg->next(offset / 4);
VMReg vmReg = CodeInstaller::get_hotspot_reg(number, CHECK_NULL);
if (offset % 4 == 0) {
return vmReg->next(offset / 4);
} else {
JVMCI_ERROR_NULL("unaligned subregister offset %d in oop map", offset);
}
} else {
// stack slot
assert(offset % 4 == 0, "must be aligned");
return VMRegImpl::stack2reg(offset / 4);
if (offset % 4 == 0) {
return VMRegImpl::stack2reg(offset / 4);
} else {
JVMCI_ERROR_NULL("unaligned stack offset %d in oop map", offset);
}
}
}
// creates a HotSpot oop map out of the byte arrays provided by DebugInfo
OopMap* CodeInstaller::create_oop_map(oop debug_info) {
oop reference_map = DebugInfo::referenceMap(debug_info);
OopMap* CodeInstaller::create_oop_map(Handle debug_info, TRAPS) {
Handle reference_map = DebugInfo::referenceMap(debug_info);
if (reference_map.is_null()) {
THROW_NULL(vmSymbols::java_lang_NullPointerException());
}
if (!reference_map->is_a(HotSpotReferenceMap::klass())) {
JVMCI_ERROR_NULL("unknown reference map: %s", reference_map->klass()->signature_name());
}
if (HotSpotReferenceMap::maxRegisterSize(reference_map) > 16) {
_has_wide_vector = true;
}
OopMap* map = new OopMap(_total_frame_size, _parameter_count);
objArrayOop objects = HotSpotReferenceMap::objects(reference_map);
objArrayOop derivedBase = HotSpotReferenceMap::derivedBase(reference_map);
typeArrayOop sizeInBytes = HotSpotReferenceMap::sizeInBytes(reference_map);
objArrayHandle objects = HotSpotReferenceMap::objects(reference_map);
objArrayHandle derivedBase = HotSpotReferenceMap::derivedBase(reference_map);
typeArrayHandle sizeInBytes = HotSpotReferenceMap::sizeInBytes(reference_map);
if (objects.is_null() || derivedBase.is_null() || sizeInBytes.is_null()) {
THROW_NULL(vmSymbols::java_lang_NullPointerException());
}
if (objects->length() != derivedBase->length() || objects->length() != sizeInBytes->length()) {
JVMCI_ERROR_NULL("arrays in reference map have different sizes: %d %d %d", objects->length(), derivedBase->length(), sizeInBytes->length());
}
for (int i = 0; i < objects->length(); i++) {
oop location = objects->obj_at(i);
oop baseLocation = derivedBase->obj_at(i);
Handle location = objects->obj_at(i);
Handle baseLocation = derivedBase->obj_at(i);
int bytes = sizeInBytes->int_at(i);
VMReg vmReg = getVMRegFromLocation(location, _total_frame_size);
if (baseLocation != NULL) {
VMReg vmReg = getVMRegFromLocation(location, _total_frame_size, CHECK_NULL);
if (baseLocation.not_null()) {
// derived oop
assert(bytes == 8, "derived oop can't be compressed");
VMReg baseReg = getVMRegFromLocation(baseLocation, _total_frame_size);
map->set_derived_oop(vmReg, baseReg);
#ifdef _LP64
if (bytes == 8) {
#else
if (bytes == 4) {
#endif
VMReg baseReg = getVMRegFromLocation(baseLocation, _total_frame_size, CHECK_NULL);
map->set_derived_oop(vmReg, baseReg);
} else {
JVMCI_ERROR_NULL("invalid derived oop size in ReferenceMap: %d", bytes);
}
#ifdef _LP64
} else if (bytes == 8) {
// wide oop
map->set_oop(vmReg);
} else {
} else if (bytes == 4) {
// narrow oop
assert(bytes == 4, "wrong size");
map->set_narrowoop(vmReg);
#else
} else if (bytes == 4) {
map->set_oop(vmReg);
#endif
} else {
JVMCI_ERROR_NULL("invalid oop size in ReferenceMap: %d", bytes);
}
}
oop callee_save_info = (oop) DebugInfo::calleeSaveInfo(debug_info);
if (callee_save_info != NULL) {
objArrayOop registers = RegisterSaveLayout::registers(callee_save_info);
typeArrayOop slots = RegisterSaveLayout::slots(callee_save_info);
Handle callee_save_info = (oop) DebugInfo::calleeSaveInfo(debug_info);
if (callee_save_info.not_null()) {
objArrayHandle registers = RegisterSaveLayout::registers(callee_save_info);
typeArrayHandle slots = RegisterSaveLayout::slots(callee_save_info);
for (jint i = 0; i < slots->length(); i++) {
oop jvmci_reg = registers->obj_at(i);
Handle jvmci_reg = registers->obj_at(i);
jint jvmci_reg_number = code_Register::number(jvmci_reg);
VMReg hotspot_reg = CodeInstaller::get_hotspot_reg(jvmci_reg_number);
VMReg hotspot_reg = CodeInstaller::get_hotspot_reg(jvmci_reg_number, CHECK_NULL);
// HotSpot stack slots are 4 bytes
jint jvmci_slot = slots->int_at(i);
jint hotspot_slot = jvmci_slot * VMRegImpl::slots_per_word;
@ -142,7 +177,7 @@ OopMap* CodeInstaller::create_oop_map(oop debug_info) {
return map;
}
Metadata* CodeInstaller::record_metadata_reference(Handle& constant) {
Metadata* CodeInstaller::record_metadata_reference(Handle constant, TRAPS) {
oop obj = HotSpotMetaspaceConstantImpl::metaspaceObject(constant);
if (obj->is_a(HotSpotResolvedObjectTypeImpl::klass())) {
Klass* klass = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(obj));
@ -157,16 +192,18 @@ Metadata* CodeInstaller::record_metadata_reference(Handle& constant) {
TRACE_jvmci_3("metadata[%d of %d] = %s", index, _oop_recorder->metadata_count(), method->name()->as_C_string());
return method;
} else {
fatal("unexpected metadata reference for constant of type %s", obj->klass()->name()->as_C_string());
return NULL;
JVMCI_ERROR_NULL("unexpected metadata reference for constant of type %s", obj->klass()->signature_name());
}
}
#ifdef _LP64
narrowKlass CodeInstaller::record_narrow_metadata_reference(Handle& constant) {
narrowKlass CodeInstaller::record_narrow_metadata_reference(Handle constant, TRAPS) {
oop obj = HotSpotMetaspaceConstantImpl::metaspaceObject(constant);
assert(HotSpotMetaspaceConstantImpl::compressed(constant), "unexpected uncompressed pointer");
assert(obj->is_a(HotSpotResolvedObjectTypeImpl::klass()), "unexpected compressed pointer of type %s", obj->klass()->name()->as_C_string());
if (!obj->is_a(HotSpotResolvedObjectTypeImpl::klass())) {
JVMCI_ERROR_0("unexpected compressed pointer of type %s", obj->klass()->signature_name());
}
Klass* klass = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(obj));
int index = _oop_recorder->find_index(klass);
@ -175,9 +212,9 @@ narrowKlass CodeInstaller::record_narrow_metadata_reference(Handle& constant) {
}
#endif
Location::Type CodeInstaller::get_oop_type(oop value) {
oop lirKind = Value::lirKind(value);
oop platformKind = LIRKind::platformKind(lirKind);
Location::Type CodeInstaller::get_oop_type(Handle value) {
Handle lirKind = Value::lirKind(value);
Handle platformKind = LIRKind::platformKind(lirKind);
assert(LIRKind::referenceMask(lirKind) == 1, "unexpected referenceMask");
if (platformKind == word_kind()) {
@ -187,24 +224,29 @@ Location::Type CodeInstaller::get_oop_type(oop value) {
}
}
ScopeValue* CodeInstaller::get_scope_value(oop value, BasicType type, GrowableArray<ScopeValue*>* objects, ScopeValue* &second) {
ScopeValue* CodeInstaller::get_scope_value(Handle value, BasicType type, GrowableArray<ScopeValue*>* objects, ScopeValue* &second, TRAPS) {
second = NULL;
if (value == Value::ILLEGAL()) {
assert(type == T_ILLEGAL, "expected legal value");
if (value.is_null()) {
THROW_NULL(vmSymbols::java_lang_NullPointerException());
} else if (value == Value::ILLEGAL()) {
if (type != T_ILLEGAL) {
JVMCI_ERROR_NULL("unexpected illegal value, expected %s", basictype_to_str(type));
}
return _illegal_value;
} else if (value->is_a(RegisterValue::klass())) {
oop reg = RegisterValue::reg(value);
Handle reg = RegisterValue::reg(value);
jint number = code_Register::number(reg);
VMReg hotspotRegister = get_hotspot_reg(number);
VMReg hotspotRegister = get_hotspot_reg(number, CHECK_NULL);
if (is_general_purpose_reg(hotspotRegister)) {
Location::Type locationType;
if (type == T_OBJECT) {
locationType = get_oop_type(value);
} else if (type == T_LONG) {
locationType = Location::lng;
} else {
assert(type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN, "unexpected type in cpu register");
} else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) {
locationType = Location::int_in_long;
} else {
JVMCI_ERROR_NULL("unexpected type %s in cpu register", basictype_to_str(type));
}
ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));
if (type == T_LONG) {
@ -212,13 +254,14 @@ ScopeValue* CodeInstaller::get_scope_value(oop value, BasicType type, GrowableAr
}
return value;
} else {
assert(type == T_FLOAT || type == T_DOUBLE, "only float and double expected in xmm register");
Location::Type locationType;
if (type == T_FLOAT) {
// this seems weird, but the same value is used in c1_LinearScan
locationType = Location::normal;
} else {
} else if (type == T_DOUBLE) {
locationType = Location::dbl;
} else {
JVMCI_ERROR_NULL("unexpected type %s in floating point register", basictype_to_str(type));
}
ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));
if (type == T_DOUBLE) {
@ -239,9 +282,10 @@ ScopeValue* CodeInstaller::get_scope_value(oop value, BasicType type, GrowableAr
locationType = Location::lng;
} else if (type == T_DOUBLE) {
locationType = Location::dbl;
} else {
assert(type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN, "unexpected type in stack slot");
} else if (type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN) {
locationType = Location::normal;
} else {
JVMCI_ERROR_NULL("unexpected type %s in stack slot", basictype_to_str(type));
}
ScopeValue* value = new LocationValue(Location::new_stk_loc(locationType, offset));
if (type == T_DOUBLE || type == T_LONG) {
@ -254,7 +298,10 @@ ScopeValue* CodeInstaller::get_scope_value(oop value, BasicType type, GrowableAr
jlong prim = PrimitiveConstant::primitive(value);
return new ConstantLongValue(prim);
} else {
assert(type == JVMCIRuntime::kindToBasicType(JavaKind::typeChar(PrimitiveConstant::kind(value))), "primitive constant type doesn't match");
BasicType constantType = JVMCIRuntime::kindToBasicType(PrimitiveConstant::kind(value), CHECK_NULL);
if (type != constantType) {
JVMCI_ERROR_NULL("primitive constant type doesn't match, expected %s but got %s", basictype_to_str(type), basictype_to_str(constantType));
}
if (type == T_INT || type == T_FLOAT) {
jint prim = (jint)PrimitiveConstant::primitive(value);
switch (prim) {
@ -264,53 +311,63 @@ ScopeValue* CodeInstaller::get_scope_value(oop value, BasicType type, GrowableAr
case 2: return _int_2_scope_value;
default: return new ConstantIntValue(prim);
}
} else {
assert(type == T_LONG || type == T_DOUBLE, "unexpected primitive constant type");
} else if (type == T_LONG || type == T_DOUBLE) {
jlong prim = PrimitiveConstant::primitive(value);
second = _int_1_scope_value;
return new ConstantLongValue(prim);
} else {
JVMCI_ERROR_NULL("unexpected primitive constant type %s", basictype_to_str(type));
}
}
} else {
assert(type == T_OBJECT, "unexpected object constant");
if (value->is_a(NullConstant::klass()) || value->is_a(HotSpotCompressedNullConstant::klass())) {
} else if (value->is_a(NullConstant::klass()) || value->is_a(HotSpotCompressedNullConstant::klass())) {
if (type == T_OBJECT) {
return _oop_null_scope_value;
} else {
assert(value->is_a(HotSpotObjectConstantImpl::klass()), "unexpected constant type");
JVMCI_ERROR_NULL("unexpected null constant, expected %s", basictype_to_str(type));
}
} else if (value->is_a(HotSpotObjectConstantImpl::klass())) {
if (type == T_OBJECT) {
oop obj = HotSpotObjectConstantImpl::object(value);
assert(obj != NULL, "null value must be in NullConstant");
if (obj == NULL) {
JVMCI_ERROR_NULL("null value must be in NullConstant");
}
return new ConstantOopWriteValue(JNIHandles::make_local(obj));
} else {
JVMCI_ERROR_NULL("unexpected object constant, expected %s", basictype_to_str(type));
}
}
} else if (value->is_a(VirtualObject::klass())) {
assert(type == T_OBJECT, "unexpected virtual object");
int id = VirtualObject::id(value);
ScopeValue* object = objects->at(id);
assert(object != NULL, "missing value");
return object;
} else {
value->klass()->print();
value->print();
if (type == T_OBJECT) {
int id = VirtualObject::id(value);
if (0 <= id && id < objects->length()) {
ScopeValue* object = objects->at(id);
if (object != NULL) {
return object;
}
}
JVMCI_ERROR_NULL("unknown virtual object id %d", id);
} else {
JVMCI_ERROR_NULL("unexpected virtual object, expected %s", basictype_to_str(type));
}
}
ShouldNotReachHere();
return NULL;
JVMCI_ERROR_NULL("unexpected value in scope: %s", value->klass()->signature_name())
}
void CodeInstaller::record_object_value(ObjectValue* sv, oop value, GrowableArray<ScopeValue*>* objects) {
oop type = VirtualObject::type(value);
void CodeInstaller::record_object_value(ObjectValue* sv, Handle value, GrowableArray<ScopeValue*>* objects, TRAPS) {
Handle type = VirtualObject::type(value);
int id = VirtualObject::id(value);
oop javaMirror = HotSpotResolvedObjectTypeImpl::javaClass(type);
Klass* klass = java_lang_Class::as_Klass(javaMirror);
bool isLongArray = klass == Universe::longArrayKlassObj();
objArrayOop values = VirtualObject::values(value);
objArrayOop slotKinds = VirtualObject::slotKinds(value);
objArrayHandle values = VirtualObject::values(value);
objArrayHandle slotKinds = VirtualObject::slotKinds(value);
for (jint i = 0; i < values->length(); i++) {
ScopeValue* cur_second = NULL;
oop object = values->obj_at(i);
oop kind = slotKinds->obj_at(i);
BasicType type = JVMCIRuntime::kindToBasicType(JavaKind::typeChar(kind));
ScopeValue* value = get_scope_value(object, type, objects, cur_second);
Handle object = values->obj_at(i);
BasicType type = JVMCIRuntime::kindToBasicType(slotKinds->obj_at(i), CHECK);
ScopeValue* value = get_scope_value(object, type, objects, cur_second, CHECK);
if (isLongArray && cur_second == NULL) {
// we're trying to put ints into a long array... this isn't really valid, but it's used for some optimizations.
@ -326,14 +383,19 @@ void CodeInstaller::record_object_value(ObjectValue* sv, oop value, GrowableArra
}
}
MonitorValue* CodeInstaller::get_monitor_value(oop value, GrowableArray<ScopeValue*>* objects) {
guarantee(value->is_a(StackLockValue::klass()), "Monitors must be of type StackLockValue");
MonitorValue* CodeInstaller::get_monitor_value(Handle value, GrowableArray<ScopeValue*>* objects, TRAPS) {
if (value.is_null()) {
THROW_NULL(vmSymbols::java_lang_NullPointerException());
}
if (!value->is_a(StackLockValue::klass())) {
JVMCI_ERROR_NULL("Monitors must be of type StackLockValue, got %s", value->klass()->signature_name());
}
ScopeValue* second = NULL;
ScopeValue* owner_value = get_scope_value(StackLockValue::owner(value), T_OBJECT, objects, second);
ScopeValue* owner_value = get_scope_value(StackLockValue::owner(value), T_OBJECT, objects, second, CHECK_NULL);
assert(second == NULL, "monitor cannot occupy two stack slots");
ScopeValue* lock_data_value = get_scope_value(StackLockValue::slot(value), T_LONG, objects, second);
ScopeValue* lock_data_value = get_scope_value(StackLockValue::slot(value), T_LONG, objects, second, CHECK_NULL);
assert(second == lock_data_value, "monitor is LONG value that occupies two stack slots");
assert(lock_data_value->is_location(), "invalid monitor location");
Location lock_data_loc = ((LocationValue*)lock_data_value)->location();
@ -346,7 +408,7 @@ MonitorValue* CodeInstaller::get_monitor_value(oop value, GrowableArray<ScopeVal
return new MonitorValue(owner_value, lock_data_loc, eliminated);
}
void CodeInstaller::initialize_dependencies(oop compiled_code, OopRecorder* recorder) {
void CodeInstaller::initialize_dependencies(oop compiled_code, OopRecorder* recorder, TRAPS) {
JavaThread* thread = JavaThread::current();
CompilerThread* compilerThread = thread->is_Compiler_thread() ? thread->as_CompilerThread() : NULL;
_oop_recorder = recorder;
@ -368,8 +430,7 @@ void CodeInstaller::initialize_dependencies(oop compiled_code, OopRecorder* reco
} else if (assumption->klass() == Assumptions_CallSiteTargetValue::klass()) {
assumption_CallSiteTargetValue(assumption);
} else {
assumption->print();
fatal("unexpected Assumption subclass");
JVMCI_ERROR("unexpected Assumption subclass %s", assumption->klass()->signature_name());
}
}
}
@ -414,18 +475,19 @@ void RelocBuffer::ensure_size(size_t bytes) {
_size = bytes;
}
JVMCIEnv::CodeInstallResult CodeInstaller::gather_metadata(Handle target, Handle& compiled_code, CodeMetadata& metadata) {
JVMCIEnv::CodeInstallResult CodeInstaller::gather_metadata(Handle target, Handle& compiled_code, CodeMetadata& metadata, TRAPS) {
CodeBuffer buffer("JVMCI Compiler CodeBuffer for Metadata");
jobject compiled_code_obj = JNIHandles::make_local(compiled_code());
initialize_dependencies(JNIHandles::resolve(compiled_code_obj), NULL);
initialize_dependencies(JNIHandles::resolve(compiled_code_obj), NULL, CHECK_OK);
// Get instructions and constants CodeSections early because we need it.
_instructions = buffer.insts();
_constants = buffer.consts();
initialize_fields(target(), JNIHandles::resolve(compiled_code_obj));
if (!initialize_buffer(buffer)) {
return JVMCIEnv::code_too_large;
initialize_fields(target(), JNIHandles::resolve(compiled_code_obj), CHECK_OK);
JVMCIEnv::CodeInstallResult result = initialize_buffer(buffer, CHECK_OK);
if (result != JVMCIEnv::ok) {
return result;
}
process_exception_handlers();
@ -446,18 +508,18 @@ JVMCIEnv::CodeInstallResult CodeInstaller::gather_metadata(Handle target, Handle
}
// constructor used to create a method
JVMCIEnv::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler, Handle target, Handle& compiled_code, CodeBlob*& cb, Handle installed_code, Handle speculation_log) {
JVMCIEnv::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler, Handle target, Handle& compiled_code, CodeBlob*& cb, Handle installed_code, Handle speculation_log, TRAPS) {
CodeBuffer buffer("JVMCI Compiler CodeBuffer");
jobject compiled_code_obj = JNIHandles::make_local(compiled_code());
OopRecorder* recorder = new OopRecorder(&_arena, true);
initialize_dependencies(JNIHandles::resolve(compiled_code_obj), recorder);
initialize_dependencies(JNIHandles::resolve(compiled_code_obj), recorder, CHECK_OK);
// Get instructions and constants CodeSections early because we need it.
_instructions = buffer.insts();
_constants = buffer.consts();
initialize_fields(target(), JNIHandles::resolve(compiled_code_obj));
JVMCIEnv::CodeInstallResult result = initialize_buffer(buffer);
initialize_fields(target(), JNIHandles::resolve(compiled_code_obj), CHECK_OK);
JVMCIEnv::CodeInstallResult result = initialize_buffer(buffer, CHECK_OK);
if (result != JVMCIEnv::ok) {
return result;
}
@ -500,7 +562,7 @@ JVMCIEnv::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler, Hand
return result;
}
void CodeInstaller::initialize_fields(oop target, oop compiled_code) {
void CodeInstaller::initialize_fields(oop target, oop compiled_code, TRAPS) {
if (compiled_code->is_a(HotSpotCompiledNmethod::klass())) {
Handle hotspotJavaMethod = HotSpotCompiledNmethod::method(compiled_code);
methodHandle method = getMethodFromHotSpotMethod(hotspotJavaMethod());
@ -521,7 +583,9 @@ void CodeInstaller::initialize_fields(oop target, oop compiled_code) {
// Pre-calculate the constants section size. This is required for PC-relative addressing.
_data_section_handle = JNIHandles::make_local(HotSpotCompiledCode::dataSection(compiled_code));
guarantee(HotSpotCompiledCode::dataSectionAlignment(compiled_code) <= _constants->alignment(), "Alignment inside constants section is restricted by alignment of section begin");
if ((_constants->alignment() % HotSpotCompiledCode::dataSectionAlignment(compiled_code)) != 0) {
JVMCI_ERROR("invalid data section alignment: %d", HotSpotCompiledCode::dataSectionAlignment(compiled_code));
}
_constants_size = data_section()->length();
_data_section_patches_handle = JNIHandles::make_local(HotSpotCompiledCode::dataSectionPatches(compiled_code));
@ -538,16 +602,18 @@ void CodeInstaller::initialize_fields(oop target, oop compiled_code) {
_word_kind_handle = JNIHandles::make_local(Architecture::wordKind(arch));
}
int CodeInstaller::estimate_stubs_size() {
int CodeInstaller::estimate_stubs_size(TRAPS) {
// Estimate the number of static call stubs that might be emitted.
int static_call_stubs = 0;
objArrayOop sites = this->sites();
for (int i = 0; i < sites->length(); i++) {
oop site = sites->obj_at(i);
if (site->is_a(CompilationResult_Mark::klass())) {
if (site != NULL && site->is_a(CompilationResult_Mark::klass())) {
oop id_obj = CompilationResult_Mark::id(site);
if (id_obj != NULL) {
assert(java_lang_boxing_object::is_instance(id_obj, T_INT), "Integer id expected");
if (!java_lang_boxing_object::is_instance(id_obj, T_INT)) {
JVMCI_ERROR_0("expected Integer id, got %s", id_obj->klass()->signature_name());
}
jint id = id_obj->int_field(java_lang_boxing_object::value_offset_in_bytes(T_INT));
if (id == INVOKESTATIC || id == INVOKESPECIAL) {
static_call_stubs++;
@ -559,7 +625,7 @@ int CodeInstaller::estimate_stubs_size() {
}
// perform data and call relocation on the CodeBuffer
JVMCIEnv::CodeInstallResult CodeInstaller::initialize_buffer(CodeBuffer& buffer) {
JVMCIEnv::CodeInstallResult CodeInstaller::initialize_buffer(CodeBuffer& buffer, TRAPS) {
HandleMark hm;
objArrayHandle sites = this->sites();
int locs_buffer_size = sites->length() * (relocInfo::length_limit + sizeof(relocInfo));
@ -568,7 +634,7 @@ JVMCIEnv::CodeInstallResult CodeInstaller::initialize_buffer(CodeBuffer& buffer)
// stubs. Stubs have extra relocs but they are managed by the stub
// section itself so they don't need to be accounted for in the
// locs_buffer above.
int stubs_size = estimate_stubs_size();
int stubs_size = estimate_stubs_size(CHECK_OK);
int total_size = round_to(_code_size, buffer.insts()->alignment()) + round_to(_constants_size, buffer.consts()->alignment()) + round_to(stubs_size, buffer.stubs()->alignment());
if (total_size > JVMCINMethodSizeLimit) {
@ -600,19 +666,30 @@ JVMCIEnv::CodeInstallResult CodeInstaller::initialize_buffer(CodeBuffer& buffer)
for (int i = 0; i < data_section_patches()->length(); i++) {
Handle patch = data_section_patches()->obj_at(i);
if (patch.is_null()) {
THROW_(vmSymbols::java_lang_NullPointerException(), JVMCIEnv::ok);
}
Handle reference = CompilationResult_DataPatch::reference(patch);
assert(reference->is_a(CompilationResult_ConstantReference::klass()), "patch in data section must be a ConstantReference");
if (reference.is_null()) {
THROW_(vmSymbols::java_lang_NullPointerException(), JVMCIEnv::ok);
}
if (!reference->is_a(CompilationResult_ConstantReference::klass())) {
JVMCI_ERROR_OK("invalid patch in data section: %s", reference->klass()->signature_name());
}
Handle constant = CompilationResult_ConstantReference::constant(reference);
if (constant.is_null()) {
THROW_(vmSymbols::java_lang_NullPointerException(), JVMCIEnv::ok);
}
address dest = _constants->start() + CompilationResult_Site::pcOffset(patch);
if (constant->is_a(HotSpotMetaspaceConstantImpl::klass())) {
if (HotSpotMetaspaceConstantImpl::compressed(constant)) {
#ifdef _LP64
*((narrowKlass*) dest) = record_narrow_metadata_reference(constant);
*((narrowKlass*) dest) = record_narrow_metadata_reference(constant, CHECK_OK);
#else
fatal("unexpected compressed Klass* in 32-bit mode");
JVMCI_ERROR_OK("unexpected compressed Klass* in 32-bit mode");
#endif
} else {
*((Metadata**) dest) = record_metadata_reference(constant);
*((Metadata**) dest) = record_metadata_reference(constant, CHECK_OK);
}
} else if (constant->is_a(HotSpotObjectConstantImpl::klass())) {
Handle obj = HotSpotObjectConstantImpl::object(constant);
@ -623,48 +700,49 @@ JVMCIEnv::CodeInstallResult CodeInstaller::initialize_buffer(CodeBuffer& buffer)
#ifdef _LP64
_constants->relocate(dest, oop_Relocation::spec(oop_index), relocInfo::narrow_oop_in_const);
#else
fatal("unexpected compressed oop in 32-bit mode");
JVMCI_ERROR_OK("unexpected compressed oop in 32-bit mode");
#endif
} else {
_constants->relocate(dest, oop_Relocation::spec(oop_index));
}
} else {
ShouldNotReachHere();
JVMCI_ERROR_OK("invalid constant in data section: %s", constant->klass()->signature_name());
}
}
jint last_pc_offset = -1;
for (int i = 0; i < sites->length(); i++) {
{
No_Safepoint_Verifier no_safepoint;
oop site = sites->obj_at(i);
jint pc_offset = CompilationResult_Site::pcOffset(site);
if (site->is_a(CompilationResult_Call::klass())) {
TRACE_jvmci_4("call at %i", pc_offset);
site_Call(buffer, pc_offset, site);
} else if (site->is_a(CompilationResult_Infopoint::klass())) {
// three reasons for infopoints denote actual safepoints
oop reason = CompilationResult_Infopoint::reason(site);
if (InfopointReason::SAFEPOINT() == reason || InfopointReason::CALL() == reason || InfopointReason::IMPLICIT_EXCEPTION() == reason) {
TRACE_jvmci_4("safepoint at %i", pc_offset);
site_Safepoint(buffer, pc_offset, site);
} else {
// if the infopoint is not an actual safepoint, it must have one of the other reasons
// (safeguard against new safepoint types that require handling above)
assert(InfopointReason::METHOD_START() == reason || InfopointReason::METHOD_END() == reason || InfopointReason::LINE_NUMBER() == reason, "");
site_Infopoint(buffer, pc_offset, site);
}
} else if (site->is_a(CompilationResult_DataPatch::klass())) {
TRACE_jvmci_4("datapatch at %i", pc_offset);
site_DataPatch(buffer, pc_offset, site);
} else if (site->is_a(CompilationResult_Mark::klass())) {
TRACE_jvmci_4("mark at %i", pc_offset);
site_Mark(buffer, pc_offset, site);
} else {
fatal("unexpected Site subclass");
}
last_pc_offset = pc_offset;
Handle site = sites->obj_at(i);
if (site.is_null()) {
THROW_(vmSymbols::java_lang_NullPointerException(), JVMCIEnv::ok);
}
jint pc_offset = CompilationResult_Site::pcOffset(site);
if (site->is_a(CompilationResult_Call::klass())) {
TRACE_jvmci_4("call at %i", pc_offset);
site_Call(buffer, pc_offset, site, CHECK_OK);
} else if (site->is_a(CompilationResult_Infopoint::klass())) {
// three reasons for infopoints denote actual safepoints
oop reason = CompilationResult_Infopoint::reason(site);
if (InfopointReason::SAFEPOINT() == reason || InfopointReason::CALL() == reason || InfopointReason::IMPLICIT_EXCEPTION() == reason) {
TRACE_jvmci_4("safepoint at %i", pc_offset);
site_Safepoint(buffer, pc_offset, site, CHECK_OK);
} else if (InfopointReason::METHOD_START() == reason || InfopointReason::METHOD_END() == reason || InfopointReason::LINE_NUMBER() == reason) {
site_Infopoint(buffer, pc_offset, site, CHECK_OK);
} else {
JVMCI_ERROR_OK("unknown infopoint reason at %i", pc_offset);
}
} else if (site->is_a(CompilationResult_DataPatch::klass())) {
TRACE_jvmci_4("datapatch at %i", pc_offset);
site_DataPatch(buffer, pc_offset, site, CHECK_OK);
} else if (site->is_a(CompilationResult_Mark::klass())) {
TRACE_jvmci_4("mark at %i", pc_offset);
site_Mark(buffer, pc_offset, site, CHECK_OK);
} else {
JVMCI_ERROR_OK("unexpected site subclass: %s", site->klass()->signature_name());
}
last_pc_offset = pc_offset;
if (CodeInstallSafepointChecks && SafepointSynchronize::do_call_back()) {
// this is a hacky way to force a safepoint check but nothing else was jumping out at me.
ThreadToNativeFromVM ttnfv(JavaThread::current());
@ -673,7 +751,6 @@ JVMCIEnv::CodeInstallResult CodeInstaller::initialize_buffer(CodeBuffer& buffer)
#ifndef PRODUCT
if (comments() != NULL) {
No_Safepoint_Verifier no_safepoint;
for (int i = 0; i < comments()->length(); i++) {
oop comment = comments()->obj_at(i);
assert(comment->is_a(HotSpotCompiledCode_Comment::klass()), "cce");
@ -759,56 +836,61 @@ static bool bytecode_should_reexecute(Bytecodes::Code code) {
return true;
}
GrowableArray<ScopeValue*>* CodeInstaller::record_virtual_objects(oop debug_info) {
objArrayOop virtualObjects = DebugInfo::virtualObjectMapping(debug_info);
if (virtualObjects == NULL) {
GrowableArray<ScopeValue*>* CodeInstaller::record_virtual_objects(Handle debug_info, TRAPS) {
objArrayHandle virtualObjects = DebugInfo::virtualObjectMapping(debug_info);
if (virtualObjects.is_null()) {
return NULL;
}
GrowableArray<ScopeValue*>* objects = new GrowableArray<ScopeValue*>(virtualObjects->length(), virtualObjects->length(), NULL);
// Create the unique ObjectValues
for (int i = 0; i < virtualObjects->length(); i++) {
oop value = virtualObjects->obj_at(i);
Handle value = virtualObjects->obj_at(i);
int id = VirtualObject::id(value);
oop type = VirtualObject::type(value);
Handle type = VirtualObject::type(value);
oop javaMirror = HotSpotResolvedObjectTypeImpl::javaClass(type);
ObjectValue* sv = new ObjectValue(id, new ConstantOopWriteValue(JNIHandles::make_local(Thread::current(), javaMirror)));
assert(objects->at(id) == NULL, "once");
if (id < 0 || id >= objects->length()) {
JVMCI_ERROR_NULL("virtual object id %d out of bounds", id);
}
if (objects->at(id) != NULL) {
JVMCI_ERROR_NULL("duplicate virtual object id %d", id);
}
objects->at_put(id, sv);
}
// All the values which could be referenced by the VirtualObjects
// exist, so now describe all the VirtualObjects themselves.
for (int i = 0; i < virtualObjects->length(); i++) {
oop value = virtualObjects->obj_at(i);
Handle value = virtualObjects->obj_at(i);
int id = VirtualObject::id(value);
record_object_value(objects->at(id)->as_ObjectValue(), value, objects);
record_object_value(objects->at(id)->as_ObjectValue(), value, objects, CHECK_NULL);
}
_debug_recorder->dump_object_pool(objects);
return objects;
}
void CodeInstaller::record_scope(jint pc_offset, oop debug_info) {
oop position = DebugInfo::bytecodePosition(debug_info);
if (position == NULL) {
void CodeInstaller::record_scope(jint pc_offset, Handle debug_info, TRAPS) {
Handle position = DebugInfo::bytecodePosition(debug_info);
if (position.is_null()) {
// Stubs do not record scope info, just oop maps
return;
}
GrowableArray<ScopeValue*>* objectMapping = record_virtual_objects(debug_info);
record_scope(pc_offset, position, objectMapping);
GrowableArray<ScopeValue*>* objectMapping = record_virtual_objects(debug_info, CHECK);
record_scope(pc_offset, position, objectMapping, CHECK);
}
void CodeInstaller::record_scope(jint pc_offset, oop position, GrowableArray<ScopeValue*>* objects) {
oop frame = NULL;
void CodeInstaller::record_scope(jint pc_offset, Handle position, GrowableArray<ScopeValue*>* objects, TRAPS) {
Handle frame;
if (position->is_a(BytecodeFrame::klass())) {
frame = position;
}
oop caller_frame = BytecodePosition::caller(position);
if (caller_frame != NULL) {
record_scope(pc_offset, caller_frame, objects);
Handle caller_frame = BytecodePosition::caller(position);
if (caller_frame.not_null()) {
record_scope(pc_offset, caller_frame, objects, CHECK);
}
oop hotspot_method = BytecodePosition::method(position);
Method* method = getMethodFromHotSpotMethod(hotspot_method);
Handle hotspot_method = BytecodePosition::method(position);
Method* method = getMethodFromHotSpotMethod(hotspot_method());
jint bci = BytecodePosition::bci(position);
if (bci == BytecodeFrame::BEFORE_BCI()) {
bci = SynchronizationEntryBCI;
@ -817,13 +899,13 @@ void CodeInstaller::record_scope(jint pc_offset, oop position, GrowableArray<Sco
TRACE_jvmci_2("Recording scope pc_offset=%d bci=%d method=%s", pc_offset, bci, method->name_and_sig_as_C_string());
bool reexecute = false;
if (frame != NULL) {
if (frame.not_null()) {
if (bci == SynchronizationEntryBCI){
reexecute = false;
} else {
Bytecodes::Code code = Bytecodes::java_code_at(method, method->bcp_from(bci));
reexecute = bytecode_should_reexecute(code);
if (frame != NULL) {
if (frame.not_null()) {
reexecute = (BytecodeFrame::duringCall(frame) == JNI_FALSE);
}
}
@ -834,15 +916,22 @@ void CodeInstaller::record_scope(jint pc_offset, oop position, GrowableArray<Sco
DebugToken* monitors_token = NULL;
bool throw_exception = false;
if (frame != NULL) {
if (frame.not_null()) {
jint local_count = BytecodeFrame::numLocals(frame);
jint expression_count = BytecodeFrame::numStack(frame);
jint monitor_count = BytecodeFrame::numLocks(frame);
objArrayOop values = BytecodeFrame::values(frame);
objArrayOop slotKinds = BytecodeFrame::slotKinds(frame);
objArrayHandle values = BytecodeFrame::values(frame);
objArrayHandle slotKinds = BytecodeFrame::slotKinds(frame);
assert(local_count + expression_count + monitor_count == values->length(), "unexpected values length");
assert(local_count + expression_count == slotKinds->length(), "unexpected slotKinds length");
if (values.is_null() || slotKinds.is_null()) {
THROW(vmSymbols::java_lang_NullPointerException());
}
if (local_count + expression_count + monitor_count != values->length()) {
JVMCI_ERROR("unexpected values length %d in scope (%d locals, %d expressions, %d monitors)", values->length(), local_count, expression_count, monitor_count);
}
if (local_count + expression_count != slotKinds->length()) {
JVMCI_ERROR("unexpected slotKinds length %d in scope (%d locals, %d expressions)", slotKinds->length(), local_count, expression_count);
}
GrowableArray<ScopeValue*>* locals = local_count > 0 ? new GrowableArray<ScopeValue*> (local_count) : NULL;
GrowableArray<ScopeValue*>* expressions = expression_count > 0 ? new GrowableArray<ScopeValue*> (expression_count) : NULL;
@ -853,30 +942,30 @@ void CodeInstaller::record_scope(jint pc_offset, oop position, GrowableArray<Sco
for (jint i = 0; i < values->length(); i++) {
ScopeValue* second = NULL;
oop value = values->obj_at(i);
Handle value = values->obj_at(i);
if (i < local_count) {
oop kind = slotKinds->obj_at(i);
BasicType type = JVMCIRuntime::kindToBasicType(JavaKind::typeChar(kind));
ScopeValue* first = get_scope_value(value, type, objects, second);
BasicType type = JVMCIRuntime::kindToBasicType(slotKinds->obj_at(i), CHECK);
ScopeValue* first = get_scope_value(value, type, objects, second, CHECK);
if (second != NULL) {
locals->append(second);
}
locals->append(first);
} else if (i < local_count + expression_count) {
oop kind = slotKinds->obj_at(i);
BasicType type = JVMCIRuntime::kindToBasicType(JavaKind::typeChar(kind));
ScopeValue* first = get_scope_value(value, type, objects, second);
BasicType type = JVMCIRuntime::kindToBasicType(slotKinds->obj_at(i), CHECK);
ScopeValue* first = get_scope_value(value, type, objects, second, CHECK);
if (second != NULL) {
expressions->append(second);
}
expressions->append(first);
} else {
monitors->append(get_monitor_value(value, objects));
MonitorValue *monitor = get_monitor_value(value, objects, CHECK);
monitors->append(monitor);
}
if (second != NULL) {
i++;
assert(i < values->length(), "double-slot value not followed by Value.ILLEGAL");
assert(values->obj_at(i) == Value::ILLEGAL(), "double-slot value not followed by Value.ILLEGAL");
if (i >= values->length() || values->obj_at(i) != Value::ILLEGAL()) {
JVMCI_ERROR("double-slot value not followed by Value.ILLEGAL");
}
}
}
@ -891,32 +980,37 @@ void CodeInstaller::record_scope(jint pc_offset, oop position, GrowableArray<Sco
locals_token, expressions_token, monitors_token);
}
void CodeInstaller::site_Safepoint(CodeBuffer& buffer, jint pc_offset, oop site) {
oop debug_info = CompilationResult_Infopoint::debugInfo(site);
assert(debug_info != NULL, "debug info expected");
void CodeInstaller::site_Safepoint(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS) {
Handle debug_info = CompilationResult_Infopoint::debugInfo(site);
if (debug_info.is_null()) {
JVMCI_ERROR("debug info expected at safepoint at %i", pc_offset);
}
// address instruction = _instructions->start() + pc_offset;
// jint next_pc_offset = Assembler::locate_next_instruction(instruction) - _instructions->start();
_debug_recorder->add_safepoint(pc_offset, create_oop_map(debug_info));
record_scope(pc_offset, debug_info);
OopMap *map = create_oop_map(debug_info, CHECK);
_debug_recorder->add_safepoint(pc_offset, map);
record_scope(pc_offset, debug_info, CHECK);
_debug_recorder->end_safepoint(pc_offset);
}
void CodeInstaller::site_Infopoint(CodeBuffer& buffer, jint pc_offset, oop site) {
oop debug_info = CompilationResult_Infopoint::debugInfo(site);
assert(debug_info != NULL, "debug info expected");
void CodeInstaller::site_Infopoint(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS) {
Handle debug_info = CompilationResult_Infopoint::debugInfo(site);
if (debug_info.is_null()) {
JVMCI_ERROR("debug info expected at infopoint at %i", pc_offset);
}
_debug_recorder->add_non_safepoint(pc_offset);
record_scope(pc_offset, debug_info);
record_scope(pc_offset, debug_info, CHECK);
_debug_recorder->end_non_safepoint(pc_offset);
}
void CodeInstaller::site_Call(CodeBuffer& buffer, jint pc_offset, oop site) {
oop target = CompilationResult_Call::target(site);
void CodeInstaller::site_Call(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS) {
Handle target = CompilationResult_Call::target(site);
InstanceKlass* target_klass = InstanceKlass::cast(target->klass());
oop hotspot_method = NULL; // JavaMethod
oop foreign_call = NULL;
Handle hotspot_method; // JavaMethod
Handle foreign_call;
if (target_klass->is_subclass_of(SystemDictionary::HotSpotForeignCallTarget_klass())) {
foreign_call = target;
@ -924,27 +1018,29 @@ void CodeInstaller::site_Call(CodeBuffer& buffer, jint pc_offset, oop site) {
hotspot_method = target;
}
oop debug_info = CompilationResult_Call::debugInfo(site);
Handle debug_info = CompilationResult_Call::debugInfo(site);
assert(!!hotspot_method ^ !!foreign_call, "Call site needs exactly one type");
assert(hotspot_method.not_null() ^ foreign_call.not_null(), "Call site needs exactly one type");
NativeInstruction* inst = nativeInstruction_at(_instructions->start() + pc_offset);
jint next_pc_offset = CodeInstaller::pd_next_offset(inst, pc_offset, hotspot_method);
jint next_pc_offset = CodeInstaller::pd_next_offset(inst, pc_offset, hotspot_method, CHECK);
if (debug_info != NULL) {
_debug_recorder->add_safepoint(next_pc_offset, create_oop_map(debug_info));
record_scope(next_pc_offset, debug_info);
if (debug_info.not_null()) {
OopMap *map = create_oop_map(debug_info, CHECK);
_debug_recorder->add_safepoint(next_pc_offset, map);
record_scope(next_pc_offset, debug_info, CHECK);
}
if (foreign_call != NULL) {
if (foreign_call.not_null()) {
jlong foreign_call_destination = HotSpotForeignCallTarget::address(foreign_call);
CodeInstaller::pd_relocate_ForeignCall(inst, foreign_call_destination);
CodeInstaller::pd_relocate_ForeignCall(inst, foreign_call_destination, CHECK);
} else { // method != NULL
assert(hotspot_method != NULL, "unexpected JavaMethod");
assert(debug_info != NULL, "debug info expected");
if (debug_info.is_null()) {
JVMCI_ERROR("debug info expected at call at %i", pc_offset);
}
TRACE_jvmci_3("method call");
CodeInstaller::pd_relocate_JavaMethod(hotspot_method, pc_offset);
CodeInstaller::pd_relocate_JavaMethod(hotspot_method, pc_offset, CHECK);
if (_next_call_type == INVOKESTATIC || _next_call_type == INVOKESPECIAL) {
// Need a static call stub for transitions from compiled to interpreted.
CompiledStaticCall::emit_to_interp_stub(buffer, _instructions->start() + pc_offset);
@ -953,38 +1049,45 @@ void CodeInstaller::site_Call(CodeBuffer& buffer, jint pc_offset, oop site) {
_next_call_type = INVOKE_INVALID;
if (debug_info != NULL) {
if (debug_info.not_null()) {
_debug_recorder->end_safepoint(next_pc_offset);
}
}
void CodeInstaller::site_DataPatch(CodeBuffer& buffer, jint pc_offset, oop site) {
oop reference = CompilationResult_DataPatch::reference(site);
if (reference->is_a(CompilationResult_ConstantReference::klass())) {
void CodeInstaller::site_DataPatch(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS) {
Handle reference = CompilationResult_DataPatch::reference(site);
if (reference.is_null()) {
THROW(vmSymbols::java_lang_NullPointerException());
} else if (reference->is_a(CompilationResult_ConstantReference::klass())) {
Handle constant = CompilationResult_ConstantReference::constant(reference);
if (constant->is_a(HotSpotObjectConstantImpl::klass())) {
pd_patch_OopConstant(pc_offset, constant);
if (constant.is_null()) {
THROW(vmSymbols::java_lang_NullPointerException());
} else if (constant->is_a(HotSpotObjectConstantImpl::klass())) {
pd_patch_OopConstant(pc_offset, constant, CHECK);
} else if (constant->is_a(HotSpotMetaspaceConstantImpl::klass())) {
pd_patch_MetaspaceConstant(pc_offset, constant);
} else if (constant->is_a(HotSpotSentinelConstant::klass())) {
fatal("sentinel constant unsupported");
pd_patch_MetaspaceConstant(pc_offset, constant, CHECK);
} else {
fatal("unknown constant type in data patch");
JVMCI_ERROR("unknown constant type in data patch: %s", constant->klass()->signature_name());
}
} else if (reference->is_a(CompilationResult_DataSectionReference::klass())) {
int data_offset = CompilationResult_DataSectionReference::offset(reference);
assert(0 <= data_offset && data_offset < _constants_size, "data offset 0x%X points outside data section (size 0x%X)", data_offset, _constants_size);
pd_patch_DataSectionReference(pc_offset, data_offset);
if (0 <= data_offset && data_offset < _constants_size) {
pd_patch_DataSectionReference(pc_offset, data_offset);
} else {
JVMCI_ERROR("data offset 0x%X points outside data section (size 0x%X)", data_offset, _constants_size);
}
} else {
fatal("unknown data patch type");
JVMCI_ERROR("unknown data patch type: %s", reference->klass()->signature_name());
}
}
void CodeInstaller::site_Mark(CodeBuffer& buffer, jint pc_offset, oop site) {
oop id_obj = CompilationResult_Mark::id(site);
void CodeInstaller::site_Mark(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS) {
Handle id_obj = CompilationResult_Mark::id(site);
if (id_obj != NULL) {
assert(java_lang_boxing_object::is_instance(id_obj, T_INT), "Integer id expected");
if (id_obj.not_null()) {
if (!java_lang_boxing_object::is_instance(id_obj(), T_INT)) {
JVMCI_ERROR("expected Integer id, got %s", id_obj->klass()->signature_name());
}
jint id = id_obj->int_field(java_lang_boxing_object::value_offset_in_bytes(T_INT));
address pc = _instructions->start() + pc_offset;
@ -1017,7 +1120,7 @@ void CodeInstaller::site_Mark(CodeBuffer& buffer, jint pc_offset, oop site) {
case POLL_FAR:
case POLL_RETURN_NEAR:
case POLL_RETURN_FAR:
pd_relocate_poll(pc, id);
pd_relocate_poll(pc, id, CHECK);
break;
case CARD_TABLE_SHIFT:
case CARD_TABLE_ADDRESS:
@ -1027,7 +1130,7 @@ void CodeInstaller::site_Mark(CodeBuffer& buffer, jint pc_offset, oop site) {
case CRC_TABLE_ADDRESS:
break;
default:
ShouldNotReachHere();
JVMCI_ERROR("invalid mark id: %d", id);
break;
}
}

56
hotspot/src/share/vm/jvmci/jvmciCodeInstaller.hpp
View File

@ -154,13 +154,13 @@ private:
static ConstantIntValue* _int_2_scope_value;
static LocationValue* _illegal_value;
jint pd_next_offset(NativeInstruction* inst, jint pc_offset, oop method);
void pd_patch_OopConstant(int pc_offset, Handle& constant);
void pd_patch_MetaspaceConstant(int pc_offset, Handle& constant);
jint pd_next_offset(NativeInstruction* inst, jint pc_offset, Handle method, TRAPS);
void pd_patch_OopConstant(int pc_offset, Handle constant, TRAPS);
void pd_patch_MetaspaceConstant(int pc_offset, Handle constant, TRAPS);
void pd_patch_DataSectionReference(int pc_offset, int data_offset);
void pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination);
void pd_relocate_JavaMethod(oop method, jint pc_offset);
void pd_relocate_poll(address pc, jint mark);
void pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination, TRAPS);
void pd_relocate_JavaMethod(Handle method, jint pc_offset, TRAPS);
void pd_relocate_poll(address pc, jint mark, TRAPS);
objArrayOop sites() { return (objArrayOop) JNIHandles::resolve(_sites_handle); }
arrayOop code() { return (arrayOop) JNIHandles::resolve(_code_handle); }
@ -177,33 +177,33 @@ public:
CodeInstaller() : _arena(mtCompiler) {}
JVMCIEnv::CodeInstallResult gather_metadata(Handle target, Handle& compiled_code, CodeMetadata& metadata);
JVMCIEnv::CodeInstallResult install(JVMCICompiler* compiler, Handle target, Handle& compiled_code, CodeBlob*& cb, Handle installed_code, Handle speculation_log);
JVMCIEnv::CodeInstallResult gather_metadata(Handle target, Handle& compiled_code, CodeMetadata& metadata, TRAPS);
JVMCIEnv::CodeInstallResult install(JVMCICompiler* compiler, Handle target, Handle& compiled_code, CodeBlob*& cb, Handle installed_code, Handle speculation_log, TRAPS);
static address runtime_call_target_address(oop runtime_call);
static VMReg get_hotspot_reg(jint jvmciRegisterNumber);
static VMReg get_hotspot_reg(jint jvmciRegisterNumber, TRAPS);
static bool is_general_purpose_reg(VMReg hotspotRegister);
const OopMapSet* oopMapSet() const { return _debug_recorder->_oopmaps; }
protected:
Location::Type get_oop_type(oop value);
ScopeValue* get_scope_value(oop value, BasicType type, GrowableArray<ScopeValue*>* objects, ScopeValue* &second);
MonitorValue* get_monitor_value(oop value, GrowableArray<ScopeValue*>* objects);
Location::Type get_oop_type(Handle value);
ScopeValue* get_scope_value(Handle value, BasicType type, GrowableArray<ScopeValue*>* objects, ScopeValue* &second, TRAPS);
MonitorValue* get_monitor_value(Handle value, GrowableArray<ScopeValue*>* objects, TRAPS);
Metadata* record_metadata_reference(Handle& constant);
Metadata* record_metadata_reference(Handle constant, TRAPS);
#ifdef _LP64
narrowKlass record_narrow_metadata_reference(Handle& constant);
narrowKlass record_narrow_metadata_reference(Handle constant, TRAPS);
#endif
// extract the fields of the CompilationResult
void initialize_fields(oop target, oop target_method);
void initialize_dependencies(oop target_method, OopRecorder* oop_recorder);
void initialize_fields(oop target, oop target_method, TRAPS);
void initialize_dependencies(oop target_method, OopRecorder* oop_recorder, TRAPS);
int estimate_stubs_size();
int estimate_stubs_size(TRAPS);
// perform data and call relocation on the CodeBuffer
JVMCIEnv::CodeInstallResult initialize_buffer(CodeBuffer& buffer);
JVMCIEnv::CodeInstallResult initialize_buffer(CodeBuffer& buffer, TRAPS);
void assumption_NoFinalizableSubclass(Handle assumption);
void assumption_ConcreteSubtype(Handle assumption);
@ -211,19 +211,19 @@ protected:
void assumption_ConcreteMethod(Handle assumption);
void assumption_CallSiteTargetValue(Handle assumption);
void site_Safepoint(CodeBuffer& buffer, jint pc_offset, oop site);
void site_Infopoint(CodeBuffer& buffer, jint pc_offset, oop site);
void site_Call(CodeBuffer& buffer, jint pc_offset, oop site);
void site_DataPatch(CodeBuffer& buffer, jint pc_offset, oop site);
void site_Mark(CodeBuffer& buffer, jint pc_offset, oop site);
void site_Safepoint(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS);
void site_Infopoint(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS);
void site_Call(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS);
void site_DataPatch(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS);
void site_Mark(CodeBuffer& buffer, jint pc_offset, Handle site, TRAPS);
OopMap* create_oop_map(oop debug_info);
OopMap* create_oop_map(Handle debug_info, TRAPS);
void record_scope(jint pc_offset, oop debug_info);
void record_scope(jint pc_offset, oop code_pos, GrowableArray<ScopeValue*>* objects);
void record_object_value(ObjectValue* sv, oop value, GrowableArray<ScopeValue*>* objects);
void record_scope(jint pc_offset, Handle debug_info, TRAPS);
void record_scope(jint pc_offset, Handle code_pos, GrowableArray<ScopeValue*>* objects, TRAPS);
void record_object_value(ObjectValue* sv, Handle value, GrowableArray<ScopeValue*>* objects, TRAPS);
GrowableArray<ScopeValue*>* record_virtual_objects(oop debug_info);
GrowableArray<ScopeValue*>* record_virtual_objects(Handle debug_info, TRAPS);
void process_exception_handlers();
int estimateStubSpace(int static_call_stubs);

4
hotspot/src/share/vm/jvmci/jvmciCompilerToVM.cpp
View File

@ -670,7 +670,7 @@ C2V_VMENTRY(jint, installCode, (JNIEnv *jniEnv, jobject, jobject target, jobject
TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer());
CodeInstaller installer;
JVMCIEnv::CodeInstallResult result = installer.install(compiler, target_handle, compiled_code_handle, cb, installed_code_handle, speculation_log_handle);
JVMCIEnv::CodeInstallResult result = installer.install(compiler, target_handle, compiled_code_handle, cb, installed_code_handle, speculation_log_handle, CHECK_0);
if (PrintCodeCacheOnCompilation) {
stringStream s;
@ -726,7 +726,7 @@ C2V_VMENTRY(jint, getMetadata, (JNIEnv *jniEnv, jobject, jobject target, jobject
CodeBlob *cb = NULL;
CodeInstaller installer;
JVMCIEnv::CodeInstallResult result = installer.gather_metadata(target_handle, compiled_code_handle, code_metadata); //cb, pc_descs, nr_pc_descs, scopes_descs, scopes_size, reloc_buffer);
JVMCIEnv::CodeInstallResult result = installer.gather_metadata(target_handle, compiled_code_handle, code_metadata, CHECK_0); //cb, pc_descs, nr_pc_descs, scopes_descs, scopes_size, reloc_buffer);
if (result != JVMCIEnv::ok) {
return result;
}

10
hotspot/src/share/vm/jvmci/jvmciRuntime.cpp
View File

@ -59,7 +59,11 @@ bool JVMCIRuntime::_shutdown_called = false;
static const char* OPTION_PREFIX = "jvmci.option.";
static const size_t OPTION_PREFIX_LEN = strlen(OPTION_PREFIX);
BasicType JVMCIRuntime::kindToBasicType(jchar ch) {
BasicType JVMCIRuntime::kindToBasicType(Handle kind, TRAPS) {
if (kind.is_null()) {
THROW_(vmSymbols::java_lang_NullPointerException(), T_ILLEGAL);
}
jchar ch = JavaKind::typeChar(kind);
switch(ch) {
case 'z': return T_BOOLEAN;
case 'b': return T_BYTE;
@ -72,10 +76,8 @@ BasicType JVMCIRuntime::kindToBasicType(jchar ch) {
case 'a': return T_OBJECT;
case '-': return T_ILLEGAL;
default:
fatal("unexpected Kind: %c", ch);
break;
JVMCI_ERROR_(T_ILLEGAL, "unexpected Kind: %c", ch);
}
return T_ILLEGAL;
}
// Simple helper to see if the caller of a runtime stub which

13
hotspot/src/share/vm/jvmci/jvmciRuntime.hpp
View File

@ -29,6 +29,17 @@
#include "runtime/arguments.hpp"
#include "runtime/deoptimization.hpp"
#define JVMCI_ERROR(...) \
{ Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::jdk_vm_ci_common_JVMCIError(), __VA_ARGS__); return; }
#define JVMCI_ERROR_(ret, ...) \
{ Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::jdk_vm_ci_common_JVMCIError(), __VA_ARGS__); return ret; }
#define JVMCI_ERROR_0(...) JVMCI_ERROR_(0, __VA_ARGS__)
#define JVMCI_ERROR_NULL(...) JVMCI_ERROR_(NULL, __VA_ARGS__)
#define JVMCI_ERROR_OK(...) JVMCI_ERROR_(JVMCIEnv::ok, __VA_ARGS__)
#define CHECK_OK CHECK_(JVMCIEnv::ok)
class ParseClosure : public StackObj {
int _lineNo;
char* _filename;
@ -171,7 +182,7 @@ class JVMCIRuntime: public AllStatic {
} \
(void)(0
static BasicType kindToBasicType(jchar ch);
static BasicType kindToBasicType(Handle kind, TRAPS);
// The following routines are all called from compiled JVMCI code

1
hotspot/src/share/vm/jvmci/vmSymbols_jvmci.hpp
View File

@ -86,6 +86,7 @@
template(jdk_vm_ci_code_VirtualObject, "jdk/vm/ci/code/VirtualObject") \
template(jdk_vm_ci_code_RegisterSaveLayout, "jdk/vm/ci/code/RegisterSaveLayout") \
template(jdk_vm_ci_code_InvalidInstalledCodeException, "jdk/vm/ci/code/InvalidInstalledCodeException") \
template(jdk_vm_ci_common_JVMCIError, "jdk/vm/ci/common/JVMCIError") \
template(compileMethod_name, "compileMethod") \
template(compileMethod_signature, "(Ljdk/vm/ci/hotspot/HotSpotResolvedJavaMethod;IJI)V") \
template(fromMetaspace_name, "fromMetaspace") \

85
hotspot/test/compiler/jvmci/errors/CodeInstallerTest.java Normal file
View File

@ -0,0 +1,85 @@
/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package compiler.jvmci.errors;
import java.lang.reflect.Method;
import jdk.vm.ci.code.Architecture;
import jdk.vm.ci.code.CodeCacheProvider;
import jdk.vm.ci.code.CompilationResult;
import jdk.vm.ci.code.Register;
import jdk.vm.ci.meta.MetaAccessProvider;
import jdk.vm.ci.meta.PlatformKind;
import jdk.vm.ci.meta.ResolvedJavaMethod;
import jdk.vm.ci.hotspot.HotSpotConstantReflectionProvider;
import jdk.vm.ci.runtime.JVMCI;
import jdk.vm.ci.runtime.JVMCIBackend;
import org.junit.Assert;
public class CodeInstallerTest {
protected final Architecture arch;
protected final CodeCacheProvider codeCache;
protected final MetaAccessProvider metaAccess;
protected final HotSpotConstantReflectionProvider constantReflection;
protected final ResolvedJavaMethod dummyMethod;
public static void dummyMethod() {
}
protected CodeInstallerTest() {
JVMCIBackend backend = JVMCI.getRuntime().getHostJVMCIBackend();
metaAccess = backend.getMetaAccess();
codeCache = backend.getCodeCache();
constantReflection = (HotSpotConstantReflectionProvider) backend.getConstantReflection();
arch = codeCache.getTarget().arch;
Method method = null;
try {
method = CodeInstallerTest.class.getMethod("dummyMethod");
} catch (NoSuchMethodException e) {
Assert.fail();
}
dummyMethod = metaAccess.lookupJavaMethod(method);
}
protected void installCode(CompilationResult result) {
codeCache.addCode(dummyMethod, result, null, null);
}
protected Register getRegister(PlatformKind kind, int index) {
Register[] allRegs = arch.getAvailableValueRegisters();
for (int i = 0; i < allRegs.length; i++) {
if (arch.canStoreValue(allRegs[i].getRegisterCategory(), kind)) {
if (index-- == 0) {
return allRegs[i];
}
}
}
return null;
}
}

241
hotspot/test/compiler/jvmci/errors/TestInvalidCompilationResult.java Normal file
View File

@ -0,0 +1,241 @@
/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* @test
* @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9") & os.arch != "aarch64"
* @compile CodeInstallerTest.java
* @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI compiler.jvmci.errors.TestInvalidCompilationResult
*/
package compiler.jvmci.errors;
import static jdk.vm.ci.code.CompilationResult.ConstantReference;
import static jdk.vm.ci.code.CompilationResult.DataPatch;
import static jdk.vm.ci.code.CompilationResult.DataSectionReference;
import static jdk.vm.ci.code.CompilationResult.Infopoint;
import static jdk.vm.ci.code.CompilationResult.Reference;
import static jdk.vm.ci.code.DataSection.Data;
import static jdk.vm.ci.code.DataSection.DataBuilder;
import static jdk.vm.ci.meta.Assumptions.Assumption;
import jdk.vm.ci.code.CompilationResult;
import jdk.vm.ci.code.InfopointReason;
import jdk.vm.ci.common.JVMCIError;
import jdk.vm.ci.hotspot.HotSpotConstant;
import jdk.vm.ci.meta.ResolvedJavaType;
import jdk.vm.ci.meta.VMConstant;
import org.junit.Test;
/**
* Tests for errors in the code installer.
*/
public class TestInvalidCompilationResult extends CodeInstallerTest {
private static class InvalidAssumption extends Assumption {
}
private static class InvalidVMConstant implements VMConstant {
public boolean isDefaultForKind() {
return false;
}
public String toValueString() {
return null;
}
}
private static class InvalidReference extends Reference {
@Override
public int hashCode() {
return 0;
}
@Override
public boolean equals(Object obj) {
return false;
}
}
@Test(expected = JVMCIError.class)
public void testInvalidAssumption() {
CompilationResult result = new CompilationResult();
result.setAssumptions(new Assumption[]{new InvalidAssumption()});
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testInvalidAlignment() {
CompilationResult result = new CompilationResult();
result.getDataSection().insertData(new Data(7, 1, DataBuilder.zero(1)));
installCode(result);
}
@Test(expected = NullPointerException.class)
public void testNullDataPatchInDataSection() {
CompilationResult result = new CompilationResult();
Data data = new Data(1, 1, (buffer, patch) -> {
patch.accept(null);
buffer.put((byte) 0);
});
result.getDataSection().insertData(data);
installCode(result);
}
@Test(expected = NullPointerException.class)
public void testNullReferenceInDataSection() {
CompilationResult result = new CompilationResult();
Data data = new Data(1, 1, (buffer, patch) -> {
patch.accept(new DataPatch(buffer.position(), null));
buffer.put((byte) 0);
});
result.getDataSection().insertData(data);
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testInvalidDataSectionReference() {
CompilationResult result = new CompilationResult();
DataSectionReference ref = result.getDataSection().insertData(new Data(1, 1, DataBuilder.zero(1)));
Data data = new Data(1, 1, (buffer, patch) -> {
patch.accept(new DataPatch(buffer.position(), ref));
buffer.put((byte) 0);
});
result.getDataSection().insertData(data);
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testInvalidNarrowMethodInDataSection() {
CompilationResult result = new CompilationResult();
HotSpotConstant c = (HotSpotConstant) dummyMethod.getEncoding();
Data data = new Data(4, 4, (buffer, patch) -> {
patch.accept(new DataPatch(buffer.position(), new ConstantReference((VMConstant) c.compress())));
buffer.putInt(0);
});
result.getDataSection().insertData(data);
installCode(result);
}
@Test(expected = NullPointerException.class)
public void testNullConstantInDataSection() {
CompilationResult result = new CompilationResult();
Data data = new Data(1, 1, (buffer, patch) -> {
patch.accept(new DataPatch(buffer.position(), new ConstantReference(null)));
});
result.getDataSection().insertData(data);
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testInvalidConstantInDataSection() {
CompilationResult result = new CompilationResult();
Data data = new Data(1, 1, (buffer, patch) -> {
patch.accept(new DataPatch(buffer.position(), new ConstantReference(new InvalidVMConstant())));
});
result.getDataSection().insertData(data);
installCode(result);
}
@Test(expected = NullPointerException.class)
public void testNullReferenceInCode() {
CompilationResult result = new CompilationResult();
result.recordDataPatch(0, null);
installCode(result);
}
@Test(expected = NullPointerException.class)
public void testNullConstantInCode() {
CompilationResult result = new CompilationResult();
result.recordDataPatch(0, new ConstantReference(null));
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testInvalidConstantInCode() {
CompilationResult result = new CompilationResult();
result.recordDataPatch(0, new ConstantReference(new InvalidVMConstant()));
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testInvalidReference() {
CompilationResult result = new CompilationResult();
result.recordDataPatch(0, new InvalidReference());
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testOutOfBoundsDataSectionReference() {
CompilationResult result = new CompilationResult();
DataSectionReference ref = new DataSectionReference();
ref.setOffset(0x1000);
result.recordDataPatch(0, ref);
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testInvalidMark() {
CompilationResult result = new CompilationResult();
result.recordMark(0, new Object());
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testInvalidMarkInt() {
CompilationResult result = new CompilationResult();
result.recordMark(0, -1);
installCode(result);
}
@Test(expected = NullPointerException.class)
public void testNullInfopoint() {
CompilationResult result = new CompilationResult();
result.addInfopoint(null);
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testUnknownInfopointReason() {
CompilationResult result = new CompilationResult();
result.addInfopoint(new Infopoint(0, null, InfopointReason.UNKNOWN));
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testInfopointMissingDebugInfo() {
CompilationResult result = new CompilationResult();
result.addInfopoint(new Infopoint(0, null, InfopointReason.METHOD_START));
installCode(result);
}
@Test(expected = JVMCIError.class)
public void testSafepointMissingDebugInfo() {
CompilationResult result = new CompilationResult();
result.addInfopoint(new Infopoint(0, null, InfopointReason.SAFEPOINT));
installCode(result);
}
}

212
hotspot/test/compiler/jvmci/errors/TestInvalidDebugInfo.java Normal file
View File

@ -0,0 +1,212 @@
/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* @test
* @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9") & os.arch != "aarch64"
* @compile CodeInstallerTest.java
* @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI compiler.jvmci.errors.TestInvalidDebugInfo
*/
package compiler.jvmci.errors;
import static jdk.vm.ci.code.CompilationResult.Infopoint;
import jdk.vm.ci.code.BytecodeFrame;
import jdk.vm.ci.code.CompilationResult;
import jdk.vm.ci.code.DebugInfo;
import jdk.vm.ci.code.InfopointReason;
import jdk.vm.ci.code.Location;
import jdk.vm.ci.code.Register;
import jdk.vm.ci.code.StackSlot;
import jdk.vm.ci.code.VirtualObject;
import jdk.vm.ci.hotspot.HotSpotReferenceMap;
import jdk.vm.ci.meta.JavaConstant;
import jdk.vm.ci.meta.JavaKind;
import jdk.vm.ci.meta.JavaValue;
import jdk.vm.ci.meta.LIRKind;
import jdk.vm.ci.meta.ResolvedJavaType;
import jdk.vm.ci.meta.Value;
import jdk.vm.ci.common.JVMCIError;
import org.junit.Test;
/**
* Tests for errors in debug info.
*/
public class TestInvalidDebugInfo extends CodeInstallerTest {
private static class UnknownJavaValue implements JavaValue {
}
private void test(JavaValue[] values, JavaKind[] slotKinds, int locals, int stack, int locks) {
test(null, values, slotKinds, locals, stack, locks);
}
private void test(VirtualObject[] vobj, JavaValue[] values, JavaKind[] slotKinds, int locals, int stack, int locks) {
BytecodeFrame frame = new BytecodeFrame(null, dummyMethod, 0, false, false, values, slotKinds, locals, stack, locks);
DebugInfo info = new DebugInfo(frame, vobj);
info.setReferenceMap(new HotSpotReferenceMap(new Location[0], new Location[0], new int[0], 8));
CompilationResult result = new CompilationResult();
result.addInfopoint(new Infopoint(0, info, InfopointReason.SAFEPOINT));
installCode(result);
}
@Test(expected = NullPointerException.class)
public void testNullValues() {
test(null, new JavaKind[0], 0, 0, 0);
}
@Test(expected = NullPointerException.class)
public void testNullSlotKinds() {
test(new JavaValue[0], null, 0, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnexpectedScopeValuesLength() {
test(new JavaValue[]{JavaConstant.FALSE}, new JavaKind[0], 0, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnexpectedScopeSlotKindsLength() {
test(new JavaValue[0], new JavaKind[]{JavaKind.Boolean}, 0, 0, 0);
}
@Test(expected = NullPointerException.class)
public void testNullValue() {
test(new JavaValue[]{null}, new JavaKind[]{JavaKind.Int}, 1, 0, 0);
}
@Test(expected = NullPointerException.class)
public void testNullSlotKind() {
test(new JavaValue[]{JavaConstant.INT_0}, new JavaKind[]{null}, 1, 0, 0);
}
@Test(expected = NullPointerException.class)
public void testNullMonitor() {
test(new JavaValue[]{null}, new JavaKind[0], 0, 0, 1);
}
@Test(expected = JVMCIError.class)
public void testWrongMonitorType() {
test(new JavaValue[]{JavaConstant.INT_0}, new JavaKind[0], 0, 0, 1);
}
@Test(expected = JVMCIError.class)
public void testUnexpectedIllegalValue() {
test(new JavaValue[]{Value.ILLEGAL}, new JavaKind[]{JavaKind.Int}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnexpectedTypeInCPURegister() {
Register reg = getRegister(arch.getPlatformKind(JavaKind.Int), 0);
test(new JavaValue[]{reg.asValue()}, new JavaKind[]{JavaKind.Illegal}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnexpectedTypeInFloatRegister() {
Register reg = getRegister(arch.getPlatformKind(JavaKind.Float), 0);
test(new JavaValue[]{reg.asValue()}, new JavaKind[]{JavaKind.Illegal}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnexpectedTypeOnStack() {
LIRKind kind = codeCache.getTarget().getLIRKind(JavaKind.Int);
StackSlot value = StackSlot.get(kind, 8, false);
test(new JavaValue[]{value}, new JavaKind[]{JavaKind.Illegal}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testWrongConstantType() {
test(new JavaValue[]{JavaConstant.INT_0}, new JavaKind[]{JavaKind.Object}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnsupportedConstantType() {
test(new JavaValue[]{JavaConstant.forShort((short) 0)}, new JavaKind[]{JavaKind.Short}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnexpectedNull() {
test(new JavaValue[]{JavaConstant.NULL_POINTER}, new JavaKind[]{JavaKind.Int}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnexpectedObject() {
JavaValue wrapped = constantReflection.forObject(this);
test(new JavaValue[]{wrapped}, new JavaKind[]{JavaKind.Int}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnknownJavaValue() {
test(new JavaValue[]{new UnknownJavaValue()}, new JavaKind[]{JavaKind.Int}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testMissingIllegalAfterDouble() {
test(new JavaValue[]{JavaConstant.DOUBLE_0, JavaConstant.INT_0}, new JavaKind[]{JavaKind.Double, JavaKind.Int}, 2, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testInvalidVirtualObjectId() {
ResolvedJavaType obj = metaAccess.lookupJavaType(Object.class);
VirtualObject o = VirtualObject.get(obj, 5);
o.setValues(new JavaValue[0], new JavaKind[0]);
test(new VirtualObject[]{o}, new JavaValue[0], new JavaKind[0], 0, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testDuplicateVirtualObject() {
ResolvedJavaType obj = metaAccess.lookupJavaType(Object.class);
VirtualObject o1 = VirtualObject.get(obj, 0);
o1.setValues(new JavaValue[0], new JavaKind[0]);
VirtualObject o2 = VirtualObject.get(obj, 0);
o2.setValues(new JavaValue[0], new JavaKind[0]);
test(new VirtualObject[]{o1, o2}, new JavaValue[0], new JavaKind[0], 0, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUnexpectedVirtualObject() {
ResolvedJavaType obj = metaAccess.lookupJavaType(Object.class);
VirtualObject o = VirtualObject.get(obj, 0);
o.setValues(new JavaValue[0], new JavaKind[0]);
test(new VirtualObject[]{o}, new JavaValue[]{o}, new JavaKind[]{JavaKind.Int}, 1, 0, 0);
}
@Test(expected = JVMCIError.class)
public void testUndefinedVirtualObject() {
ResolvedJavaType obj = metaAccess.lookupJavaType(Object.class);
VirtualObject o0 = VirtualObject.get(obj, 0);
o0.setValues(new JavaValue[0], new JavaKind[0]);
VirtualObject o1 = VirtualObject.get(obj, 1);
o1.setValues(new JavaValue[0], new JavaKind[0]);
test(new VirtualObject[]{o0}, new JavaValue[]{o1}, new JavaKind[]{JavaKind.Object}, 1, 0, 0);
}
}

127
hotspot/test/compiler/jvmci/errors/TestInvalidOopMap.java Normal file
View File

@ -0,0 +1,127 @@
/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* @test
* @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9") & os.arch != "aarch64"
* @compile CodeInstallerTest.java
* @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI compiler.jvmci.errors.TestInvalidOopMap
*/
package compiler.jvmci.errors;
import static jdk.vm.ci.code.CompilationResult.Infopoint;
import jdk.vm.ci.code.BytecodePosition;
import jdk.vm.ci.code.CompilationResult;
import jdk.vm.ci.code.DebugInfo;
import jdk.vm.ci.code.InfopointReason;
import jdk.vm.ci.code.Location;
import jdk.vm.ci.code.ReferenceMap;
import jdk.vm.ci.code.Register;
import jdk.vm.ci.hotspot.HotSpotReferenceMap;
import jdk.vm.ci.hotspot.HotSpotVMConfig;
import jdk.vm.ci.meta.JavaKind;
import jdk.vm.ci.meta.LIRKind;
import jdk.vm.ci.meta.PlatformKind;
import jdk.vm.ci.common.JVMCIError;
import org.junit.Test;
/**
* Tests for errors in oop maps.
*/
public class TestInvalidOopMap extends CodeInstallerTest {
private static class InvalidReferenceMap extends ReferenceMap {
}
private void test(ReferenceMap refMap) {
BytecodePosition pos = new BytecodePosition(null, dummyMethod, 0);
DebugInfo info = new DebugInfo(pos);
info.setReferenceMap(refMap);
CompilationResult result = new CompilationResult();
result.addInfopoint(new Infopoint(0, info, InfopointReason.SAFEPOINT));
installCode(result);
}
@Test(expected = NullPointerException.class)
public void testMissingReferenceMap() {
test(null);
}
@Test(expected = JVMCIError.class)
public void testInvalidReferenceMap() {
test(new InvalidReferenceMap());
}
@Test(expected = NullPointerException.class)
public void testNullOops() {
test(new HotSpotReferenceMap(null, new Location[0], new int[0], 8));
}
@Test(expected = NullPointerException.class)
public void testNullBase() {
test(new HotSpotReferenceMap(new Location[0], null, new int[0], 8));
}
@Test(expected = NullPointerException.class)
public void testNullSize() {
test(new HotSpotReferenceMap(new Location[0], new Location[0], null, 8));
}
@Test(expected = JVMCIError.class)
public void testInvalidLength() {
test(new HotSpotReferenceMap(new Location[1], new Location[2], new int[3], 8));
}
@Test(expected = JVMCIError.class)
public void testInvalidShortOop() {
PlatformKind kind = arch.getPlatformKind(JavaKind.Short);
Register reg = getRegister(kind, 0);
Location[] oops = new Location[]{Location.register(reg)};
Location[] base = new Location[]{null};
int[] size = new int[]{kind.getSizeInBytes()};
test(new HotSpotReferenceMap(oops, base, size, 8));
}
@Test(expected = JVMCIError.class)
public void testInvalidNarrowDerivedOop() {
if (!HotSpotVMConfig.config().useCompressedOops) {
throw new JVMCIError("skipping test");
}
PlatformKind kind = arch.getPlatformKind(JavaKind.Int);
Register reg = getRegister(kind, 0);
Register baseReg = getRegister(arch.getPlatformKind(JavaKind.Object), 1);
Location[] oops = new Location[]{Location.register(reg)};
Location[] base = new Location[]{Location.register(baseReg)};
int[] size = new int[]{kind.getSizeInBytes()};
test(new HotSpotReferenceMap(oops, base, size, 8));
}
}