TrustFinalDefaultFields = new OptionValue<>(true);
- //@formatter:on
- }
+ /**
+ * Determines whether to treat {@code final} fields with default values as constant.
+ */
+ private static final boolean TrustFinalDefaultFields = HotSpotJVMCIRuntime.getBooleanProperty("TrustFinalDefaultFields", true);
protected final HotSpotJVMCIRuntimeProvider runtime;
protected final HotSpotMethodHandleAccessProvider methodHandleAccess;
@@ -239,10 +233,10 @@ public class HotSpotConstantReflectionProvider implements ConstantReflectionProv
/**
* Determines if a static field is constant for the purpose of
- * {@link #readConstantFieldValue(JavaField, JavaConstant)}.
+ * {@link #readConstantFieldValue(ResolvedJavaField, JavaConstant)}.
*/
protected boolean isStaticFieldConstant(HotSpotResolvedJavaField staticField) {
- if (staticField.isFinal() || staticField.isStable()) {
+ if (staticField.isFinal() || (staticField.isStable() && runtime.getConfig().foldStableValues)) {
ResolvedJavaType holder = staticField.getDeclaringClass();
if (holder.isInitialized() && !holder.getName().equals(SystemClassName)) {
return true;
@@ -255,14 +249,14 @@ public class HotSpotConstantReflectionProvider implements ConstantReflectionProv
* Determines if a value read from a {@code final} instance field is considered constant. The
* implementation in {@link HotSpotConstantReflectionProvider} returns true if {@code value} is
* not the {@link JavaConstant#isDefaultForKind default value} for its kind or if
- * {@link Options#TrustFinalDefaultFields} is true.
+ * {@link #TrustFinalDefaultFields} is true.
*
* @param value a value read from a {@code final} instance field
* @param receiverClass the {@link Object#getClass() class} of object from which the
* {@code value} was read
*/
protected boolean isFinalInstanceFieldValueConstant(JavaConstant value, Class receiverClass) {
- return !value.isDefaultForKind() || Options.TrustFinalDefaultFields.getValue();
+ return !value.isDefaultForKind() || TrustFinalDefaultFields;
}
/**
@@ -278,13 +272,7 @@ public class HotSpotConstantReflectionProvider implements ConstantReflectionProv
return !value.isDefaultForKind();
}
- /**
- * {@inheritDoc}
- *
- * The {@code value} field in {@link OptionValue} is considered constant if the type of
- * {@code receiver} is (assignable to) {@link StableOptionValue}.
- */
- public JavaConstant readConstantFieldValue(JavaField field, JavaConstant receiver) {
+ public JavaConstant readConstantFieldValue(ResolvedJavaField field, JavaConstant receiver) {
HotSpotResolvedJavaField hotspotField = (HotSpotResolvedJavaField) field;
if (hotspotField.isStatic()) {
@@ -312,37 +300,31 @@ public class HotSpotConstantReflectionProvider implements ConstantReflectionProv
return value;
}
}
- } else if (hotspotField.isStable()) {
+ } else if (hotspotField.isStable() && runtime.getConfig().foldStableValues) {
if (hotspotField.isInObject(object)) {
JavaConstant value = readFieldValue(field, receiver);
if (isStableInstanceFieldValueConstant(value, object.getClass())) {
return value;
}
}
- } else {
- Class clazz = object.getClass();
- if (StableOptionValue.class.isAssignableFrom(clazz)) {
- if (hotspotField.isInObject(object) && hotspotField.getName().equals("value")) {
- StableOptionValue option = (StableOptionValue) object;
- return HotSpotObjectConstantImpl.forObject(option.getValue());
- }
- }
}
}
}
return null;
}
- public JavaConstant readFieldValue(JavaField field, JavaConstant receiver) {
+ public JavaConstant readFieldValue(ResolvedJavaField field, JavaConstant receiver) {
HotSpotResolvedJavaField hotspotField = (HotSpotResolvedJavaField) field;
if (!hotspotField.isStable()) {
return readNonStableFieldValue(field, receiver);
- } else {
+ } else if (runtime.getConfig().foldStableValues) {
return readStableFieldValue(field, receiver, hotspotField.isDefaultStable());
+ } else {
+ return null;
}
}
- private JavaConstant readNonStableFieldValue(JavaField field, JavaConstant receiver) {
+ private JavaConstant readNonStableFieldValue(ResolvedJavaField field, JavaConstant receiver) {
HotSpotResolvedJavaField hotspotField = (HotSpotResolvedJavaField) field;
if (hotspotField.isStatic()) {
HotSpotResolvedJavaType holder = (HotSpotResolvedJavaType) hotspotField.getDeclaringClass();
@@ -357,7 +339,7 @@ public class HotSpotConstantReflectionProvider implements ConstantReflectionProv
return null;
}
- public JavaConstant readStableFieldValue(JavaField field, JavaConstant receiver, boolean isDefaultStable) {
+ public JavaConstant readStableFieldValue(ResolvedJavaField field, JavaConstant receiver, boolean isDefaultStable) {
JavaConstant fieldValue = readNonStableFieldValue(field, receiver);
if (fieldValue.isNonNull()) {
JavaType declaredType = field.getType();
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotJVMCIRuntime.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotJVMCIRuntime.java
index 7ea4ebf407d..bf7f255d4db 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotJVMCIRuntime.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotJVMCIRuntime.java
@@ -49,6 +49,7 @@ import jdk.vm.ci.runtime.JVMCI;
import jdk.vm.ci.runtime.JVMCIBackend;
import jdk.vm.ci.runtime.JVMCICompiler;
import jdk.vm.ci.service.Services;
+import sun.misc.VM;
//JaCoCo Exclude
@@ -83,6 +84,22 @@ public final class HotSpotJVMCIRuntime implements HotSpotJVMCIRuntimeProvider, H
return DelayedInit.instance;
}
+ /**
+ * Gets a boolean value based on a system property {@linkplain VM#getSavedProperty(String)
+ * saved} at system initialization time. The property name is prefixed with "{@code jvmci.}".
+ *
+ * @param name the name of the system property to derive a boolean value from using
+ * {@link Boolean#parseBoolean(String)}
+ * @param def the value to return if there is no system property corresponding to {@code name}
+ */
+ public static boolean getBooleanProperty(String name, boolean def) {
+ String value = VM.getSavedProperty("jvmci." + name);
+ if (value == null) {
+ return def;
+ }
+ return Boolean.parseBoolean(value);
+ }
+
public static HotSpotJVMCIBackendFactory findFactory(String architecture) {
for (HotSpotJVMCIBackendFactory factory : Services.load(HotSpotJVMCIBackendFactory.class)) {
if (factory.getArchitecture().equalsIgnoreCase(architecture)) {
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaField.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaField.java
index 00b0c0de8c9..1fd7e48924f 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaField.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaField.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 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
@@ -40,17 +40,14 @@ public interface HotSpotResolvedJavaField extends ResolvedJavaField {
int offset();
/**
- * Checks if this field has the {@link Stable} annotation.
- *
- * @return true if field has {@link Stable} annotation, false otherwise
+ * Determines if this field should be treated as a constant.
*/
boolean isStable();
/**
- * If this field is stable, checks if default values (0, null, etc.) should be considered stable
- * as well.
- *
- * @return true if default values should be considered stable, false otherwise
+ * Determines if this field should be considered constant if it has the default value for its
+ * type (e.g, 0, null, etc.). The result of this method is undefined if this field is not
+ * {@linkplain #isStable() stable}.
*/
boolean isDefaultStable();
}
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaFieldImpl.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaFieldImpl.java
index cd89be3e563..c6f4dabc0fb 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaFieldImpl.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaFieldImpl.java
@@ -35,21 +35,16 @@ import jdk.vm.ci.meta.MetaAccessProvider;
import jdk.vm.ci.meta.ModifiersProvider;
import jdk.vm.ci.meta.ResolvedJavaField;
import jdk.vm.ci.meta.ResolvedJavaType;
-import jdk.vm.ci.options.Option;
-import jdk.vm.ci.options.OptionType;
-import jdk.vm.ci.options.OptionValue;
/**
* Represents a field in a HotSpot type.
*/
class HotSpotResolvedJavaFieldImpl implements HotSpotResolvedJavaField, HotSpotProxified {
- static class Options {
- //@formatter:off
- @Option(help = "Mark well-known stable fields as such.", type = OptionType.Debug)
- public static final OptionValue ImplicitStableValues = new OptionValue<>(true);
- //@formatter:on
- }
+ /**
+ * Mark well-known stable fields as such.
+ */
+ private static final boolean ImplicitStableValues = HotSpotJVMCIRuntime.getBooleanProperty("ImplicitStableValues", true);
private final HotSpotResolvedObjectTypeImpl holder;
private final String name;
@@ -190,7 +185,7 @@ class HotSpotResolvedJavaFieldImpl implements HotSpotResolvedJavaField, HotSpotP
@Override
public boolean isSynthetic() {
- return (config().syntheticFlag & modifiers) != 0;
+ return (config().jvmAccSynthetic & modifiers) != 0;
}
/**
@@ -203,7 +198,7 @@ class HotSpotResolvedJavaFieldImpl implements HotSpotResolvedJavaField, HotSpotP
return true;
}
assert getAnnotation(Stable.class) == null;
- if (Options.ImplicitStableValues.getValue() && isImplicitStableField()) {
+ if (ImplicitStableValues && isImplicitStableField()) {
return true;
}
return false;
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethod.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethod.java
index d1ecdac098d..80635caa7c7 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethod.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethod.java
@@ -27,22 +27,12 @@ import java.lang.reflect.Modifier;
import jdk.vm.ci.meta.JavaMethod;
import jdk.vm.ci.meta.ResolvedJavaMethod;
import jdk.vm.ci.meta.ResolvedJavaType;
-import jdk.vm.ci.options.Option;
-import jdk.vm.ci.options.OptionType;
-import jdk.vm.ci.options.OptionValue;
/**
* Implementation of {@link JavaMethod} for resolved HotSpot methods.
*/
public interface HotSpotResolvedJavaMethod extends ResolvedJavaMethod {
- public static class Options {
- // @formatter:off
- @Option(help = "", type = OptionType.Debug)
- public static final OptionValue UseProfilingInformation = new OptionValue<>(true);
- // @formatter:on
- }
-
/**
* Returns true if this method has a {@code CallerSensitive} annotation.
*
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl.java
index 34647ae886c..5999d8c204f 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl.java
@@ -24,7 +24,6 @@ package jdk.vm.ci.hotspot;
import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;
import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
-import static jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod.Options.UseProfilingInformation;
import static jdk.vm.ci.hotspot.HotSpotVMConfig.config;
import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
@@ -424,7 +423,7 @@ final class HotSpotResolvedJavaMethodImpl extends HotSpotMethod implements HotSp
public ProfilingInfo getProfilingInfo(boolean includeNormal, boolean includeOSR) {
ProfilingInfo info;
- if (UseProfilingInformation.getValue() && methodData == null) {
+ if (methodData == null) {
long metaspaceMethodData = UNSAFE.getAddress(metaspaceMethod + config().methodDataOffset);
if (metaspaceMethodData != 0) {
methodData = new HotSpotMethodData(metaspaceMethodData, this);
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java
index 4ef227ec823..65d92b1d8fd 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl.java
@@ -324,8 +324,7 @@ final class HotSpotResolvedObjectTypeImpl extends HotSpotResolvedJavaType implem
@Override
public boolean hasFinalizer() {
- HotSpotVMConfig config = config();
- return (getAccessFlags() & config.klassHasFinalizerFlag) != 0;
+ return (getAccessFlags() & config().jvmAccHasFinalizer) != 0;
}
@Override
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotVMConfig.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotVMConfig.java
index 2f8decbdeab..d237006dfcb 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotVMConfig.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotVMConfig.java
@@ -37,7 +37,6 @@ import jdk.vm.ci.hotspotvmconfig.HotSpotVMConstant;
import jdk.vm.ci.hotspotvmconfig.HotSpotVMData;
import jdk.vm.ci.hotspotvmconfig.HotSpotVMField;
import jdk.vm.ci.hotspotvmconfig.HotSpotVMFlag;
-import jdk.vm.ci.hotspotvmconfig.HotSpotVMManual;
import jdk.vm.ci.hotspotvmconfig.HotSpotVMType;
import sun.misc.Unsafe;
@@ -68,11 +67,11 @@ public class HotSpotVMConfig {
assert gHotSpotVMData != 0;
// Make FindBugs happy.
- gHotSpotVMStructs = 0;
- gHotSpotVMTypes = 0;
- gHotSpotVMIntConstants = 0;
- gHotSpotVMLongConstants = 0;
- gHotSpotVMAddresses = 0;
+ jvmciHotSpotVMStructs = 0;
+ jvmciHotSpotVMTypes = 0;
+ jvmciHotSpotVMIntConstants = 0;
+ jvmciHotSpotVMLongConstants = 0;
+ jvmciHotSpotVMAddresses = 0;
// Initialize the gHotSpotVM fields.
for (Field f : HotSpotVMConfig.class.getDeclaredFields()) {
@@ -89,41 +88,17 @@ public class HotSpotVMConfig {
}
// Quick sanity check.
- assert gHotSpotVMStructs != 0;
- assert gHotSpotVMTypes != 0;
- assert gHotSpotVMIntConstants != 0;
- assert gHotSpotVMLongConstants != 0;
- assert gHotSpotVMAddresses != 0;
+ assert jvmciHotSpotVMStructs != 0;
+ assert jvmciHotSpotVMTypes != 0;
+ assert jvmciHotSpotVMIntConstants != 0;
+ assert jvmciHotSpotVMLongConstants != 0;
+ assert jvmciHotSpotVMAddresses != 0;
initialize();
oopEncoding = new CompressEncoding(narrowOopBase, narrowOopShift, logMinObjAlignment());
klassEncoding = new CompressEncoding(narrowKlassBase, narrowKlassShift, logKlassAlignment);
- final long barrierSetAddress = UNSAFE.getAddress(universeCollectedHeap + collectedHeapBarrierSetOffset);
- final int kind = UNSAFE.getInt(barrierSetAddress + barrierSetFakeRttiOffset + fakeRttiConcreteTagOffset);
- if ((kind == barrierSetCardTableModRef) || (kind == barrierSetCardTableForRS) || (kind == barrierSetCardTableExtension) || (kind == barrierSetG1SATBCT) || (kind == barrierSetG1SATBCTLogging)) {
- final long base = UNSAFE.getAddress(barrierSetAddress + cardTableModRefBSByteMapBaseOffset);
- assert base != 0 : "unexpected byte_map_base: " + base;
- cardtableStartAddress = base;
- cardtableShift = cardTableModRefBSCardShift;
- } else if (kind == barrierSetModRef) {
- // No post barriers
- cardtableStartAddress = 0;
- cardtableShift = 0;
- } else {
- cardtableStartAddress = -1;
- cardtableShift = -1;
- }
-
- // Now handle all HotSpotVMManual fields.
- inlineCacheMissStub = inlineCacheMissBlob + UNSAFE.getInt(inlineCacheMissBlob + codeBlobCodeOffsetOffset);
- handleWrongMethodStub = wrongMethodBlob + UNSAFE.getInt(wrongMethodBlob + codeBlobCodeOffsetOffset);
- handleDeoptStub = deoptBlob + UNSAFE.getInt(deoptBlob + codeBlobCodeOffsetOffset) + UNSAFE.getInt(deoptBlob + deoptimizationBlobUnpackOffsetOffset);
- uncommonTrapStub = deoptBlob + UNSAFE.getInt(deoptBlob + codeBlobCodeOffsetOffset) + UNSAFE.getInt(deoptBlob + deoptimizationBlobUncommonTrapOffsetOffset);
-
- tlabAlignmentReserve = roundUp(threadLocalAllocBufferEndReserve(), minObjAlignment());
-
assert check();
assert HotSpotVMConfigVerifier.check();
}
@@ -139,28 +114,28 @@ public class HotSpotVMConfig {
private void initialize() {
// Fill the VM fields hash map.
HashMap vmFields = new HashMap<>();
- for (VMFields.Field e : new VMFields(gHotSpotVMStructs)) {
+ for (VMFields.Field e : new VMFields(jvmciHotSpotVMStructs)) {
vmFields.put(e.getName(), e);
}
// Fill the VM types hash map.
HashMap vmTypes = new HashMap<>();
- for (VMTypes.Type e : new VMTypes(gHotSpotVMTypes)) {
+ for (VMTypes.Type e : new VMTypes(jvmciHotSpotVMTypes)) {
vmTypes.put(e.getTypeName(), e);
}
// Fill the VM constants hash map.
HashMap vmConstants = new HashMap<>();
- for (AbstractConstant e : new VMIntConstants(gHotSpotVMIntConstants)) {
+ for (AbstractConstant e : new VMIntConstants(jvmciHotSpotVMIntConstants)) {
vmConstants.put(e.getName(), e);
}
- for (AbstractConstant e : new VMAddresses(gHotSpotVMLongConstants)) {
+ for (AbstractConstant e : new VMLongConstants(jvmciHotSpotVMLongConstants)) {
vmConstants.put(e.getName(), e);
}
// Fill the VM addresses hash map.
HashMap vmAddresses = new HashMap<>();
- for (VMAddresses.Address e : new VMAddresses(gHotSpotVMAddresses)) {
+ for (VMAddresses.Address e : new VMAddresses(jvmciHotSpotVMAddresses)) {
vmAddresses.put(e.getName(), e);
}
@@ -213,6 +188,7 @@ public class HotSpotVMConfig {
if (entry == null) {
throw new JVMCIError(f.getName() + ": expected VM type not found: " + name);
}
+
switch (annotation.get()) {
case SIZE:
setField(f, entry.getSize());
@@ -371,14 +347,14 @@ public class HotSpotVMConfig {
/**
* VMStructEntry (see {@code vmStructs.hpp}).
*/
- @HotSpotVMData(index = 0) @Stable private long gHotSpotVMStructs;
- @HotSpotVMData(index = 1) @Stable private long gHotSpotVMStructEntryTypeNameOffset;
- @HotSpotVMData(index = 2) @Stable private long gHotSpotVMStructEntryFieldNameOffset;
- @HotSpotVMData(index = 3) @Stable private long gHotSpotVMStructEntryTypeStringOffset;
- @HotSpotVMData(index = 4) @Stable private long gHotSpotVMStructEntryIsStaticOffset;
- @HotSpotVMData(index = 5) @Stable private long gHotSpotVMStructEntryOffsetOffset;
- @HotSpotVMData(index = 6) @Stable private long gHotSpotVMStructEntryAddressOffset;
- @HotSpotVMData(index = 7) @Stable private long gHotSpotVMStructEntryArrayStride;
+ @HotSpotVMData(index = 0) @Stable private long jvmciHotSpotVMStructs;
+ @HotSpotVMData(index = 1) @Stable private long jvmciHotSpotVMStructEntryTypeNameOffset;
+ @HotSpotVMData(index = 2) @Stable private long jvmciHotSpotVMStructEntryFieldNameOffset;
+ @HotSpotVMData(index = 3) @Stable private long jvmciHotSpotVMStructEntryTypeStringOffset;
+ @HotSpotVMData(index = 4) @Stable private long jvmciHotSpotVMStructEntryIsStaticOffset;
+ @HotSpotVMData(index = 5) @Stable private long jvmciHotSpotVMStructEntryOffsetOffset;
+ @HotSpotVMData(index = 6) @Stable private long jvmciHotSpotVMStructEntryAddressOffset;
+ @HotSpotVMData(index = 7) @Stable private long jvmciHotSpotVMStructEntryArrayStride;
final class VMFields implements Iterable {
@@ -394,7 +370,7 @@ public class HotSpotVMConfig {
private int index = 0;
private Field current() {
- return new Field(address + gHotSpotVMStructEntryArrayStride * index);
+ return new Field(address + jvmciHotSpotVMStructEntryArrayStride * index);
}
/**
@@ -422,30 +398,30 @@ public class HotSpotVMConfig {
}
public String getTypeName() {
- long typeNameAddress = UNSAFE.getAddress(entryAddress + gHotSpotVMStructEntryTypeNameOffset);
+ long typeNameAddress = UNSAFE.getAddress(entryAddress + jvmciHotSpotVMStructEntryTypeNameOffset);
return readCString(UNSAFE, typeNameAddress);
}
public String getFieldName() {
- long fieldNameAddress = UNSAFE.getAddress(entryAddress + gHotSpotVMStructEntryFieldNameOffset);
+ long fieldNameAddress = UNSAFE.getAddress(entryAddress + jvmciHotSpotVMStructEntryFieldNameOffset);
return readCString(UNSAFE, fieldNameAddress);
}
public String getTypeString() {
- long typeStringAddress = UNSAFE.getAddress(entryAddress + gHotSpotVMStructEntryTypeStringOffset);
+ long typeStringAddress = UNSAFE.getAddress(entryAddress + jvmciHotSpotVMStructEntryTypeStringOffset);
return readCString(UNSAFE, typeStringAddress);
}
public boolean isStatic() {
- return UNSAFE.getInt(entryAddress + gHotSpotVMStructEntryIsStaticOffset) != 0;
+ return UNSAFE.getInt(entryAddress + jvmciHotSpotVMStructEntryIsStaticOffset) != 0;
}
public long getOffset() {
- return UNSAFE.getLong(entryAddress + gHotSpotVMStructEntryOffsetOffset);
+ return UNSAFE.getLong(entryAddress + jvmciHotSpotVMStructEntryOffsetOffset);
}
public long getAddress() {
- return UNSAFE.getAddress(entryAddress + gHotSpotVMStructEntryAddressOffset);
+ return UNSAFE.getAddress(entryAddress + jvmciHotSpotVMStructEntryAddressOffset);
}
public String getName() {
@@ -466,6 +442,7 @@ public class HotSpotVMConfig {
case "address":
case "intptr_t":
case "uintptr_t":
+ case "size_t":
return UNSAFE.getAddress(getAddress());
default:
// All foo* types are addresses.
@@ -487,14 +464,14 @@ public class HotSpotVMConfig {
/**
* VMTypeEntry (see vmStructs.hpp).
*/
- @HotSpotVMData(index = 8) @Stable private long gHotSpotVMTypes;
- @HotSpotVMData(index = 9) @Stable private long gHotSpotVMTypeEntryTypeNameOffset;
- @HotSpotVMData(index = 10) @Stable private long gHotSpotVMTypeEntrySuperclassNameOffset;
- @HotSpotVMData(index = 11) @Stable private long gHotSpotVMTypeEntryIsOopTypeOffset;
- @HotSpotVMData(index = 12) @Stable private long gHotSpotVMTypeEntryIsIntegerTypeOffset;
- @HotSpotVMData(index = 13) @Stable private long gHotSpotVMTypeEntryIsUnsignedOffset;
- @HotSpotVMData(index = 14) @Stable private long gHotSpotVMTypeEntrySizeOffset;
- @HotSpotVMData(index = 15) @Stable private long gHotSpotVMTypeEntryArrayStride;
+ @HotSpotVMData(index = 8) @Stable private long jvmciHotSpotVMTypes;
+ @HotSpotVMData(index = 9) @Stable private long jvmciHotSpotVMTypeEntryTypeNameOffset;
+ @HotSpotVMData(index = 10) @Stable private long jvmciHotSpotVMTypeEntrySuperclassNameOffset;
+ @HotSpotVMData(index = 11) @Stable private long jvmciHotSpotVMTypeEntryIsOopTypeOffset;
+ @HotSpotVMData(index = 12) @Stable private long jvmciHotSpotVMTypeEntryIsIntegerTypeOffset;
+ @HotSpotVMData(index = 13) @Stable private long jvmciHotSpotVMTypeEntryIsUnsignedOffset;
+ @HotSpotVMData(index = 14) @Stable private long jvmciHotSpotVMTypeEntrySizeOffset;
+ @HotSpotVMData(index = 15) @Stable private long jvmciHotSpotVMTypeEntryArrayStride;
final class VMTypes implements Iterable {
@@ -510,7 +487,7 @@ public class HotSpotVMConfig {
private int index = 0;
private Type current() {
- return new Type(address + gHotSpotVMTypeEntryArrayStride * index);
+ return new Type(address + jvmciHotSpotVMTypeEntryArrayStride * index);
}
/**
@@ -538,29 +515,29 @@ public class HotSpotVMConfig {
}
public String getTypeName() {
- long typeNameAddress = UNSAFE.getAddress(entryAddress + gHotSpotVMTypeEntryTypeNameOffset);
+ long typeNameAddress = UNSAFE.getAddress(entryAddress + jvmciHotSpotVMTypeEntryTypeNameOffset);
return readCString(UNSAFE, typeNameAddress);
}
public String getSuperclassName() {
- long superclassNameAddress = UNSAFE.getAddress(entryAddress + gHotSpotVMTypeEntrySuperclassNameOffset);
+ long superclassNameAddress = UNSAFE.getAddress(entryAddress + jvmciHotSpotVMTypeEntrySuperclassNameOffset);
return readCString(UNSAFE, superclassNameAddress);
}
public boolean isOopType() {
- return UNSAFE.getInt(entryAddress + gHotSpotVMTypeEntryIsOopTypeOffset) != 0;
+ return UNSAFE.getInt(entryAddress + jvmciHotSpotVMTypeEntryIsOopTypeOffset) != 0;
}
public boolean isIntegerType() {
- return UNSAFE.getInt(entryAddress + gHotSpotVMTypeEntryIsIntegerTypeOffset) != 0;
+ return UNSAFE.getInt(entryAddress + jvmciHotSpotVMTypeEntryIsIntegerTypeOffset) != 0;
}
public boolean isUnsigned() {
- return UNSAFE.getInt(entryAddress + gHotSpotVMTypeEntryIsUnsignedOffset) != 0;
+ return UNSAFE.getInt(entryAddress + jvmciHotSpotVMTypeEntryIsUnsignedOffset) != 0;
}
public long getSize() {
- return UNSAFE.getLong(entryAddress + gHotSpotVMTypeEntrySizeOffset);
+ return UNSAFE.getLong(entryAddress + jvmciHotSpotVMTypeEntrySizeOffset);
}
@Override
@@ -594,10 +571,10 @@ public class HotSpotVMConfig {
/**
* VMIntConstantEntry (see vmStructs.hpp).
*/
- @HotSpotVMData(index = 16) @Stable private long gHotSpotVMIntConstants;
- @HotSpotVMData(index = 17) @Stable private long gHotSpotVMIntConstantEntryNameOffset;
- @HotSpotVMData(index = 18) @Stable private long gHotSpotVMIntConstantEntryValueOffset;
- @HotSpotVMData(index = 19) @Stable private long gHotSpotVMIntConstantEntryArrayStride;
+ @HotSpotVMData(index = 16) @Stable private long jvmciHotSpotVMIntConstants;
+ @HotSpotVMData(index = 17) @Stable private long jvmciHotSpotVMIntConstantEntryNameOffset;
+ @HotSpotVMData(index = 18) @Stable private long jvmciHotSpotVMIntConstantEntryValueOffset;
+ @HotSpotVMData(index = 19) @Stable private long jvmciHotSpotVMIntConstantEntryArrayStride;
final class VMIntConstants implements Iterable {
@@ -613,7 +590,7 @@ public class HotSpotVMConfig {
private int index = 0;
private Constant current() {
- return new Constant(address + gHotSpotVMIntConstantEntryArrayStride * index);
+ return new Constant(address + jvmciHotSpotVMIntConstantEntryArrayStride * index);
}
/**
@@ -635,7 +612,7 @@ public class HotSpotVMConfig {
final class Constant extends AbstractConstant {
Constant(long address) {
- super(address, gHotSpotVMIntConstantEntryNameOffset, gHotSpotVMIntConstantEntryValueOffset);
+ super(address, jvmciHotSpotVMIntConstantEntryNameOffset, jvmciHotSpotVMIntConstantEntryValueOffset);
}
@Override
@@ -653,10 +630,10 @@ public class HotSpotVMConfig {
/**
* VMLongConstantEntry (see vmStructs.hpp).
*/
- @HotSpotVMData(index = 20) @Stable private long gHotSpotVMLongConstants;
- @HotSpotVMData(index = 21) @Stable private long gHotSpotVMLongConstantEntryNameOffset;
- @HotSpotVMData(index = 22) @Stable private long gHotSpotVMLongConstantEntryValueOffset;
- @HotSpotVMData(index = 23) @Stable private long gHotSpotVMLongConstantEntryArrayStride;
+ @HotSpotVMData(index = 20) @Stable private long jvmciHotSpotVMLongConstants;
+ @HotSpotVMData(index = 21) @Stable private long jvmciHotSpotVMLongConstantEntryNameOffset;
+ @HotSpotVMData(index = 22) @Stable private long jvmciHotSpotVMLongConstantEntryValueOffset;
+ @HotSpotVMData(index = 23) @Stable private long jvmciHotSpotVMLongConstantEntryArrayStride;
final class VMLongConstants implements Iterable {
@@ -672,7 +649,7 @@ public class HotSpotVMConfig {
private int index = 0;
private Constant currentEntry() {
- return new Constant(address + gHotSpotVMLongConstantEntryArrayStride * index);
+ return new Constant(address + jvmciHotSpotVMLongConstantEntryArrayStride * index);
}
/**
@@ -694,7 +671,7 @@ public class HotSpotVMConfig {
final class Constant extends AbstractConstant {
Constant(long address) {
- super(address, gHotSpotVMLongConstantEntryNameOffset, gHotSpotVMLongConstantEntryValueOffset);
+ super(address, jvmciHotSpotVMLongConstantEntryNameOffset, jvmciHotSpotVMLongConstantEntryValueOffset);
}
@Override
@@ -712,10 +689,10 @@ public class HotSpotVMConfig {
/**
* VMAddressEntry (see vmStructs.hpp).
*/
- @HotSpotVMData(index = 24) @Stable private long gHotSpotVMAddresses;
- @HotSpotVMData(index = 25) @Stable private long gHotSpotVMAddressEntryNameOffset;
- @HotSpotVMData(index = 26) @Stable private long gHotSpotVMAddressEntryValueOffset;
- @HotSpotVMData(index = 27) @Stable private long gHotSpotVMAddressEntryArrayStride;
+ @HotSpotVMData(index = 24) @Stable private long jvmciHotSpotVMAddresses;
+ @HotSpotVMData(index = 25) @Stable private long jvmciHotSpotVMAddressEntryNameOffset;
+ @HotSpotVMData(index = 26) @Stable private long jvmciHotSpotVMAddressEntryValueOffset;
+ @HotSpotVMData(index = 27) @Stable private long jvmciHotSpotVMAddressEntryArrayStride;
final class VMAddresses implements Iterable {
@@ -731,7 +708,7 @@ public class HotSpotVMConfig {
private int index = 0;
private Address currentEntry() {
- return new Address(address + gHotSpotVMAddressEntryArrayStride * index);
+ return new Address(address + jvmciHotSpotVMAddressEntryArrayStride * index);
}
/**
@@ -753,7 +730,7 @@ public class HotSpotVMConfig {
final class Address extends AbstractConstant {
Address(long address) {
- super(address, gHotSpotVMAddressEntryNameOffset, gHotSpotVMAddressEntryValueOffset);
+ super(address, jvmciHotSpotVMAddressEntryNameOffset, jvmciHotSpotVMAddressEntryValueOffset);
}
@Override
@@ -876,6 +853,7 @@ public class HotSpotVMConfig {
@HotSpotVMFlag(name = "JVMCIUseFastLocking") @Stable public boolean useFastLocking;
@HotSpotVMFlag(name = "ForceUnreachable") @Stable public boolean forceUnreachable;
@HotSpotVMFlag(name = "CodeCacheSegmentSize") @Stable public int codeSegmentSize;
+ @HotSpotVMFlag(name = "FoldStableValues") @Stable public boolean foldStableValues;
@HotSpotVMFlag(name = "UseTLAB") @Stable public boolean useTLAB;
@HotSpotVMFlag(name = "UseBiasedLocking") @Stable public boolean useBiasedLocking;
@@ -896,7 +874,7 @@ public class HotSpotVMConfig {
@HotSpotVMFlag(name = "FlightRecorder", optional = true) @Stable public boolean flightRecorder;
- @HotSpotVMField(name = "Universe::_collectedHeap", type = "CollectedHeap*", get = HotSpotVMField.Type.VALUE) @Stable private long universeCollectedHeap;
+ @HotSpotVMField(name = "CompilerToVM::Data::Universe_collectedHeap", type = "CollectedHeap*", get = HotSpotVMField.Type.VALUE) @Stable private long universeCollectedHeap;
@HotSpotVMField(name = "CollectedHeap::_total_collections", type = "unsigned int", get = HotSpotVMField.Type.OFFSET) @Stable private int collectedHeapTotalCollectionsOffset;
public long gcTotalCollectionsAddress() {
@@ -909,8 +887,8 @@ public class HotSpotVMConfig {
@HotSpotVMFlag(name = "UseCompressedOops") @Stable public boolean useCompressedOops;
@HotSpotVMFlag(name = "UseCompressedClassPointers") @Stable public boolean useCompressedClassPointers;
- @HotSpotVMField(name = "Universe::_narrow_oop._base", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long narrowOopBase;
- @HotSpotVMField(name = "Universe::_narrow_oop._shift", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int narrowOopShift;
+ @HotSpotVMField(name = "CompilerToVM::Data::Universe_narrow_oop_base", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long narrowOopBase;
+ @HotSpotVMField(name = "CompilerToVM::Data::Universe_narrow_oop_shift", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int narrowOopShift;
@HotSpotVMFlag(name = "ObjectAlignmentInBytes") @Stable public int objectAlignment;
public final int minObjAlignment() {
@@ -922,77 +900,75 @@ public class HotSpotVMConfig {
}
@HotSpotVMType(name = "narrowKlass", get = HotSpotVMType.Type.SIZE) @Stable public int narrowKlassSize;
- @HotSpotVMField(name = "Universe::_narrow_klass._base", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long narrowKlassBase;
- @HotSpotVMField(name = "Universe::_narrow_klass._shift", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int narrowKlassShift;
+ @HotSpotVMField(name = "CompilerToVM::Data::Universe_narrow_klass_base", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long narrowKlassBase;
+ @HotSpotVMField(name = "CompilerToVM::Data::Universe_narrow_klass_shift", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int narrowKlassShift;
@HotSpotVMConstant(name = "LogKlassAlignmentInBytes") @Stable public int logKlassAlignment;
// CPU capabilities
@HotSpotVMFlag(name = "UseSSE") @Stable public int useSSE;
@HotSpotVMFlag(name = "UseAVX", archs = {"amd64"}) @Stable public int useAVX;
- @HotSpotVMField(name = "Abstract_VM_Version::_reserve_for_allocation_prefetch", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int abstractVmVersionReserveForAllocationPrefetch;
+ @HotSpotVMField(name = "Abstract_VM_Version::_features", type = "uint64_t", get = HotSpotVMField.Type.VALUE) @Stable public long vmVersionFeatures;
- // X86 specific values
- @HotSpotVMField(name = "VM_Version::_cpuFeatures", type = "uint64_t", get = HotSpotVMField.Type.VALUE, archs = {"amd64"}) @Stable public long x86CPUFeatures;
- @HotSpotVMConstant(name = "VM_Version::CPU_CX8", archs = {"amd64"}) @Stable public long cpuCX8;
- @HotSpotVMConstant(name = "VM_Version::CPU_CMOV", archs = {"amd64"}) @Stable public long cpuCMOV;
- @HotSpotVMConstant(name = "VM_Version::CPU_FXSR", archs = {"amd64"}) @Stable public long cpuFXSR;
- @HotSpotVMConstant(name = "VM_Version::CPU_HT", archs = {"amd64"}) @Stable public long cpuHT;
- @HotSpotVMConstant(name = "VM_Version::CPU_MMX", archs = {"amd64"}) @Stable public long cpuMMX;
- @HotSpotVMConstant(name = "VM_Version::CPU_3DNOW_PREFETCH", archs = {"amd64"}) @Stable public long cpu3DNOWPREFETCH;
- @HotSpotVMConstant(name = "VM_Version::CPU_SSE", archs = {"amd64"}) @Stable public long cpuSSE;
- @HotSpotVMConstant(name = "VM_Version::CPU_SSE2", archs = {"amd64"}) @Stable public long cpuSSE2;
- @HotSpotVMConstant(name = "VM_Version::CPU_SSE3", archs = {"amd64"}) @Stable public long cpuSSE3;
- @HotSpotVMConstant(name = "VM_Version::CPU_SSSE3", archs = {"amd64"}) @Stable public long cpuSSSE3;
- @HotSpotVMConstant(name = "VM_Version::CPU_SSE4A", archs = {"amd64"}) @Stable public long cpuSSE4A;
- @HotSpotVMConstant(name = "VM_Version::CPU_SSE4_1", archs = {"amd64"}) @Stable public long cpuSSE41;
- @HotSpotVMConstant(name = "VM_Version::CPU_SSE4_2", archs = {"amd64"}) @Stable public long cpuSSE42;
- @HotSpotVMConstant(name = "VM_Version::CPU_POPCNT", archs = {"amd64"}) @Stable public long cpuPOPCNT;
- @HotSpotVMConstant(name = "VM_Version::CPU_LZCNT", archs = {"amd64"}) @Stable public long cpuLZCNT;
- @HotSpotVMConstant(name = "VM_Version::CPU_TSC", archs = {"amd64"}) @Stable public long cpuTSC;
- @HotSpotVMConstant(name = "VM_Version::CPU_TSCINV", archs = {"amd64"}) @Stable public long cpuTSCINV;
- @HotSpotVMConstant(name = "VM_Version::CPU_AVX", archs = {"amd64"}) @Stable public long cpuAVX;
- @HotSpotVMConstant(name = "VM_Version::CPU_AVX2", archs = {"amd64"}) @Stable public long cpuAVX2;
- @HotSpotVMConstant(name = "VM_Version::CPU_AES", archs = {"amd64"}) @Stable public long cpuAES;
- @HotSpotVMConstant(name = "VM_Version::CPU_ERMS", archs = {"amd64"}) @Stable public long cpuERMS;
- @HotSpotVMConstant(name = "VM_Version::CPU_CLMUL", archs = {"amd64"}) @Stable public long cpuCLMUL;
- @HotSpotVMConstant(name = "VM_Version::CPU_BMI1", archs = {"amd64"}) @Stable public long cpuBMI1;
- @HotSpotVMConstant(name = "VM_Version::CPU_BMI2", archs = {"amd64"}) @Stable public long cpuBMI2;
- @HotSpotVMConstant(name = "VM_Version::CPU_RTM", archs = {"amd64"}) @Stable public long cpuRTM;
- @HotSpotVMConstant(name = "VM_Version::CPU_ADX", archs = {"amd64"}) @Stable public long cpuADX;
- @HotSpotVMConstant(name = "VM_Version::CPU_AVX512F", archs = {"amd64"}) @Stable public long cpuAVX512F;
- @HotSpotVMConstant(name = "VM_Version::CPU_AVX512DQ", archs = {"amd64"}) @Stable public long cpuAVX512DQ;
- @HotSpotVMConstant(name = "VM_Version::CPU_AVX512PF", archs = {"amd64"}) @Stable public long cpuAVX512PF;
- @HotSpotVMConstant(name = "VM_Version::CPU_AVX512ER", archs = {"amd64"}) @Stable public long cpuAVX512ER;
- @HotSpotVMConstant(name = "VM_Version::CPU_AVX512CD", archs = {"amd64"}) @Stable public long cpuAVX512CD;
- @HotSpotVMConstant(name = "VM_Version::CPU_AVX512BW", archs = {"amd64"}) @Stable public long cpuAVX512BW;
- @HotSpotVMConstant(name = "VM_Version::CPU_AVX512VL", archs = {"amd64"}) @Stable public long cpuAVX512VL;
+ // AMD64 specific values
+ @HotSpotVMConstant(name = "VM_Version::CPU_CX8", archs = {"amd64"}) @Stable public long amd64CX8;
+ @HotSpotVMConstant(name = "VM_Version::CPU_CMOV", archs = {"amd64"}) @Stable public long amd64CMOV;
+ @HotSpotVMConstant(name = "VM_Version::CPU_FXSR", archs = {"amd64"}) @Stable public long amd64FXSR;
+ @HotSpotVMConstant(name = "VM_Version::CPU_HT", archs = {"amd64"}) @Stable public long amd64HT;
+ @HotSpotVMConstant(name = "VM_Version::CPU_MMX", archs = {"amd64"}) @Stable public long amd64MMX;
+ @HotSpotVMConstant(name = "VM_Version::CPU_3DNOW_PREFETCH", archs = {"amd64"}) @Stable public long amd643DNOWPREFETCH;
+ @HotSpotVMConstant(name = "VM_Version::CPU_SSE", archs = {"amd64"}) @Stable public long amd64SSE;
+ @HotSpotVMConstant(name = "VM_Version::CPU_SSE2", archs = {"amd64"}) @Stable public long amd64SSE2;
+ @HotSpotVMConstant(name = "VM_Version::CPU_SSE3", archs = {"amd64"}) @Stable public long amd64SSE3;
+ @HotSpotVMConstant(name = "VM_Version::CPU_SSSE3", archs = {"amd64"}) @Stable public long amd64SSSE3;
+ @HotSpotVMConstant(name = "VM_Version::CPU_SSE4A", archs = {"amd64"}) @Stable public long amd64SSE4A;
+ @HotSpotVMConstant(name = "VM_Version::CPU_SSE4_1", archs = {"amd64"}) @Stable public long amd64SSE41;
+ @HotSpotVMConstant(name = "VM_Version::CPU_SSE4_2", archs = {"amd64"}) @Stable public long amd64SSE42;
+ @HotSpotVMConstant(name = "VM_Version::CPU_POPCNT", archs = {"amd64"}) @Stable public long amd64POPCNT;
+ @HotSpotVMConstant(name = "VM_Version::CPU_LZCNT", archs = {"amd64"}) @Stable public long amd64LZCNT;
+ @HotSpotVMConstant(name = "VM_Version::CPU_TSC", archs = {"amd64"}) @Stable public long amd64TSC;
+ @HotSpotVMConstant(name = "VM_Version::CPU_TSCINV", archs = {"amd64"}) @Stable public long amd64TSCINV;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AVX", archs = {"amd64"}) @Stable public long amd64AVX;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AVX2", archs = {"amd64"}) @Stable public long amd64AVX2;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AES", archs = {"amd64"}) @Stable public long amd64AES;
+ @HotSpotVMConstant(name = "VM_Version::CPU_ERMS", archs = {"amd64"}) @Stable public long amd64ERMS;
+ @HotSpotVMConstant(name = "VM_Version::CPU_CLMUL", archs = {"amd64"}) @Stable public long amd64CLMUL;
+ @HotSpotVMConstant(name = "VM_Version::CPU_BMI1", archs = {"amd64"}) @Stable public long amd64BMI1;
+ @HotSpotVMConstant(name = "VM_Version::CPU_BMI2", archs = {"amd64"}) @Stable public long amd64BMI2;
+ @HotSpotVMConstant(name = "VM_Version::CPU_RTM", archs = {"amd64"}) @Stable public long amd64RTM;
+ @HotSpotVMConstant(name = "VM_Version::CPU_ADX", archs = {"amd64"}) @Stable public long amd64ADX;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AVX512F", archs = {"amd64"}) @Stable public long amd64AVX512F;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AVX512DQ", archs = {"amd64"}) @Stable public long amd64AVX512DQ;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AVX512PF", archs = {"amd64"}) @Stable public long amd64AVX512PF;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AVX512ER", archs = {"amd64"}) @Stable public long amd64AVX512ER;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AVX512CD", archs = {"amd64"}) @Stable public long amd64AVX512CD;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AVX512BW", archs = {"amd64"}) @Stable public long amd64AVX512BW;
+ @HotSpotVMConstant(name = "VM_Version::CPU_AVX512VL", archs = {"amd64"}) @Stable public long amd64AVX512VL;
// SPARC specific values
- @HotSpotVMField(name = "VM_Version::_features", type = "int", get = HotSpotVMField.Type.VALUE, archs = {"sparc"}) @Stable public int sparcFeatures;
- @HotSpotVMConstant(name = "VM_Version::vis3_instructions_m", archs = {"sparc"}) @Stable public int vis3Instructions;
- @HotSpotVMConstant(name = "VM_Version::vis2_instructions_m", archs = {"sparc"}) @Stable public int vis2Instructions;
- @HotSpotVMConstant(name = "VM_Version::vis1_instructions_m", archs = {"sparc"}) @Stable public int vis1Instructions;
- @HotSpotVMConstant(name = "VM_Version::cbcond_instructions_m", archs = {"sparc"}) @Stable public int cbcondInstructions;
- @HotSpotVMConstant(name = "VM_Version::v8_instructions_m", archs = {"sparc"}) @Stable public int v8Instructions;
- @HotSpotVMConstant(name = "VM_Version::hardware_mul32_m", archs = {"sparc"}) @Stable public int hardwareMul32;
- @HotSpotVMConstant(name = "VM_Version::hardware_div32_m", archs = {"sparc"}) @Stable public int hardwareDiv32;
- @HotSpotVMConstant(name = "VM_Version::hardware_fsmuld_m", archs = {"sparc"}) @Stable public int hardwareFsmuld;
- @HotSpotVMConstant(name = "VM_Version::hardware_popc_m", archs = {"sparc"}) @Stable public int hardwarePopc;
- @HotSpotVMConstant(name = "VM_Version::v9_instructions_m", archs = {"sparc"}) @Stable public int v9Instructions;
- @HotSpotVMConstant(name = "VM_Version::sun4v_m", archs = {"sparc"}) @Stable public int sun4v;
- @HotSpotVMConstant(name = "VM_Version::blk_init_instructions_m", archs = {"sparc"}) @Stable public int blkInitInstructions;
- @HotSpotVMConstant(name = "VM_Version::fmaf_instructions_m", archs = {"sparc"}) @Stable public int fmafInstructions;
- @HotSpotVMConstant(name = "VM_Version::fmau_instructions_m", archs = {"sparc"}) @Stable public int fmauInstructions;
- @HotSpotVMConstant(name = "VM_Version::sparc64_family_m", archs = {"sparc"}) @Stable public int sparc64Family;
- @HotSpotVMConstant(name = "VM_Version::M_family_m", archs = {"sparc"}) @Stable public int mFamily;
- @HotSpotVMConstant(name = "VM_Version::T_family_m", archs = {"sparc"}) @Stable public int tFamily;
- @HotSpotVMConstant(name = "VM_Version::T1_model_m", archs = {"sparc"}) @Stable public int t1Model;
- @HotSpotVMConstant(name = "VM_Version::sparc5_instructions_m", archs = {"sparc"}) @Stable public int sparc5Instructions;
- @HotSpotVMConstant(name = "VM_Version::aes_instructions_m", archs = {"sparc"}) @Stable public int aesInstructions;
- @HotSpotVMConstant(name = "VM_Version::sha1_instruction_m", archs = {"sparc"}) @Stable public int sha1Instruction;
- @HotSpotVMConstant(name = "VM_Version::sha256_instruction_m", archs = {"sparc"}) @Stable public int sha256Instruction;
- @HotSpotVMConstant(name = "VM_Version::sha512_instruction_m", archs = {"sparc"}) @Stable public int sha512Instruction;
+ @HotSpotVMConstant(name = "VM_Version::vis3_instructions_m", archs = {"sparc"}) @Stable public int sparcVis3Instructions;
+ @HotSpotVMConstant(name = "VM_Version::vis2_instructions_m", archs = {"sparc"}) @Stable public int sparcVis2Instructions;
+ @HotSpotVMConstant(name = "VM_Version::vis1_instructions_m", archs = {"sparc"}) @Stable public int sparcVis1Instructions;
+ @HotSpotVMConstant(name = "VM_Version::cbcond_instructions_m", archs = {"sparc"}) @Stable public int sparcCbcondInstructions;
+ @HotSpotVMConstant(name = "VM_Version::v8_instructions_m", archs = {"sparc"}) @Stable public int sparcV8Instructions;
+ @HotSpotVMConstant(name = "VM_Version::hardware_mul32_m", archs = {"sparc"}) @Stable public int sparcHardwareMul32;
+ @HotSpotVMConstant(name = "VM_Version::hardware_div32_m", archs = {"sparc"}) @Stable public int sparcHardwareDiv32;
+ @HotSpotVMConstant(name = "VM_Version::hardware_fsmuld_m", archs = {"sparc"}) @Stable public int sparcHardwareFsmuld;
+ @HotSpotVMConstant(name = "VM_Version::hardware_popc_m", archs = {"sparc"}) @Stable public int sparcHardwarePopc;
+ @HotSpotVMConstant(name = "VM_Version::v9_instructions_m", archs = {"sparc"}) @Stable public int sparcV9Instructions;
+ @HotSpotVMConstant(name = "VM_Version::sun4v_m", archs = {"sparc"}) @Stable public int sparcSun4v;
+ @HotSpotVMConstant(name = "VM_Version::blk_init_instructions_m", archs = {"sparc"}) @Stable public int sparcBlkInitInstructions;
+ @HotSpotVMConstant(name = "VM_Version::fmaf_instructions_m", archs = {"sparc"}) @Stable public int sparcFmafInstructions;
+ @HotSpotVMConstant(name = "VM_Version::fmau_instructions_m", archs = {"sparc"}) @Stable public int sparcFmauInstructions;
+ @HotSpotVMConstant(name = "VM_Version::sparc64_family_m", archs = {"sparc"}) @Stable public int sparcSparc64Family;
+ @HotSpotVMConstant(name = "VM_Version::M_family_m", archs = {"sparc"}) @Stable public int sparcMFamily;
+ @HotSpotVMConstant(name = "VM_Version::T_family_m", archs = {"sparc"}) @Stable public int sparcTFamily;
+ @HotSpotVMConstant(name = "VM_Version::T1_model_m", archs = {"sparc"}) @Stable public int sparcT1Model;
+ @HotSpotVMConstant(name = "VM_Version::sparc5_instructions_m", archs = {"sparc"}) @Stable public int sparcSparc5Instructions;
+ @HotSpotVMConstant(name = "VM_Version::aes_instructions_m", archs = {"sparc"}) @Stable public int sparcAesInstructions;
+ @HotSpotVMConstant(name = "VM_Version::sha1_instruction_m", archs = {"sparc"}) @Stable public int sparcSha1Instruction;
+ @HotSpotVMConstant(name = "VM_Version::sha256_instruction_m", archs = {"sparc"}) @Stable public int sparcSha256Instruction;
+ @HotSpotVMConstant(name = "VM_Version::sha512_instruction_m", archs = {"sparc"}) @Stable public int sparcSha512Instruction;
@HotSpotVMFlag(name = "UseBlockZeroing", archs = {"sparc"}) @Stable public boolean useBlockZeroing;
@HotSpotVMFlag(name = "BlockZeroingLowLimit", archs = {"sparc"}) @Stable public int blockZeroingLowLimit;
@@ -1054,7 +1030,8 @@ public class HotSpotVMConfig {
@HotSpotVMField(name = "InstanceKlass::_init_state", type = "u1", get = HotSpotVMField.Type.OFFSET) @Stable public int instanceKlassInitStateOffset;
@HotSpotVMField(name = "InstanceKlass::_constants", type = "ConstantPool*", get = HotSpotVMField.Type.OFFSET) @Stable public int instanceKlassConstantsOffset;
@HotSpotVMField(name = "InstanceKlass::_fields", type = "Array*", get = HotSpotVMField.Type.OFFSET) @Stable public int instanceKlassFieldsOffset;
- @HotSpotVMField(name = "InstanceKlass::_vtable_len", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int instanceKlassVtableLengthOffset;
+ @HotSpotVMField(name = "CompilerToVM::Data::InstanceKlass_vtable_start_offset", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int instanceKlassVtableStartOffset;
+ @HotSpotVMField(name = "CompilerToVM::Data::InstanceKlass_vtable_length_offset", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int instanceKlassVtableLengthOffset;
@HotSpotVMConstant(name = "InstanceKlass::linked") @Stable public int instanceKlassStateLinked;
@HotSpotVMConstant(name = "InstanceKlass::fully_initialized") @Stable public int instanceKlassStateFullyInitialized;
@@ -1063,12 +1040,7 @@ public class HotSpotVMConfig {
* See {@code InstanceKlass::vtable_start_offset()}.
*/
public final int instanceKlassVtableStartOffset() {
- return roundUp(instanceKlassSize, heapWordSize);
- }
-
- // TODO use CodeUtil method once it's moved from NumUtil
- private static int roundUp(int number, int mod) {
- return ((number + mod - 1) / mod) * mod;
+ return instanceKlassVtableStartOffset * heapWordSize;
}
@HotSpotVMType(name = "arrayOopDesc", get = HotSpotVMType.Type.SIZE) @Stable public int arrayOopDescSize;
@@ -1100,11 +1072,22 @@ public class HotSpotVMConfig {
@HotSpotVMConstant(name = "FIELDINFO_TAG_SIZE") @Stable public int fieldInfoTagSize;
+ @HotSpotVMConstant(name = "JVM_ACC_MONITOR_MATCH") @Stable public int jvmAccMonitorMatch;
+ @HotSpotVMConstant(name = "JVM_ACC_HAS_MONITOR_BYTECODES") @Stable public int jvmAccHasMonitorBytecodes;
+ @HotSpotVMConstant(name = "JVM_ACC_HAS_FINALIZER") @Stable public int jvmAccHasFinalizer;
@HotSpotVMConstant(name = "JVM_ACC_FIELD_INTERNAL") @Stable public int jvmAccFieldInternal;
@HotSpotVMConstant(name = "JVM_ACC_FIELD_STABLE") @Stable public int jvmAccFieldStable;
@HotSpotVMConstant(name = "JVM_ACC_FIELD_HAS_GENERIC_SIGNATURE") @Stable public int jvmAccFieldHasGenericSignature;
@HotSpotVMConstant(name = "JVM_ACC_WRITTEN_FLAGS") @Stable public int jvmAccWrittenFlags;
+ // Modifier.SYNTHETIC is not public so we get it via vmStructs.
+ @HotSpotVMConstant(name = "JVM_ACC_SYNTHETIC") @Stable public int jvmAccSynthetic;
+
+ /**
+ * @see HotSpotResolvedObjectTypeImpl#createField
+ */
+ @HotSpotVMConstant(name = "JVM_RECOGNIZED_FIELD_MODIFIERS") @Stable public int recognizedFieldModifiers;
+
@HotSpotVMField(name = "Thread::_tlab", type = "ThreadLocalAllocBuffer", get = HotSpotVMField.Type.OFFSET) @Stable public int threadTlabOffset;
@HotSpotVMField(name = "JavaThread::_anchor", type = "JavaFrameAnchor", get = HotSpotVMField.Type.OFFSET) @Stable public int javaThreadAnchorOffset;
@@ -1202,16 +1185,17 @@ public class HotSpotVMConfig {
@HotSpotVMField(name = "OSThread::_interrupted", type = "jint", get = HotSpotVMField.Type.OFFSET) @Stable public int osThreadInterruptedOffset;
- @HotSpotVMConstant(name = "markOopDesc::unlocked_value") @Stable public int unlockedMask;
+ @HotSpotVMConstant(name = "markOopDesc::hash_shift") @Stable public long markOopDescHashShift;
+
@HotSpotVMConstant(name = "markOopDesc::biased_lock_mask_in_place") @Stable public int biasedLockMaskInPlace;
@HotSpotVMConstant(name = "markOopDesc::age_mask_in_place") @Stable public int ageMaskInPlace;
@HotSpotVMConstant(name = "markOopDesc::epoch_mask_in_place") @Stable public int epochMaskInPlace;
-
- @HotSpotVMConstant(name = "markOopDesc::hash_shift") @Stable public long markOopDescHashShift;
@HotSpotVMConstant(name = "markOopDesc::hash_mask") @Stable public long markOopDescHashMask;
@HotSpotVMConstant(name = "markOopDesc::hash_mask_in_place") @Stable public long markOopDescHashMaskInPlace;
+ @HotSpotVMConstant(name = "markOopDesc::unlocked_value") @Stable public int unlockedMask;
@HotSpotVMConstant(name = "markOopDesc::biased_lock_pattern") @Stable public int biasedLockPattern;
+
@HotSpotVMConstant(name = "markOopDesc::no_hash_in_place") @Stable public int markWordNoHashInPlace;
@HotSpotVMConstant(name = "markOopDesc::no_lock_in_place") @Stable public int markWordNoLockInPlace;
@@ -1247,6 +1231,11 @@ public class HotSpotVMConfig {
@HotSpotVMField(name = "Method::_flags", type = "u2", get = HotSpotVMField.Type.OFFSET) @Stable public int methodFlagsOffset;
@HotSpotVMField(name = "Method::_vtable_index", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int methodVtableIndexOffset;
+ @HotSpotVMField(name = "Method::_method_counters", type = "MethodCounters*", get = HotSpotVMField.Type.OFFSET) @Stable public int methodCountersOffset;
+ @HotSpotVMField(name = "Method::_method_data", type = "MethodData*", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataOffset;
+ @HotSpotVMField(name = "Method::_from_compiled_entry", type = "address", get = HotSpotVMField.Type.OFFSET) @Stable public int methodCompiledEntryOffset;
+ @HotSpotVMField(name = "Method::_code", type = "nmethod*", get = HotSpotVMField.Type.OFFSET) @Stable public int methodCodeOffset;
+
@HotSpotVMConstant(name = "Method::_jfr_towrite") @Stable public int methodFlagsJfrTowrite;
@HotSpotVMConstant(name = "Method::_caller_sensitive") @Stable public int methodFlagsCallerSensitive;
@HotSpotVMConstant(name = "Method::_force_inline") @Stable public int methodFlagsForceInline;
@@ -1255,16 +1244,29 @@ public class HotSpotVMConfig {
@HotSpotVMConstant(name = "Method::nonvirtual_vtable_index") @Stable public int nonvirtualVtableIndex;
@HotSpotVMConstant(name = "Method::invalid_vtable_index") @Stable public int invalidVtableIndex;
+ @HotSpotVMField(name = "MethodCounters::_invocation_counter", type = "InvocationCounter", get = HotSpotVMField.Type.OFFSET) @Stable public int invocationCounterOffset;
+ @HotSpotVMField(name = "MethodCounters::_backedge_counter", type = "InvocationCounter", get = HotSpotVMField.Type.OFFSET) @Stable public int backedgeCounterOffset;
+ @HotSpotVMConstant(name = "InvocationCounter::count_increment") @Stable public int invocationCounterIncrement;
+ @HotSpotVMConstant(name = "InvocationCounter::count_shift") @Stable public int invocationCounterShift;
+
+ @HotSpotVMField(name = "MethodData::_size", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataSize;
+ @HotSpotVMField(name = "MethodData::_data_size", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataDataSize;
+ @HotSpotVMField(name = "MethodData::_data[0]", type = "intptr_t", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataOopDataOffset;
+ @HotSpotVMField(name = "MethodData::_trap_hist._array[0]", type = "u1", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataOopTrapHistoryOffset;
+ @HotSpotVMField(name = "MethodData::_jvmci_ir_size", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataIRSizeOffset;
+
+ @HotSpotVMField(name = "nmethod::_verified_entry_point", type = "address", get = HotSpotVMField.Type.OFFSET) @Stable public int nmethodEntryOffset;
+ @HotSpotVMField(name = "nmethod::_comp_level", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int nmethodCompLevelOffset;
+
+ @HotSpotVMConstant(name = "CompLevel_full_optimization") @Stable public int compilationLevelFullOptimization;
+
@HotSpotVMConstant(name = "InvocationEntryBci") @Stable public int invocationEntryBci;
@HotSpotVMField(name = "JVMCIEnv::_task", type = "CompileTask*", get = HotSpotVMField.Type.OFFSET) @Stable public int jvmciEnvTaskOffset;
@HotSpotVMField(name = "JVMCIEnv::_jvmti_can_hotswap_or_post_breakpoint", type = "bool", get = HotSpotVMField.Type.OFFSET) @Stable public int jvmciEnvJvmtiCanHotswapOrPostBreakpointOffset;
@HotSpotVMField(name = "CompileTask::_num_inlined_bytecodes", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int compileTaskNumInlinedBytecodesOffset;
- /**
- * See {@code Method::extra_stack_entries()}.
- */
- @HotSpotVMConstant(name = "Method::extra_stack_entries_for_jsr292") @Stable public int extraStackEntries;
+ @HotSpotVMField(name = "CompilerToVM::Data::Method_extra_stack_entries", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int extraStackEntries;
@HotSpotVMField(name = "ConstMethod::_constants", type = "ConstantPool*", get = HotSpotVMField.Type.OFFSET) @Stable public int constMethodConstantsOffset;
@HotSpotVMField(name = "ConstMethod::_flags", type = "u2", get = HotSpotVMField.Type.OFFSET) @Stable public int constMethodFlagsOffset;
@@ -1325,72 +1327,39 @@ public class HotSpotVMConfig {
@HotSpotVMConstant(name = "HeapWordSize") @Stable public int heapWordSize;
@HotSpotVMType(name = "Symbol*", get = HotSpotVMType.Type.SIZE) @Stable public int symbolPointerSize;
- @HotSpotVMField(name = "Symbol::_length", type = "unsigned short", get = HotSpotVMField.Type.OFFSET) @Stable public int symbolLengthOffset;
- @HotSpotVMField(name = "Symbol::_body[0]", type = "jbyte", get = HotSpotVMField.Type.OFFSET) @Stable public int symbolBodyOffset;
@HotSpotVMField(name = "vmSymbols::_symbols[0]", type = "Symbol*", get = HotSpotVMField.Type.ADDRESS) @Stable public long vmSymbolsSymbols;
@HotSpotVMConstant(name = "vmSymbols::FIRST_SID") @Stable public int vmSymbolsFirstSID;
@HotSpotVMConstant(name = "vmSymbols::SID_LIMIT") @Stable public int vmSymbolsSIDLimit;
- @HotSpotVMConstant(name = "JVM_ACC_HAS_FINALIZER") @Stable public int klassHasFinalizerFlag;
-
- // Modifier.SYNTHETIC is not public so we get it via vmStructs.
- @HotSpotVMConstant(name = "JVM_ACC_SYNTHETIC") @Stable public int syntheticFlag;
-
- /**
- * @see HotSpotResolvedObjectTypeImpl#createField
- */
- @HotSpotVMConstant(name = "JVM_RECOGNIZED_FIELD_MODIFIERS") @Stable public int recognizedFieldModifiers;
-
/**
* Bit pattern that represents a non-oop. Neither the high bits nor the low bits of this value
* are allowed to look like (respectively) the high or low bits of a real oop.
*/
- @HotSpotVMField(name = "Universe::_non_oop_bits", type = "intptr_t", get = HotSpotVMField.Type.VALUE) @Stable public long nonOopBits;
+ @HotSpotVMField(name = "CompilerToVM::Data::Universe_non_oop_bits", type = "void*", get = HotSpotVMField.Type.VALUE) @Stable public long nonOopBits;
@HotSpotVMField(name = "StubRoutines::_verify_oop_count", type = "jint", get = HotSpotVMField.Type.ADDRESS) @Stable public long verifyOopCounterAddress;
- @HotSpotVMField(name = "Universe::_verify_oop_mask", type = "uintptr_t", get = HotSpotVMField.Type.VALUE) @Stable public long verifyOopMask;
- @HotSpotVMField(name = "Universe::_verify_oop_bits", type = "uintptr_t", get = HotSpotVMField.Type.VALUE) @Stable public long verifyOopBits;
- @HotSpotVMField(name = "Universe::_base_vtable_size", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int universeBaseVtableSize;
+ @HotSpotVMField(name = "CompilerToVM::Data::Universe_verify_oop_mask", type = "uintptr_t", get = HotSpotVMField.Type.VALUE) @Stable public long verifyOopMask;
+ @HotSpotVMField(name = "CompilerToVM::Data::Universe_verify_oop_bits", type = "uintptr_t", get = HotSpotVMField.Type.VALUE) @Stable public long verifyOopBits;
+ @HotSpotVMField(name = "CompilerToVM::Data::Universe_base_vtable_size", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int universeBaseVtableSize;
public final int baseVtableLength() {
return universeBaseVtableSize / vtableEntrySize;
}
- @HotSpotVMField(name = "CollectedHeap::_barrier_set", type = "BarrierSet*", get = HotSpotVMField.Type.OFFSET) @Stable public int collectedHeapBarrierSetOffset;
-
@HotSpotVMField(name = "HeapRegion::LogOfHRGrainBytes", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int logOfHRGrainBytes;
- @HotSpotVMField(name = "BarrierSet::_fake_rtti", type = "BarrierSet::FakeRtti", get = HotSpotVMField.Type.OFFSET) @Stable private int barrierSetFakeRttiOffset;
- @HotSpotVMConstant(name = "BarrierSet::CardTableModRef") @Stable public int barrierSetCardTableModRef;
- @HotSpotVMConstant(name = "BarrierSet::CardTableForRS") @Stable public int barrierSetCardTableForRS;
- @HotSpotVMConstant(name = "BarrierSet::CardTableExtension") @Stable public int barrierSetCardTableExtension;
- @HotSpotVMConstant(name = "BarrierSet::G1SATBCT") @Stable public int barrierSetG1SATBCT;
- @HotSpotVMConstant(name = "BarrierSet::G1SATBCTLogging") @Stable public int barrierSetG1SATBCTLogging;
- @HotSpotVMConstant(name = "BarrierSet::ModRef") @Stable public int barrierSetModRef;
-
- @HotSpotVMField(name = "BarrierSet::FakeRtti::_concrete_tag", type = "BarrierSet::Name", get = HotSpotVMField.Type.OFFSET) @Stable private int fakeRttiConcreteTagOffset;
-
- @HotSpotVMField(name = "CardTableModRefBS::byte_map_base", type = "jbyte*", get = HotSpotVMField.Type.OFFSET) @Stable private int cardTableModRefBSByteMapBaseOffset;
- @HotSpotVMConstant(name = "CardTableModRefBS::card_shift") @Stable public int cardTableModRefBSCardShift;
-
@HotSpotVMConstant(name = "CardTableModRefBS::dirty_card") @Stable public byte dirtyCardValue;
@HotSpotVMConstant(name = "G1SATBCardTableModRefBS::g1_young_gen") @Stable public byte g1YoungCardValue;
- private final long cardtableStartAddress;
- private final int cardtableShift;
+ @HotSpotVMField(name = "CompilerToVM::Data::cardtable_start_address", type = "jbyte*", get = HotSpotVMField.Type.VALUE) @Stable private long cardtableStartAddress;
+ @HotSpotVMField(name = "CompilerToVM::Data::cardtable_shift", type = "int", get = HotSpotVMField.Type.VALUE) @Stable private int cardtableShift;
public long cardtableStartAddress() {
- if (cardtableStartAddress == -1) {
- throw JVMCIError.shouldNotReachHere();
- }
return cardtableStartAddress;
}
public int cardtableShift() {
- if (cardtableShift == -1) {
- throw JVMCIError.shouldNotReachHere();
- }
return cardtableShift;
}
@@ -1421,34 +1390,12 @@ public class HotSpotVMConfig {
@HotSpotVMField(name = "java_lang_Class::_klass_offset", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int klassOffset;
@HotSpotVMField(name = "java_lang_Class::_array_klass_offset", type = "int", get = HotSpotVMField.Type.VALUE) @Stable public int arrayKlassOffset;
- @HotSpotVMField(name = "Method::_method_counters", type = "MethodCounters*", get = HotSpotVMField.Type.OFFSET) @Stable public int methodCountersOffset;
- @HotSpotVMField(name = "Method::_method_data", type = "MethodData*", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataOffset;
- @HotSpotVMField(name = "Method::_from_compiled_entry", type = "address", get = HotSpotVMField.Type.OFFSET) @Stable public int methodCompiledEntryOffset;
- @HotSpotVMField(name = "Method::_code", type = "nmethod*", get = HotSpotVMField.Type.OFFSET) @Stable public int methodCodeOffset;
-
- @HotSpotVMField(name = "MethodCounters::_invocation_counter", type = "InvocationCounter", get = HotSpotVMField.Type.OFFSET) @Stable public int invocationCounterOffset;
- @HotSpotVMField(name = "MethodCounters::_backedge_counter", type = "InvocationCounter", get = HotSpotVMField.Type.OFFSET) @Stable public int backedgeCounterOffset;
- @HotSpotVMConstant(name = "InvocationCounter::count_increment") @Stable public int invocationCounterIncrement;
- @HotSpotVMConstant(name = "InvocationCounter::count_shift") @Stable public int invocationCounterShift;
-
- @HotSpotVMField(name = "MethodData::_size", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataSize;
- @HotSpotVMField(name = "MethodData::_data_size", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataDataSize;
- @HotSpotVMField(name = "MethodData::_data[0]", type = "intptr_t", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataOopDataOffset;
- @HotSpotVMField(name = "MethodData::_trap_hist._array[0]", type = "u1", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataOopTrapHistoryOffset;
- @HotSpotVMField(name = "MethodData::_jvmci_ir_size", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int methodDataIRSizeOffset;
-
- @HotSpotVMField(name = "nmethod::_verified_entry_point", type = "address", get = HotSpotVMField.Type.OFFSET) @Stable public int nmethodEntryOffset;
- @HotSpotVMField(name = "nmethod::_comp_level", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable public int nmethodCompLevelOffset;
-
- @HotSpotVMConstant(name = "CompLevel_full_optimization") @Stable public int compilationLevelFullOptimization;
-
@HotSpotVMType(name = "BasicLock", get = HotSpotVMType.Type.SIZE) @Stable public int basicLockSize;
@HotSpotVMField(name = "BasicLock::_displaced_header", type = "markOop", get = HotSpotVMField.Type.OFFSET) @Stable public int basicLockDisplacedHeaderOffset;
@HotSpotVMField(name = "Thread::_allocated_bytes", type = "jlong", get = HotSpotVMField.Type.OFFSET) @Stable public int threadAllocatedBytesOffset;
@HotSpotVMFlag(name = "TLABWasteIncrement") @Stable public int tlabRefillWasteIncrement;
- @HotSpotVMManual(name = "ThreadLocalAllocBuffer::alignment_reserve()") @Stable public int tlabAlignmentReserve;
@HotSpotVMField(name = "ThreadLocalAllocBuffer::_start", type = "HeapWord*", get = HotSpotVMField.Type.OFFSET) @Stable private int threadLocalAllocBufferStartOffset;
@HotSpotVMField(name = "ThreadLocalAllocBuffer::_end", type = "HeapWord*", get = HotSpotVMField.Type.OFFSET) @Stable private int threadLocalAllocBufferEndOffset;
@@ -1496,22 +1443,14 @@ public class HotSpotVMConfig {
return threadTlabOffset + threadLocalAllocBufferPfTopOffset;
}
- /**
- * See: {@code ThreadLocalAllocBuffer::end_reserve()}.
- */
- public final int threadLocalAllocBufferEndReserve() {
- final int typeSizeInBytes = roundUp(arrayOopDescLengthOffset() + Integer.BYTES, heapWordSize);
- // T_INT arrays need not be 8 byte aligned.
- final int reserveSize = typeSizeInBytes / heapWordSize;
- return Integer.max(reserveSize, abstractVmVersionReserveForAllocationPrefetch);
- }
+ @HotSpotVMField(name = "CompilerToVM::Data::ThreadLocalAllocBuffer_alignment_reserve", type = "size_t", get = HotSpotVMField.Type.VALUE) @Stable public int tlabAlignmentReserve;
@HotSpotVMFlag(name = "TLABStats") @Stable public boolean tlabStats;
// FIXME This is only temporary until the GC code is changed.
- @HotSpotVMField(name = "CompilerToVM::_supports_inline_contig_alloc", type = "bool", get = HotSpotVMField.Type.VALUE) @Stable public boolean inlineContiguousAllocationSupported;
- @HotSpotVMField(name = "CompilerToVM::_heap_end_addr", type = "HeapWord**", get = HotSpotVMField.Type.VALUE) @Stable public long heapEndAddress;
- @HotSpotVMField(name = "CompilerToVM::_heap_top_addr", type = "HeapWord**", get = HotSpotVMField.Type.VALUE) @Stable public long heapTopAddress;
+ @HotSpotVMField(name = "CompilerToVM::Data::_supports_inline_contig_alloc", type = "bool", get = HotSpotVMField.Type.VALUE) @Stable public boolean inlineContiguousAllocationSupported;
+ @HotSpotVMField(name = "CompilerToVM::Data::_heap_end_addr", type = "HeapWord**", get = HotSpotVMField.Type.VALUE) @Stable public long heapEndAddress;
+ @HotSpotVMField(name = "CompilerToVM::Data::_heap_top_addr", type = "HeapWord**", get = HotSpotVMField.Type.VALUE) @Stable public long heapTopAddress;
/**
* The DataLayout header size is the same as the cell size.
@@ -1542,19 +1481,11 @@ public class HotSpotVMConfig {
@HotSpotVMFlag(name = "TypeProfileWidth") @Stable public int typeProfileWidth;
@HotSpotVMFlag(name = "MethodProfileWidth") @Stable public int methodProfileWidth;
- @HotSpotVMField(name = "CodeBlob::_code_offset", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable private int codeBlobCodeOffsetOffset;
- @HotSpotVMField(name = "DeoptimizationBlob::_unpack_offset", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable private int deoptimizationBlobUnpackOffsetOffset;
- @HotSpotVMField(name = "DeoptimizationBlob::_uncommon_trap_offset", type = "int", get = HotSpotVMField.Type.OFFSET) @Stable private int deoptimizationBlobUncommonTrapOffsetOffset;
+ @HotSpotVMField(name = "CompilerToVM::Data::SharedRuntime_ic_miss_stub", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long inlineCacheMissStub;
+ @HotSpotVMField(name = "CompilerToVM::Data::SharedRuntime_handle_wrong_method_stub", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long handleWrongMethodStub;
- @HotSpotVMField(name = "SharedRuntime::_ic_miss_blob", type = "RuntimeStub*", get = HotSpotVMField.Type.VALUE) @Stable private long inlineCacheMissBlob;
- @HotSpotVMField(name = "SharedRuntime::_wrong_method_blob", type = "RuntimeStub*", get = HotSpotVMField.Type.VALUE) @Stable private long wrongMethodBlob;
- @HotSpotVMField(name = "SharedRuntime::_deopt_blob", type = "DeoptimizationBlob*", get = HotSpotVMField.Type.VALUE) @Stable private long deoptBlob;
-
- @HotSpotVMManual(name = "SharedRuntime::get_ic_miss_stub()") public final long inlineCacheMissStub;
- @HotSpotVMManual(name = "SharedRuntime::get_handle_wrong_method_stub()") public final long handleWrongMethodStub;
-
- @HotSpotVMManual(name = "SharedRuntime::deopt_blob()->unpack()") public final long handleDeoptStub;
- @HotSpotVMManual(name = "SharedRuntime::deopt_blob()->uncommon_trap()") public final long uncommonTrapStub;
+ @HotSpotVMField(name = "CompilerToVM::Data::SharedRuntime_deopt_blob_unpack", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long handleDeoptStub;
+ @HotSpotVMField(name = "CompilerToVM::Data::SharedRuntime_deopt_blob_uncommon_trap", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long uncommonTrapStub;
@HotSpotVMField(name = "CodeCache::_low_bound", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long codeCacheLowBound;
@HotSpotVMField(name = "CodeCache::_high_bound", type = "address", get = HotSpotVMField.Type.VALUE) @Stable public long codeCacheHighBound;
@@ -1717,9 +1648,6 @@ public class HotSpotVMConfig {
return "unknown";
}
- @HotSpotVMConstant(name = "CompilerToVM::KLASS_TAG") @Stable public int compilerToVMKlassTag;
- @HotSpotVMConstant(name = "CompilerToVM::SYMBOL_TAG") @Stable public int compilerToVMSymbolTag;
-
// Checkstyle: stop
@HotSpotVMConstant(name = "CodeInstaller::VERIFIED_ENTRY") @Stable public int MARKID_VERIFIED_ENTRY;
@HotSpotVMConstant(name = "CodeInstaller::UNVERIFIED_ENTRY") @Stable public int MARKID_UNVERIFIED_ENTRY;
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/Stable.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/Stable.java
index e386dc0ca77..f313238bf41 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/Stable.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/Stable.java
@@ -29,7 +29,7 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
- * This annotation functions as an alias for the java.lang.invoke.Stable annotation within JVMCI
+ * This annotation functions as an alias for the jdk.internal.vm.annotation.Stable annotation within JVMCI
* code. It is specially recognized during class file parsing in the same way as that annotation.
*/
@Target(ElementType.FIELD)
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.inittimer/src/jdk/vm/ci/inittimer/InitTimer.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.inittimer/src/jdk/vm/ci/inittimer/InitTimer.java
index 608285e7e92..921b537bfb1 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.inittimer/src/jdk/vm/ci/inittimer/InitTimer.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.inittimer/src/jdk/vm/ci/inittimer/InitTimer.java
@@ -22,6 +22,8 @@
*/
package jdk.vm.ci.inittimer;
+import java.util.concurrent.atomic.AtomicInteger;
+
/**
* A facility for timing a step in the runtime initialization sequence. This is independent from all
* other JVMCI code so as to not perturb the initialization sequence. It is enabled by setting the
@@ -32,18 +34,26 @@ public final class InitTimer implements AutoCloseable {
final long start;
private InitTimer(String name) {
+ int n = nesting.getAndIncrement();
+ if (n == 0) {
+ initializingThread = Thread.currentThread();
+ System.out.println("INITIALIZING THREAD: " + initializingThread);
+ } else {
+ assert Thread.currentThread() == initializingThread : Thread.currentThread() + " != " + initializingThread;
+ }
this.name = name;
this.start = System.currentTimeMillis();
- System.out.println("START: " + SPACES.substring(0, timerDepth * 2) + name);
- assert Thread.currentThread() == initializingThread : Thread.currentThread() + " != " + initializingThread;
- timerDepth++;
+ System.out.println("START: " + SPACES.substring(0, n * 2) + name);
}
@SuppressFBWarnings(value = "ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD", justification = "only the initializing thread accesses this field")
public void close() {
final long end = System.currentTimeMillis();
- timerDepth--;
- System.out.println(" DONE: " + SPACES.substring(0, timerDepth * 2) + name + " [" + (end - start) + " ms]");
+ int n = nesting.decrementAndGet();
+ System.out.println(" DONE: " + SPACES.substring(0, n * 2) + name + " [" + (end - start) + " ms]");
+ if (n == 0) {
+ initializingThread = null;
+ }
}
public static InitTimer timer(String name) {
@@ -59,19 +69,11 @@ public final class InitTimer implements AutoCloseable {
*/
private static final boolean ENABLED = Boolean.getBoolean("jvmci.inittimer") || Boolean.getBoolean("jvmci.runtime.TimeInit");
- public static int timerDepth = 0;
+ public static final AtomicInteger nesting = ENABLED ? new AtomicInteger() : null;
public static final String SPACES = " ";
/**
- * Used to assert the invariant that all initialization happens on the same thread.
+ * Used to assert the invariant that all related initialization happens on the same thread.
*/
- public static final Thread initializingThread;
- static {
- if (ENABLED) {
- initializingThread = Thread.currentThread();
- System.out.println("INITIALIZING THREAD: " + initializingThread);
- } else {
- initializingThread = null;
- }
- }
+ public static Thread initializingThread;
}
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ConstantReflectionProvider.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ConstantReflectionProvider.java
index 1db2b98c7ea..33cc2a27ebc 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ConstantReflectionProvider.java
+++ b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/ConstantReflectionProvider.java
@@ -80,29 +80,31 @@ public interface ConstantReflectionProvider {
* @return the constant value of this field or {@code null} if this field is not considered
* constant by the runtime
*/
- JavaConstant readConstantFieldValue(JavaField field, JavaConstant receiver);
+ JavaConstant readConstantFieldValue(ResolvedJavaField field, JavaConstant receiver);
/**
* Gets the current value of this field for a given object, if available.
*
* There is no guarantee that the same value will be returned by this method for a field unless
- * the field is considered to be {@linkplain #readConstantFieldValue(JavaField, JavaConstant)
- * constant} by the runtime.
+ * the field is considered to be
+ * {@linkplain #readConstantFieldValue(ResolvedJavaField, JavaConstant) constant} by the
+ * runtime.
*
* @param receiver object from which this field's value is to be read. This value is ignored if
* this field is static.
* @return the value of this field or {@code null} if the value is not available (e.g., because
* the field holder is not yet initialized).
*/
- JavaConstant readFieldValue(JavaField field, JavaConstant receiver);
+ JavaConstant readFieldValue(ResolvedJavaField field, JavaConstant receiver);
/**
* Gets the current value of this field for a given object, if available. Like
- * {@link #readFieldValue(JavaField, JavaConstant)} but treats array fields as stable.
+ * {@link #readFieldValue(ResolvedJavaField, JavaConstant)} but treats array fields as stable.
*
* There is no guarantee that the same value will be returned by this method for a field unless
- * the field is considered to be {@linkplain #readConstantFieldValue(JavaField, JavaConstant)
- * constant} by the runtime.
+ * the field is considered to be
+ * {@linkplain #readConstantFieldValue(ResolvedJavaField, JavaConstant) constant} by the
+ * runtime.
*
* @param receiver object from which this field's value is to be read. This value is ignored if
* this field is static.
@@ -110,7 +112,7 @@ public interface ConstantReflectionProvider {
* @return the value of this field or {@code null} if the value is not available (e.g., because
* the field holder is not yet initialized).
*/
- JavaConstant readStableFieldValue(JavaField field, JavaConstant receiver, boolean isDefaultStable);
+ JavaConstant readStableFieldValue(ResolvedJavaField field, JavaConstant receiver, boolean isDefaultStable);
/**
* Converts the given {@link JavaKind#isPrimitive() primitive} constant to a boxed
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options.processor/src/META-INF/services/javax.annotation.processing.Processor b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options.processor/src/META-INF/services/javax.annotation.processing.Processor
deleted file mode 100644
index 3aab30fa3c7..00000000000
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options.processor/src/META-INF/services/javax.annotation.processing.Processor
+++ /dev/null
@@ -1 +0,0 @@
-jdk.vm.ci.options.processor.OptionProcessor
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options.processor/src/jdk/vm/ci/options/processor/OptionProcessor.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options.processor/src/jdk/vm/ci/options/processor/OptionProcessor.java
deleted file mode 100644
index 95422c24135..00000000000
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options.processor/src/jdk/vm/ci/options/processor/OptionProcessor.java
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
- * Copyright (c) 2013, 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 jdk.vm.ci.options.processor;
-
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import javax.annotation.processing.AbstractProcessor;
-import javax.annotation.processing.Filer;
-import javax.annotation.processing.RoundEnvironment;
-import javax.annotation.processing.SupportedAnnotationTypes;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ElementKind;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.Name;
-import javax.lang.model.element.PackageElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.Elements;
-import javax.lang.model.util.Types;
-import javax.tools.Diagnostic.Kind;
-import javax.tools.JavaFileObject;
-
-import jdk.vm.ci.options.Option;
-import jdk.vm.ci.options.OptionDescriptor;
-import jdk.vm.ci.options.OptionDescriptors;
-import jdk.vm.ci.options.OptionValue;
-
-/**
- * Processes static fields annotated with {@link Option}. An {@link OptionDescriptors}
- * implementation is generated for each top level class containing at least one such field. The name
- * of the generated class for top level class {@code com.foo.Bar} is
- * {@code com.foo.Bar_OptionDescriptors}.
- */
-@SupportedAnnotationTypes({"jdk.vm.ci.options.Option"})
-public class OptionProcessor extends AbstractProcessor {
-
- @Override
- public SourceVersion getSupportedSourceVersion() {
- return SourceVersion.latest();
- }
-
- private final Set processed = new HashSet<>();
-
- private void processElement(Element element, OptionsInfo info) {
-
- if (!element.getModifiers().contains(Modifier.STATIC)) {
- processingEnv.getMessager().printMessage(Kind.ERROR, "Option field must be static", element);
- return;
- }
-
- Option annotation = element.getAnnotation(Option.class);
- assert annotation != null;
- assert element instanceof VariableElement;
- assert element.getKind() == ElementKind.FIELD;
- VariableElement field = (VariableElement) element;
- String fieldName = field.getSimpleName().toString();
-
- Elements elements = processingEnv.getElementUtils();
- Types types = processingEnv.getTypeUtils();
-
- TypeMirror fieldType = field.asType();
- if (fieldType.getKind() != TypeKind.DECLARED) {
- processingEnv.getMessager().printMessage(Kind.ERROR, "Option field must be of type " + OptionValue.class.getName(), element);
- return;
- }
- DeclaredType declaredFieldType = (DeclaredType) fieldType;
-
- TypeMirror optionValueType = elements.getTypeElement(OptionValue.class.getName()).asType();
- if (!types.isSubtype(fieldType, types.erasure(optionValueType))) {
- String msg = String.format("Option field type %s is not a subclass of %s", fieldType, optionValueType);
- processingEnv.getMessager().printMessage(Kind.ERROR, msg, element);
- return;
- }
-
- if (!field.getModifiers().contains(Modifier.STATIC)) {
- processingEnv.getMessager().printMessage(Kind.ERROR, "Option field must be static", element);
- return;
- }
-
- String help = annotation.help();
- if (help.length() != 0) {
- char firstChar = help.charAt(0);
- if (!Character.isUpperCase(firstChar)) {
- processingEnv.getMessager().printMessage(Kind.ERROR, "Option help text must start with upper case letter", element);
- return;
- }
- }
-
- String optionName = annotation.name();
- if (optionName.equals("")) {
- optionName = fieldName;
- }
-
- DeclaredType declaredOptionValueType = declaredFieldType;
- while (!types.isSameType(types.erasure(declaredOptionValueType), types.erasure(optionValueType))) {
- List directSupertypes = types.directSupertypes(declaredFieldType);
- assert !directSupertypes.isEmpty();
- declaredOptionValueType = (DeclaredType) directSupertypes.get(0);
- }
-
- assert !declaredOptionValueType.getTypeArguments().isEmpty();
- String optionType = declaredOptionValueType.getTypeArguments().get(0).toString();
- if (optionType.startsWith("java.lang.")) {
- optionType = optionType.substring("java.lang.".length());
- }
-
- Element enclosing = element.getEnclosingElement();
- String declaringClass = "";
- String separator = "";
- Set originatingElementsList = info.originatingElements;
- originatingElementsList.add(field);
- while (enclosing != null) {
- if (enclosing.getKind() == ElementKind.CLASS || enclosing.getKind() == ElementKind.INTERFACE) {
- if (enclosing.getModifiers().contains(Modifier.PRIVATE)) {
- String msg = String.format("Option field cannot be declared in a private %s %s", enclosing.getKind().name().toLowerCase(), enclosing);
- processingEnv.getMessager().printMessage(Kind.ERROR, msg, element);
- return;
- }
- originatingElementsList.add(enclosing);
- declaringClass = enclosing.getSimpleName() + separator + declaringClass;
- separator = ".";
- } else {
- assert enclosing.getKind() == ElementKind.PACKAGE;
- }
- enclosing = enclosing.getEnclosingElement();
- }
-
- info.options.add(new OptionInfo(optionName, help, optionType, declaringClass, field));
- }
-
- private void createFiles(OptionsInfo info) {
- String pkg = ((PackageElement) info.topDeclaringType.getEnclosingElement()).getQualifiedName().toString();
- Name topDeclaringClass = info.topDeclaringType.getSimpleName();
- Element[] originatingElements = info.originatingElements.toArray(new Element[info.originatingElements.size()]);
-
- createOptionsDescriptorsFile(info, pkg, topDeclaringClass, originatingElements);
- }
-
- private void createOptionsDescriptorsFile(OptionsInfo info, String pkg, Name topDeclaringClass, Element[] originatingElements) {
- String optionsClassName = topDeclaringClass + "_" + OptionDescriptors.class.getSimpleName();
-
- Filer filer = processingEnv.getFiler();
- try (PrintWriter out = createSourceFile(pkg, optionsClassName, filer, originatingElements)) {
-
- out.println("// CheckStyle: stop header check");
- out.println("// CheckStyle: stop line length check");
- out.println("// GENERATED CONTENT - DO NOT EDIT");
- out.println("// Source: " + topDeclaringClass + ".java");
- out.println("package " + pkg + ";");
- out.println("");
- out.println("import java.util.*;");
- out.println("import " + OptionDescriptors.class.getPackage().getName() + ".*;");
- out.println("");
- out.println("public class " + optionsClassName + " implements " + OptionDescriptors.class.getSimpleName() + " {");
-
- String desc = OptionDescriptor.class.getSimpleName();
-
- boolean needPrivateFieldAccessor = false;
- int i = 0;
- Collections.sort(info.options);
-
- out.println(" @Override");
- out.println(" public OptionDescriptor get(String value) {");
- out.println(" // CheckStyle: stop line length check");
- if (info.options.size() == 1) {
- out.println(" if (value.equals(\"" + info.options.get(0).name + "\")) {");
- } else {
- out.println(" switch (value) {");
- }
- for (OptionInfo option : info.options) {
- String name = option.name;
- String optionValue;
- if (option.field.getModifiers().contains(Modifier.PRIVATE)) {
- needPrivateFieldAccessor = true;
- optionValue = "field(" + option.declaringClass + ".class, \"" + option.field.getSimpleName() + "\")";
- } else {
- optionValue = option.declaringClass + "." + option.field.getSimpleName();
- }
- String type = option.type;
- String help = option.help;
- String declaringClass = option.declaringClass;
- Name fieldName = option.field.getSimpleName();
- if (info.options.size() == 1) {
- out.printf(" return %s.create(\"%s\", %s.class, \"%s\", %s.class, \"%s\", %s);\n", desc, name, type, help, declaringClass, fieldName, optionValue);
- } else {
- out.printf(" case \"" + name + "\": return %s.create(\"%s\", %s.class, \"%s\", %s.class, \"%s\", %s);\n", desc, name, type, help, declaringClass, fieldName, optionValue);
- }
- }
- out.println(" }");
- out.println(" // CheckStyle: resume line length check");
- out.println(" return null;");
- out.println(" }");
- out.println();
- out.println(" @Override");
- out.println(" public Iterator<" + desc + "> iterator() {");
- out.println(" // CheckStyle: stop line length check");
- out.println(" List<" + desc + "> options = Arrays.asList(");
- for (OptionInfo option : info.options) {
- String optionValue;
- if (option.field.getModifiers().contains(Modifier.PRIVATE)) {
- needPrivateFieldAccessor = true;
- optionValue = "field(" + option.declaringClass + ".class, \"" + option.field.getSimpleName() + "\")";
- } else {
- optionValue = option.declaringClass + "." + option.field.getSimpleName();
- }
- String name = option.name;
- String type = option.type;
- String help = option.help;
- String declaringClass = option.declaringClass;
- Name fieldName = option.field.getSimpleName();
- String comma = i == info.options.size() - 1 ? "" : ",";
- out.printf(" %s.create(\"%s\", %s.class, \"%s\", %s.class, \"%s\", %s)%s\n", desc, name, type, help, declaringClass, fieldName, optionValue, comma);
- i++;
- }
- out.println(" );");
- out.println(" // CheckStyle: resume line length check");
- out.println(" return options.iterator();");
- out.println(" }");
- if (needPrivateFieldAccessor) {
- out.println(" private static " + OptionValue.class.getSimpleName() + " field(Class declaringClass, String fieldName) {");
- out.println(" try {");
- out.println(" java.lang.reflect.Field field = declaringClass.getDeclaredField(fieldName);");
- out.println(" field.setAccessible(true);");
- out.println(" return (" + OptionValue.class.getSimpleName() + ") field.get(null);");
- out.println(" } catch (Exception e) {");
- out.println(" throw (InternalError) new InternalError().initCause(e);");
- out.println(" }");
- out.println(" }");
- }
- out.println("}");
- }
- }
-
- protected PrintWriter createSourceFile(String pkg, String relativeName, Filer filer, Element... originatingElements) {
- try {
- // Ensure Unix line endings to comply with code style guide checked by Checkstyle
- JavaFileObject sourceFile = filer.createSourceFile(pkg + "." + relativeName, originatingElements);
- return new PrintWriter(sourceFile.openWriter()) {
-
- @Override
- public void println() {
- print("\n");
- }
- };
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
-
- static class OptionInfo implements Comparable {
-
- final String name;
- final String help;
- final String type;
- final String declaringClass;
- final VariableElement field;
-
- public OptionInfo(String name, String help, String type, String declaringClass, VariableElement field) {
- this.name = name;
- this.help = help;
- this.type = type;
- this.declaringClass = declaringClass;
- this.field = field;
- }
-
- @Override
- public int compareTo(OptionInfo other) {
- return name.compareTo(other.name);
- }
-
- @Override
- public String toString() {
- return declaringClass + "." + field;
- }
- }
-
- static class OptionsInfo {
-
- final Element topDeclaringType;
- final List options = new ArrayList<>();
- final Set originatingElements = new HashSet<>();
-
- public OptionsInfo(Element topDeclaringType) {
- this.topDeclaringType = topDeclaringType;
- }
- }
-
- private static Element topDeclaringType(Element element) {
- Element enclosing = element.getEnclosingElement();
- if (enclosing == null || enclosing.getKind() == ElementKind.PACKAGE) {
- assert element.getKind() == ElementKind.CLASS || element.getKind() == ElementKind.INTERFACE;
- return element;
- }
- return topDeclaringType(enclosing);
- }
-
- @Override
- public boolean process(Set annotations, RoundEnvironment roundEnv) {
- if (roundEnv.processingOver()) {
- return true;
- }
-
- Map map = new HashMap<>();
- for (Element element : roundEnv.getElementsAnnotatedWith(Option.class)) {
- if (!processed.contains(element)) {
- processed.add(element);
- Element topDeclaringType = topDeclaringType(element);
- OptionsInfo options = map.get(topDeclaringType);
- if (options == null) {
- options = new OptionsInfo(topDeclaringType);
- map.put(topDeclaringType, options);
- }
- processElement(element, options);
- }
- }
-
- boolean ok = true;
- Map uniqueness = new HashMap<>();
- for (OptionsInfo info : map.values()) {
- for (OptionInfo option : info.options) {
- OptionInfo conflict = uniqueness.put(option.name, option);
- if (conflict != null) {
- processingEnv.getMessager().printMessage(Kind.ERROR, "Duplicate option names for " + option + " and " + conflict, option.field);
- ok = false;
- }
- }
- }
-
- if (ok) {
- for (OptionsInfo info : map.values()) {
- createFiles(info);
- }
- }
-
- return true;
- }
-}
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/NestedBooleanOptionValue.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/NestedBooleanOptionValue.java
deleted file mode 100644
index 804603814f1..00000000000
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/NestedBooleanOptionValue.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * 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 jdk.vm.ci.options;
-
-/**
- * A nested Boolean {@link OptionValue} that can be overridden by a {@link #masterOption master
- * option}.
- *
- *
If the option is present on the command line the specified value is used.
- * Otherwise {@link #getValue()} depends on the {@link #masterOption} and evaluates as follows:
- *
- * If {@link #masterOption} is set, this value equals to {@link #initialValue}.
- * Otherwise, if {@link #masterOption} is {@code false}, this option is {@code false}.
- */
-public class NestedBooleanOptionValue extends OptionValue {
- private final OptionValue masterOption;
- private final Boolean initialValue;
-
- public NestedBooleanOptionValue(OptionValue masterOption, Boolean initialValue) {
- super(null);
- this.masterOption = masterOption;
- this.initialValue = initialValue;
- }
-
- public OptionValue getMasterOption() {
- return masterOption;
- }
-
- @Override
- public Boolean getValue() {
- Boolean v = super.getValue();
- if (v == null) {
- return initialValue && masterOption.getValue();
- }
- return v;
- }
-
-}
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionDescriptor.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionDescriptor.java
deleted file mode 100644
index b0bde8a71e0..00000000000
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionDescriptor.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (c) 2013, 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 jdk.vm.ci.options;
-
-/**
- * Describes the attributes of a static field {@linkplain Option option} and provides access to its
- * {@linkplain OptionValue value}.
- */
-public final class OptionDescriptor {
-
- protected final String name;
- protected final Class type;
- protected final String help;
- protected final OptionValue option;
- protected final Class declaringClass;
- protected final String fieldName;
-
- public static OptionDescriptor create(String name, Class type, String help, Class declaringClass, String fieldName, OptionValue option) {
- OptionDescriptor result = option.getDescriptor();
- if (result == null) {
- result = new OptionDescriptor(name, type, help, declaringClass, fieldName, option);
- option.setDescriptor(result);
- }
- assert result.name.equals(name) && result.type == type && result.declaringClass == declaringClass && result.fieldName.equals(fieldName) && result.option == option;
- return result;
- }
-
- private OptionDescriptor(String name, Class type, String help, Class declaringClass, String fieldName, OptionValue option) {
- this.name = name;
- this.type = type;
- this.help = help;
- this.option = option;
- this.declaringClass = declaringClass;
- this.fieldName = fieldName;
- assert !type.isPrimitive() : "must used boxed type instead of " + type;
- }
-
- /**
- * Gets the type of values stored in the option. This will be the boxed type for a primitive
- * option.
- */
- public Class getType() {
- return type;
- }
-
- /**
- * Gets a descriptive help message for the option.
- */
- public String getHelp() {
- return help;
- }
-
- /**
- * Gets the name of the option. It's up to the client of this object how to use the name to get
- * a user specified value for the option from the environment.
- */
- public String getName() {
- return name;
- }
-
- /**
- * Gets the boxed option value.
- */
- public OptionValue getOptionValue() {
- return option;
- }
-
- public Class getDeclaringClass() {
- return declaringClass;
- }
-
- public String getFieldName() {
- return fieldName;
- }
-
- /**
- * Gets a description of the location where this option is stored.
- */
- public String getLocation() {
- return getDeclaringClass().getName() + "." + getFieldName();
- }
-}
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionValue.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionValue.java
deleted file mode 100644
index 6abcc91d936..00000000000
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionValue.java
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- * Copyright (c) 2013, 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 jdk.vm.ci.options;
-
-import java.io.PrintStream;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
-
-/**
- * An option value.
- */
-public class OptionValue {
- /**
- * Temporarily changes the value for an option. The {@linkplain OptionValue#getValue() value} of
- * {@code option} is set to {@code value} until {@link OverrideScope#close()} is called on the
- * object returned by this method.
- *
- * Since the returned object is {@link AutoCloseable} the try-with-resource construct can be
- * used:
- *
- *
- * try (OverrideScope s = OptionValue.override(myOption, myValue) {
- * // code that depends on myOption == myValue
- * }
- *
- */
- public static OverrideScope override(OptionValue option, Object value) {
- OverrideScope current = getOverrideScope();
- if (current == null) {
- if (!value.equals(option.getValue())) {
- return new SingleOverrideScope(option, value);
- }
- Map, Object> overrides = Collections.emptyMap();
- return new MultipleOverridesScope(current, overrides);
- }
- return new MultipleOverridesScope(current, option, value);
- }
-
- /**
- * Temporarily changes the values for a set of options. The {@linkplain OptionValue#getValue()
- * value} of each {@code option} in {@code overrides} is set to the corresponding {@code value}
- * in {@code overrides} until {@link OverrideScope#close()} is called on the object returned by
- * this method.
- *
- * Since the returned object is {@link AutoCloseable} the try-with-resource construct can be
- * used:
- *
- *
- * Map<OptionValue, Object> overrides = new HashMap<>();
- * overrides.put(myOption1, myValue1);
- * overrides.put(myOption2, myValue2);
- * try (OverrideScope s = OptionValue.override(overrides) {
- * // code that depends on myOption == myValue
- * }
- *
- */
- public static OverrideScope override(Map, Object> overrides) {
- OverrideScope current = getOverrideScope();
- if (current == null && overrides.size() == 1) {
- Entry, Object> single = overrides.entrySet().iterator().next();
- OptionValue option = single.getKey();
- Object overrideValue = single.getValue();
- if (!overrideValue.equals(option.getValue())) {
- return new SingleOverrideScope(option, overrideValue);
- }
- }
- return new MultipleOverridesScope(current, overrides);
- }
-
- /**
- * Temporarily changes the values for a set of options. The {@linkplain OptionValue#getValue()
- * value} of each {@code option} in {@code overrides} is set to the corresponding {@code value}
- * in {@code overrides} until {@link OverrideScope#close()} is called on the object returned by
- * this method.
- *
- * Since the returned object is {@link AutoCloseable} the try-with-resource construct can be
- * used:
- *
- *
- * try (OverrideScope s = OptionValue.override(myOption1, myValue1, myOption2, myValue2) {
- * // code that depends on myOption == myValue
- * }
- *
- *
- * @param overrides overrides in the form {@code [option1, override1, option2, override2, ...]}
- */
- public static OverrideScope override(Object... overrides) {
- OverrideScope current = getOverrideScope();
- if (current == null && overrides.length == 2) {
- OptionValue option = (OptionValue) overrides[0];
- Object overrideValue = overrides[1];
- if (!overrideValue.equals(option.getValue())) {
- return new SingleOverrideScope(option, overrideValue);
- }
- }
- Map, Object> map = Collections.emptyMap();
- for (int i = 0; i < overrides.length; i += 2) {
- OptionValue option = (OptionValue) overrides[i];
- Object overrideValue = overrides[i + 1];
- if (!overrideValue.equals(option.getValue())) {
- if (map.isEmpty()) {
- map = new HashMap<>();
- }
- map.put(option, overrideValue);
- }
- }
- return new MultipleOverridesScope(current, map);
- }
-
- private static final ThreadLocal overrideScopeTL = new ThreadLocal<>();
-
- protected static OverrideScope getOverrideScope() {
- return overrideScopeTL.get();
- }
-
- protected static void setOverrideScope(OverrideScope overrideScope) {
- overrideScopeTL.set(overrideScope);
- }
-
- private T defaultValue;
-
- /**
- * The raw option value.
- */
- protected T value;
-
- private OptionDescriptor descriptor;
-
- private long reads;
- private OptionValue next;
- private static OptionValue head;
-
- private static final boolean ShowReadsHistogram = Boolean.getBoolean("jvmci.showOptionValueReadsHistogram");
-
- private static void addToHistogram(OptionValue option) {
- if (ShowReadsHistogram) {
- synchronized (OptionValue.class) {
- option.next = head;
- head = option;
- }
- }
- }
-
- @SuppressWarnings("unchecked")
- public OptionValue(T value) {
- this.defaultValue = value;
- this.value = (T) DEFAULT;
- addToHistogram(this);
- }
-
- private static final Object DEFAULT = "DEFAULT";
- private static final Object UNINITIALIZED = "UNINITIALIZED";
-
- /**
- * Creates an uninitialized option value for a subclass that initializes itself
- * {@link #defaultValue() lazily}.
- */
- @SuppressWarnings("unchecked")
- protected OptionValue() {
- this.defaultValue = (T) UNINITIALIZED;
- this.value = (T) DEFAULT;
- addToHistogram(this);
- }
-
- /**
- * Lazy initialization of default value.
- */
- protected T defaultValue() {
- throw new InternalError("Option without a default value value must override defaultValue()");
- }
-
- /**
- * Sets the descriptor for this option.
- */
- public void setDescriptor(OptionDescriptor descriptor) {
- assert this.descriptor == null : "Overwriting existing descriptor";
- this.descriptor = descriptor;
- }
-
- /**
- * Returns the descriptor for this option, if it has been set by
- * {@link #setDescriptor(OptionDescriptor)}.
- */
- public OptionDescriptor getDescriptor() {
- return descriptor;
- }
-
- /**
- * Gets the name of this option. The name for an option value with a null
- * {@linkplain #setDescriptor(OptionDescriptor) descriptor} is the value of
- * {@link Object#toString()}.
- */
- public String getName() {
- return descriptor == null ? super.toString() : (descriptor.getDeclaringClass().getName() + "." + descriptor.getName());
- }
-
- @Override
- public String toString() {
- return getName() + "=" + getValue();
- }
-
- /**
- * The initial value specified in source code. The returned value is not affected by calls to
- * {@link #setValue(Object)} or registering {@link OverrideScope}s. Therefore, it is also not
- * affected by options set on the command line.
- */
- public T getDefaultValue() {
- if (defaultValue == UNINITIALIZED) {
- defaultValue = defaultValue();
- }
- return defaultValue;
- }
-
- /**
- * Returns true if the option has the same value that was set in the source code.
- */
- public boolean hasDefaultValue() {
- if (!(this instanceof StableOptionValue)) {
- getValue(); // ensure initialized
- }
- return value == DEFAULT || Objects.equals(value, getDefaultValue());
- }
-
- /**
- * Gets the value of this option.
- */
- public T getValue() {
- if (ShowReadsHistogram) {
- reads++;
- }
- if (!(this instanceof StableOptionValue)) {
- OverrideScope overrideScope = getOverrideScope();
- if (overrideScope != null) {
- T override = overrideScope.getOverride(this);
- if (override != null) {
- return override;
- }
- }
- }
- if (value != DEFAULT) {
- return value;
- } else {
- return getDefaultValue();
- }
- }
-
- /**
- * Gets the values of this option including overridden values.
- *
- * @param c the collection to which the values are added. If null, one is allocated.
- * @return the collection to which the values were added in order from most overridden to
- * current value
- */
- @SuppressWarnings("unchecked")
- public Collection getValues(Collection c) {
- Collection values = c == null ? new ArrayList<>() : c;
- if (!(this instanceof StableOptionValue)) {
- OverrideScope overrideScope = getOverrideScope();
- if (overrideScope != null) {
- overrideScope.getOverrides(this, (Collection) values);
- }
- }
- if (value != DEFAULT) {
- values.add(value);
- } else {
- values.add(getDefaultValue());
- }
- return values;
- }
-
- /**
- * Sets the value of this option.
- */
- @SuppressWarnings("unchecked")
- public void setValue(Object v) {
- this.value = (T) v;
- }
-
- /**
- * An object whose {@link #close()} method reverts the option value overriding initiated by
- * {@link OptionValue#override(OptionValue, Object)} or {@link OptionValue#override(Map)}.
- */
- public abstract static class OverrideScope implements AutoCloseable {
-
- private Map, Object> derivedCache = null;
-
- public T getDerived(DerivedOptionValue key) {
- if (derivedCache == null) {
- derivedCache = new HashMap<>();
- }
- @SuppressWarnings("unchecked")
- T ret = (T) derivedCache.get(key);
- if (ret == null) {
- ret = key.createValue();
- derivedCache.put(key, ret);
- }
- return ret;
- }
-
- abstract void addToInherited(Map, Object> inherited);
-
- abstract T getOverride(OptionValue option);
-
- abstract void getOverrides(OptionValue option, Collection c);
-
- public abstract void close();
- }
-
- static class SingleOverrideScope extends OverrideScope {
-
- private final OptionValue option;
- private final Object value;
-
- public SingleOverrideScope(OptionValue option, Object value) {
- if (option instanceof StableOptionValue) {
- throw new IllegalArgumentException("Cannot override stable option " + option);
- }
- this.option = option;
- this.value = value;
- setOverrideScope(this);
- }
-
- @Override
- void addToInherited(Map, Object> inherited) {
- inherited.put(option, value);
- }
-
- @SuppressWarnings("unchecked")
- @Override
- T getOverride(OptionValue key) {
- if (key == this.option) {
- return (T) value;
- }
- return null;
- }
-
- @Override
- void getOverrides(OptionValue key, Collection c) {
- if (key == this.option) {
- c.add(value);
- }
- }
-
- @Override
- public void close() {
- setOverrideScope(null);
- }
- }
-
- static class MultipleOverridesScope extends OverrideScope {
- final OverrideScope parent;
- final Map, Object> overrides;
-
- public MultipleOverridesScope(OverrideScope parent, OptionValue option, Object value) {
- this.parent = parent;
- this.overrides = new HashMap<>();
- if (parent != null) {
- parent.addToInherited(overrides);
- }
- if (option instanceof StableOptionValue) {
- throw new IllegalArgumentException("Cannot override stable option " + option);
- }
- if (!value.equals(option.getValue())) {
- this.overrides.put(option, value);
- }
- if (!overrides.isEmpty()) {
- setOverrideScope(this);
- }
- }
-
- MultipleOverridesScope(OverrideScope parent, Map, Object> overrides) {
- this.parent = parent;
- if (overrides.isEmpty() && parent == null) {
- this.overrides = Collections.emptyMap();
- return;
- }
- this.overrides = new HashMap<>();
- if (parent != null) {
- parent.addToInherited(this.overrides);
- }
- for (Map.Entry, Object> e : overrides.entrySet()) {
- OptionValue option = e.getKey();
- if (option instanceof StableOptionValue) {
- throw new IllegalArgumentException("Cannot override stable option " + option);
- }
- if (!e.getValue().equals(option.getValue())) {
- this.overrides.put(option, e.getValue());
- }
- }
- if (!this.overrides.isEmpty()) {
- setOverrideScope(this);
- }
- }
-
- @Override
- void addToInherited(Map, Object> inherited) {
- if (parent != null) {
- parent.addToInherited(inherited);
- }
- inherited.putAll(overrides);
- }
-
- @SuppressWarnings("unchecked")
- @Override
- T getOverride(OptionValue option) {
- return (T) overrides.get(option);
- }
-
- @Override
- void getOverrides(OptionValue option, Collection c) {
- Object v = overrides.get(option);
- if (v != null) {
- c.add(v);
- }
- if (parent != null) {
- parent.getOverrides(option, c);
- }
- }
-
- @Override
- public void close() {
- if (!overrides.isEmpty()) {
- setOverrideScope(parent);
- }
- }
- }
-
- static {
- if (ShowReadsHistogram) {
- Runtime.getRuntime().addShutdownHook(new Thread() {
- @Override
- public void run() {
- ArrayList> options = new ArrayList<>();
- for (OptionValue option = head; option != null; option = option.next) {
- options.add(option);
- }
- Collections.sort(options, new Comparator>() {
-
- public int compare(OptionValue o1, OptionValue o2) {
- if (o1.reads < o2.reads) {
- return -1;
- } else if (o1.reads > o2.reads) {
- return 1;
- } else {
- return o1.getName().compareTo(o2.getName());
- }
- }
- });
- PrintStream out = System.out;
- out.println("=== OptionValue reads histogram ===");
- for (OptionValue option : options) {
- out.println(option.reads + "\t" + option);
- }
- }
- });
- }
- }
-}
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionsLoader.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionsLoader.java
deleted file mode 100644
index a01a05d040e..00000000000
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionsLoader.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2014, 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 jdk.vm.ci.options;
-
-import java.util.ServiceLoader;
-import java.util.SortedMap;
-import java.util.TreeMap;
-
-/**
- * Helper class used to load option descriptors. Only to be used in the slow-path.
- */
-public class OptionsLoader {
- public static final SortedMap options = new TreeMap<>();
-
- /**
- * Initializes {@link #options} from {@link Options} services.
- */
- static {
- for (OptionDescriptors opts : ServiceLoader.load(OptionDescriptors.class, OptionsLoader.class.getClassLoader())) {
- for (OptionDescriptor desc : opts) {
- String name = desc.getName();
- OptionDescriptor existing = options.put(name, desc);
- assert existing == null : "Option named \"" + name + "\" has multiple definitions: " + existing.getLocation() + " and " + desc.getLocation();
- }
- }
- }
-}
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionsParser.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionsParser.java
deleted file mode 100644
index 0b8a6411181..00000000000
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionsParser.java
+++ /dev/null
@@ -1,382 +0,0 @@
-/*
- * Copyright (c) 2014, 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 jdk.vm.ci.options;
-
-import static jdk.vm.ci.inittimer.InitTimer.timer;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.io.PrintStream;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Formatter;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.ServiceLoader;
-import java.util.Set;
-import java.util.SortedMap;
-
-import jdk.vm.ci.inittimer.InitTimer;
-
-/**
- * This class contains methods for parsing JVMCI options and matching them against a set of
- * {@link OptionDescriptors}. The {@link OptionDescriptors} are loaded via a {@link ServiceLoader}.
- */
-public class OptionsParser {
-
- private static final OptionValue PrintFlags = new OptionValue<>(false);
- private static final OptionValue ShowFlags = new OptionValue<>(false);
-
- /**
- * A service for looking up {@link OptionDescriptor}s.
- */
- public interface OptionDescriptorsProvider {
- /**
- * Gets the {@link OptionDescriptor} matching a given option {@linkplain Option#name() name}
- * or null if no option of that name is provided by this object.
- */
- OptionDescriptor get(String name);
- }
-
- public interface OptionConsumer {
- void set(OptionDescriptor desc, Object value);
- }
-
- /**
- * Parses the options in {@code /lib/jvmci.options} if {@code parseOptionsFile == true} and
- * the file exists followed by the JVMCI options in {@code options} if {@code options != null}.
- *
- * Called from VM. This method has an object return type to allow it to be called with a VM
- * utility function used to call other static initialization methods.
- *
- * @param options JVMCI options as serialized (name, value) pairs
- * @param parseOptionsFile specifies whether to look for and parse
- * {@code /lib/jvmci.options}
- */
- @SuppressWarnings("try")
- public static Boolean parseOptionsFromVM(String[] options, boolean parseOptionsFile) {
-
- try (InitTimer t = timer("ParseOptions")) {
-
- if (parseOptionsFile) {
- File javaHome = new File(System.getProperty("java.home"));
- File lib = new File(javaHome, "lib");
- File jvmciOptions = new File(lib, "jvmci.options");
- if (jvmciOptions.exists()) {
- try (BufferedReader br = new BufferedReader(new FileReader(jvmciOptions))) {
- String optionSetting = null;
- int lineNo = 1;
- List optionSettings = new ArrayList<>();
- while ((optionSetting = br.readLine()) != null) {
- if (!optionSetting.isEmpty() && optionSetting.charAt(0) != '#') {
- try {
- parseOptionSettingTo(optionSetting, optionSettings);
- } catch (Throwable e) {
- throw new InternalError("Error parsing " + jvmciOptions + ", line " + lineNo, e);
- }
- }
- lineNo++;
- }
- try {
- parseOptions(optionSettings.toArray(new String[optionSettings.size()]), null, null, null);
- } catch (Throwable e) {
- throw new InternalError("Error parsing an option from " + jvmciOptions, e);
- }
- } catch (IOException e) {
- throw new InternalError("Error reading " + jvmciOptions, e);
- }
- }
- }
-
- parseOptions(options, null, null, null);
- }
- return Boolean.TRUE;
- }
-
- /**
- * Parses an ordered list of (name, value) pairs assigning values to JVMCI options.
- *
- * @param optionSettings JVMCI options as serialized (name, value) pairs
- * @param setter the object to notify of the parsed option and value
- * @param odp if non-null, the service to use for looking up {@link OptionDescriptor}s
- * @param options the options database to use if {@code odp == null}. If
- * {@code options == null && odp == null}, {@link OptionsLoader#options} is used.
- * @throws IllegalArgumentException if there's a problem parsing {@code option}
- */
- public static void parseOptions(String[] optionSettings, OptionConsumer setter, OptionDescriptorsProvider odp, SortedMap options) {
- if (optionSettings != null && optionSettings.length != 0) {
- assert optionSettings.length % 2 == 0;
-
- moveHelpFlagsToTail(optionSettings);
-
- for (int i = 0; i < optionSettings.length / 2; i++) {
- String name = optionSettings[i * 2];
- String value = optionSettings[i * 2 + 1];
- parseOption(name, value, setter, odp, options);
- }
- if (PrintFlags.getValue() || ShowFlags.getValue()) {
- Set explicitlyAssigned = new HashSet<>(optionSettings.length / 2);
- for (int i = 0; i < optionSettings.length / 2; i++) {
- String name = optionSettings[i * 2];
- explicitlyAssigned.add(name);
- }
- printFlags(resolveOptions(options), "JVMCI", System.out, explicitlyAssigned);
- if (PrintFlags.getValue()) {
- System.exit(0);
- }
- }
- }
- }
-
- /**
- * Moves all {@code PrintFlags} and {@code ShowFlags} option settings to the back of
- * {@code optionSettings}. This allows the help message to show which options had their value
- * explicitly set (even if to their default value).
- */
- private static void moveHelpFlagsToTail(String[] optionSettings) {
- List tail = null;
- int insert = 0;
- for (int i = 0; i < optionSettings.length / 2; i++) {
- String name = optionSettings[i * 2];
- String value = optionSettings[i * 2 + 1];
- if (name.equals("ShowFlags") || name.equals("PrintFlags")) {
- if (tail == null) {
- tail = new ArrayList<>(4);
- insert = i * 2;
- }
- tail.add(name);
- tail.add(value);
- } else if (tail != null) {
- optionSettings[insert++] = name;
- optionSettings[insert++] = value;
- }
- }
- if (tail != null) {
- assert tail.size() + insert == optionSettings.length;
- String[] tailArr = tail.toArray(new String[tail.size()]);
- System.arraycopy(tailArr, 0, optionSettings, insert, tailArr.length);
- }
- }
-
- /**
- * Parses a given option setting string to a list of (name, value) pairs.
- *
- * @param optionSetting a string matching the pattern {@code =}
- */
- public static void parseOptionSettingTo(String optionSetting, List dst) {
- int eqIndex = optionSetting.indexOf('=');
- if (eqIndex == -1) {
- throw new InternalError("Option setting has does not match the pattern =: " + optionSetting);
- }
- dst.add(optionSetting.substring(0, eqIndex));
- dst.add(optionSetting.substring(eqIndex + 1));
- }
-
- /**
- * Resolves {@code options} to a non-null value. This ensures {@link OptionsLoader#options} is
- * only loaded if necessary.
- */
- private static SortedMap resolveOptions(SortedMap options) {
- return options != null ? options : OptionsLoader.options;
- }
-
- /**
- * Parses a given option name and value.
- *
- * @param name the option name
- * @param valueString the option value as a string
- * @param setter the object to notify of the parsed option and value
- * @param odp if non-null, the service to use for looking up {@link OptionDescriptor}s
- * @param options the options database to use if {@code odp == null}. If
- * {@code options == null && odp == null}, {@link OptionsLoader#options} is used.
- * @throws IllegalArgumentException if there's a problem parsing {@code option}
- */
- private static void parseOption(String name, String valueString, OptionConsumer setter, OptionDescriptorsProvider odp, SortedMap options) {
-
- OptionDescriptor desc = odp != null ? odp.get(name) : resolveOptions(options).get(name);
- if (desc == null) {
- if (name.equals("PrintFlags")) {
- desc = OptionDescriptor.create("PrintFlags", Boolean.class, "Prints all JVMCI flags and exits", OptionsParser.class, "PrintFlags", PrintFlags);
- } else if (name.equals("ShowFlags")) {
- desc = OptionDescriptor.create("ShowFlags", Boolean.class, "Prints all JVMCI flags and continues", OptionsParser.class, "ShowFlags", ShowFlags);
- }
- }
- if (desc == null) {
- List matches = fuzzyMatch(resolveOptions(options), name);
- Formatter msg = new Formatter();
- msg.format("Could not find option %s", name);
- if (!matches.isEmpty()) {
- msg.format("%nDid you mean one of the following?");
- for (OptionDescriptor match : matches) {
- msg.format("%n %s=", match.getName());
- }
- }
- throw new IllegalArgumentException(msg.toString());
- }
-
- Class optionType = desc.getType();
- Object value;
- if (optionType == Boolean.class) {
- if ("true".equals(valueString)) {
- value = Boolean.TRUE;
- } else if ("false".equals(valueString)) {
- value = Boolean.FALSE;
- } else {
- throw new IllegalArgumentException("Boolean option '" + name + "' must have value \"true\" or \"false\", not \"" + valueString + "\"");
- }
- } else if (optionType == Float.class) {
- value = Float.parseFloat(valueString);
- } else if (optionType == Double.class) {
- value = Double.parseDouble(valueString);
- } else if (optionType == Integer.class) {
- value = Integer.valueOf((int) parseLong(valueString));
- } else if (optionType == Long.class) {
- value = Long.valueOf(parseLong(valueString));
- } else if (optionType == String.class) {
- value = valueString;
- } else {
- throw new IllegalArgumentException("Wrong value for option '" + name + "'");
- }
- if (setter == null) {
- desc.getOptionValue().setValue(value);
- } else {
- setter.set(desc, value);
- }
- }
-
- private static long parseLong(String v) {
- String valueString = v.toLowerCase();
- long scale = 1;
- if (valueString.endsWith("k")) {
- scale = 1024L;
- } else if (valueString.endsWith("m")) {
- scale = 1024L * 1024L;
- } else if (valueString.endsWith("g")) {
- scale = 1024L * 1024L * 1024L;
- } else if (valueString.endsWith("t")) {
- scale = 1024L * 1024L * 1024L * 1024L;
- }
-
- if (scale != 1) {
- /* Remove trailing scale character. */
- valueString = valueString.substring(0, valueString.length() - 1);
- }
-
- return Long.parseLong(valueString) * scale;
- }
-
- /**
- * Wraps some given text to one or more lines of a given maximum width.
- *
- * @param text text to wrap
- * @param width maximum width of an output line, exception for words in {@code text} longer than
- * this value
- * @return {@code text} broken into lines
- */
- private static List wrap(String text, int width) {
- List lines = Collections.singletonList(text);
- if (text.length() > width) {
- String[] chunks = text.split("\\s+");
- lines = new ArrayList<>();
- StringBuilder line = new StringBuilder();
- for (String chunk : chunks) {
- if (line.length() + chunk.length() > width) {
- lines.add(line.toString());
- line.setLength(0);
- }
- if (line.length() != 0) {
- line.append(' ');
- }
- String[] embeddedLines = chunk.split("%n", -2);
- if (embeddedLines.length == 1) {
- line.append(chunk);
- } else {
- for (int i = 0; i < embeddedLines.length; i++) {
- line.append(embeddedLines[i]);
- if (i < embeddedLines.length - 1) {
- lines.add(line.toString());
- line.setLength(0);
- }
- }
- }
- }
- if (line.length() != 0) {
- lines.add(line.toString());
- }
- }
- return lines;
- }
-
- private static void printFlags(SortedMap sortedOptions, String prefix, PrintStream out, Set explicitlyAssigned) {
- out.println("[List of " + prefix + " options]");
- for (Map.Entry e : sortedOptions.entrySet()) {
- e.getKey();
- OptionDescriptor desc = e.getValue();
- Object value = desc.getOptionValue().getValue();
- List helpLines = wrap(desc.getHelp(), 70);
- String name = e.getKey();
- String assign = explicitlyAssigned.contains(name) ? ":=" : " =";
- out.printf("%9s %-40s %s %-14s %s%n", desc.getType().getSimpleName(), name, assign, value, helpLines.get(0));
- for (int i = 1; i < helpLines.size(); i++) {
- out.printf("%67s %s%n", " ", helpLines.get(i));
- }
- }
- }
-
- /**
- * Compute string similarity based on Dice's coefficient.
- *
- * Ported from str_similar() in globals.cpp.
- */
- static float stringSimiliarity(String str1, String str2) {
- int hit = 0;
- for (int i = 0; i < str1.length() - 1; ++i) {
- for (int j = 0; j < str2.length() - 1; ++j) {
- if ((str1.charAt(i) == str2.charAt(j)) && (str1.charAt(i + 1) == str2.charAt(j + 1))) {
- ++hit;
- break;
- }
- }
- }
- return 2.0f * hit / (str1.length() + str2.length());
- }
-
- private static final float FUZZY_MATCH_THRESHOLD = 0.7F;
-
- /**
- * Returns the set of options that fuzzy match a given option name.
- */
- private static List fuzzyMatch(SortedMap options, String optionName) {
- List matches = new ArrayList<>();
- for (Map.Entry e : options.entrySet()) {
- float score = stringSimiliarity(e.getKey(), optionName);
- if (score >= FUZZY_MATCH_THRESHOLD) {
- matches.add(e.getValue());
- }
- }
- return matches;
- }
-}
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/StableOptionValue.java b/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/StableOptionValue.java
deleted file mode 100644
index 533e5002b47..00000000000
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/StableOptionValue.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2013, 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 jdk.vm.ci.options;
-
-/**
- * An option that always returns the same {@linkplain #getValue() value}.
- */
-public class StableOptionValue extends OptionValue {
-
- /**
- * Creates a stable option value.
- */
- public StableOptionValue(T value) {
- super(value);
- }
-
- /**
- * Used to assert the invariant for stability. Without using locks, this check is not safe
- * against races and so it's only an assertion.
- */
- private boolean getValueCalled;
-
- /**
- * Creates an uninitialized stable option value for a subclass that initializes itself
- * {@link #defaultValue() lazily}.
- */
- public StableOptionValue() {
- }
-
- /**
- * Gets the value of this option.
- */
- @Override
- public final T getValue() {
- T result = super.getValue();
- assert initGetValueCalled();
- return result;
- }
-
- private boolean initGetValueCalled() {
- getValueCalled = true;
- return true;
- }
-
- /**
- * {@inheritDoc}
- *
- * This must only be called if {@link #getValue()} has never been called.
- */
- @Override
- public final void setValue(Object v) {
- assert !getValueCalled;
- super.setValue(v);
- }
-}
diff --git a/hotspot/src/os/aix/vm/c1_globals_aix.hpp b/hotspot/src/os/aix/vm/c1_globals_aix.hpp
new file mode 100644
index 00000000000..45b57f71954
--- /dev/null
+++ b/hotspot/src/os/aix/vm/c1_globals_aix.hpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2012, 2015 SAP AG. 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.
+ *
+ */
+
+#ifndef OS_AIX_VM_C1_GLOBALS_AIX_HPP
+#define OS_AIX_VM_C1_GLOBALS_AIX_HPP
+
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/macros.hpp"
+
+//
+// Sets the default values for operating system dependent flags used by the
+// client compiler. (see c1_globals.hpp)
+//
+
+#endif // OS_AIX_VM_C1_GLOBALS_AIX_HPP
diff --git a/hotspot/src/os/aix/vm/os_aix.cpp b/hotspot/src/os/aix/vm/os_aix.cpp
index 5b8ed99bf0d..43314d7dfac 100644
--- a/hotspot/src/os/aix/vm/os_aix.cpp
+++ b/hotspot/src/os/aix/vm/os_aix.cpp
@@ -1643,7 +1643,7 @@ void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) {
st->print("total %d", os::processor_count());
// It's not safe to query number of active processors after crash.
// st->print("(active %d)", os::active_processor_count());
- st->print(" %s", VM_Version::cpu_features());
+ st->print(" %s", VM_Version::features());
st->cr();
}
diff --git a/hotspot/src/os/posix/vm/os_posix.cpp b/hotspot/src/os/posix/vm/os_posix.cpp
index 029004337cd..68ab843bf44 100644
--- a/hotspot/src/os/posix/vm/os_posix.cpp
+++ b/hotspot/src/os/posix/vm/os_posix.cpp
@@ -792,7 +792,11 @@ const char* os::Posix::describe_sa_flags(int flags, char* buffer, size_t size) {
strncpy(buffer, "none", size);
const struct {
- int i;
+ // NB: i is an unsigned int here because SA_RESETHAND is on some
+ // systems 0x80000000, which is implicitly unsigned. Assignining
+ // it to an int field would be an overflow in unsigned-to-signed
+ // conversion.
+ unsigned int i;
const char* s;
} flaginfo [] = {
{ SA_NOCLDSTOP, "SA_NOCLDSTOP" },
diff --git a/hotspot/src/share/vm/adlc/formssel.cpp b/hotspot/src/share/vm/adlc/formssel.cpp
index 82ba5f9e2d7..4e5fe365e52 100644
--- a/hotspot/src/share/vm/adlc/formssel.cpp
+++ b/hotspot/src/share/vm/adlc/formssel.cpp
@@ -1246,7 +1246,8 @@ bool InstructForm::check_branch_variant(ArchDesc &AD, InstructForm *short_branch
!is_short_branch() && // Don't match another short branch variant
reduce_result() != NULL &&
strcmp(reduce_result(), short_branch->reduce_result()) == 0 &&
- _matrule->equivalent(AD.globalNames(), short_branch->_matrule)) {
+ _matrule->equivalent(AD.globalNames(), short_branch->_matrule) &&
+ equivalent_predicates(this, short_branch)) {
// The instructions are equivalent.
// Now verify that both instructions have the same parameters and
@@ -4017,7 +4018,6 @@ int MatchRule::is_expensive() const {
strcmp(opType,"ModD")==0 ||
strcmp(opType,"ModF")==0 ||
strcmp(opType,"ModI")==0 ||
- strcmp(opType,"PowD")==0 ||
strcmp(opType,"SinD")==0 ||
strcmp(opType,"SqrtD")==0 ||
strcmp(opType,"TanD")==0 ||
diff --git a/hotspot/src/share/vm/asm/codeBuffer.cpp b/hotspot/src/share/vm/asm/codeBuffer.cpp
index 4ffcf0c81a2..30828b69751 100644
--- a/hotspot/src/share/vm/asm/codeBuffer.cpp
+++ b/hotspot/src/share/vm/asm/codeBuffer.cpp
@@ -305,6 +305,31 @@ address CodeSection::target(Label& L, address branch_pc) {
}
}
+void CodeSection::relocate(address at, relocInfo::relocType rtype, int format, jint method_index) {
+ RelocationHolder rh;
+ switch (rtype) {
+ case relocInfo::none: return;
+ case relocInfo::opt_virtual_call_type: {
+ rh = opt_virtual_call_Relocation::spec(method_index);
+ break;
+ }
+ case relocInfo::static_call_type: {
+ rh = static_call_Relocation::spec(method_index);
+ break;
+ }
+ case relocInfo::virtual_call_type: {
+ assert(method_index == 0, "resolved method overriding is not supported");
+ rh = Relocation::spec_simple(rtype);
+ break;
+ }
+ default: {
+ rh = Relocation::spec_simple(rtype);
+ break;
+ }
+ }
+ relocate(at, rh, format);
+}
+
void CodeSection::relocate(address at, RelocationHolder const& spec, int format) {
Relocation* reloc = spec.reloc();
relocInfo::relocType rtype = (relocInfo::relocType) reloc->type();
diff --git a/hotspot/src/share/vm/asm/codeBuffer.hpp b/hotspot/src/share/vm/asm/codeBuffer.hpp
index 387a5b7cced..534a81f0631 100644
--- a/hotspot/src/share/vm/asm/codeBuffer.hpp
+++ b/hotspot/src/share/vm/asm/codeBuffer.hpp
@@ -209,10 +209,7 @@ class CodeSection VALUE_OBJ_CLASS_SPEC {
// Emit a relocation.
void relocate(address at, RelocationHolder const& rspec, int format = 0);
- void relocate(address at, relocInfo::relocType rtype, int format = 0) {
- if (rtype != relocInfo::none)
- relocate(at, Relocation::spec_simple(rtype), format);
- }
+ void relocate(address at, relocInfo::relocType rtype, int format = 0, jint method_index = 0);
// alignment requirement for starting offset
// Requirements are that the instruction area and the
diff --git a/hotspot/src/share/vm/c1/c1_IR.cpp b/hotspot/src/share/vm/c1/c1_IR.cpp
index 6b015b44d85..105d27fcc0c 100644
--- a/hotspot/src/share/vm/c1/c1_IR.cpp
+++ b/hotspot/src/share/vm/c1/c1_IR.cpp
@@ -579,11 +579,8 @@ void ComputeLinearScanOrder::count_edges(BlockBegin* cur, BlockBegin* parent) {
assert(is_visited(cur), "block must be visisted when block is active");
assert(parent != NULL, "must have parent");
- cur->set(BlockBegin::linear_scan_loop_header_flag);
cur->set(BlockBegin::backward_branch_target_flag);
- parent->set(BlockBegin::linear_scan_loop_end_flag);
-
// When a loop header is also the start of an exception handler, then the backward branch is
// an exception edge. Because such edges are usually critical edges which cannot be split, the
// loop must be excluded here from processing.
@@ -592,6 +589,10 @@ void ComputeLinearScanOrder::count_edges(BlockBegin* cur, BlockBegin* parent) {
_iterative_dominators = true;
return;
}
+
+ cur->set(BlockBegin::linear_scan_loop_header_flag);
+ parent->set(BlockBegin::linear_scan_loop_end_flag);
+
assert(parent->number_of_sux() == 1 && parent->sux_at(0) == cur,
"loop end blocks must have one successor (critical edges are split)");
diff --git a/hotspot/src/share/vm/c1/c1_LIR.cpp b/hotspot/src/share/vm/c1/c1_LIR.cpp
index 44f7364ec5f..8397df6a048 100644
--- a/hotspot/src/share/vm/c1/c1_LIR.cpp
+++ b/hotspot/src/share/vm/c1/c1_LIR.cpp
@@ -754,31 +754,6 @@ void LIR_OpVisitState::visit(LIR_Op* op) {
break;
}
- case lir_pow: {
- assert(op->as_Op2() != NULL, "must be");
- LIR_Op2* op2 = (LIR_Op2*)op;
-
- // On x86 pow needs two temporary fpu stack slots: tmp1 and
- // tmp2. Register input operands as temps to guarantee that it
- // doesn't overlap with the temporary slots.
- assert(op2->_info == NULL, "not used");
- assert(op2->_opr1->is_valid() && op2->_opr2->is_valid(), "used");
- assert(op2->_tmp1->is_valid() && op2->_tmp2->is_valid() && op2->_tmp3->is_valid()
- && op2->_tmp4->is_valid() && op2->_tmp5->is_valid(), "used");
- assert(op2->_result->is_valid(), "used");
-
- do_input(op2->_opr1); do_temp(op2->_opr1);
- do_input(op2->_opr2); do_temp(op2->_opr2);
- do_temp(op2->_tmp1);
- do_temp(op2->_tmp2);
- do_temp(op2->_tmp3);
- do_temp(op2->_tmp4);
- do_temp(op2->_tmp5);
- do_output(op2->_result);
-
- break;
- }
-
// LIR_Op3
case lir_idiv:
case lir_irem: {
@@ -1769,7 +1744,6 @@ const char * LIR_Op::name() const {
case lir_cos: s = "cos"; break;
case lir_tan: s = "tan"; break;
case lir_log10: s = "log10"; break;
- case lir_pow: s = "pow"; break;
case lir_logic_and: s = "logic_and"; break;
case lir_logic_or: s = "logic_or"; break;
case lir_logic_xor: s = "logic_xor"; break;
diff --git a/hotspot/src/share/vm/c1/c1_LIR.hpp b/hotspot/src/share/vm/c1/c1_LIR.hpp
index 14651e14078..ade1fbd31cc 100644
--- a/hotspot/src/share/vm/c1/c1_LIR.hpp
+++ b/hotspot/src/share/vm/c1/c1_LIR.hpp
@@ -962,7 +962,6 @@ enum LIR_Code {
, lir_cos
, lir_tan
, lir_log10
- , lir_pow
, lir_logic_and
, lir_logic_or
, lir_logic_xor
@@ -2198,7 +2197,6 @@ class LIR_List: public CompilationResourceObj {
void sin (LIR_Opr from, LIR_Opr to, LIR_Opr tmp1, LIR_Opr tmp2) { append(new LIR_Op2(lir_sin , from, tmp1, to, tmp2)); }
void cos (LIR_Opr from, LIR_Opr to, LIR_Opr tmp1, LIR_Opr tmp2) { append(new LIR_Op2(lir_cos , from, tmp1, to, tmp2)); }
void tan (LIR_Opr from, LIR_Opr to, LIR_Opr tmp1, LIR_Opr tmp2) { append(new LIR_Op2(lir_tan , from, tmp1, to, tmp2)); }
- void pow (LIR_Opr arg1, LIR_Opr arg2, LIR_Opr res, LIR_Opr tmp1, LIR_Opr tmp2, LIR_Opr tmp3, LIR_Opr tmp4, LIR_Opr tmp5) { append(new LIR_Op2(lir_pow, arg1, arg2, res, tmp1, tmp2, tmp3, tmp4, tmp5)); }
void add (LIR_Opr left, LIR_Opr right, LIR_Opr res) { append(new LIR_Op2(lir_add, left, right, res)); }
void sub (LIR_Opr left, LIR_Opr right, LIR_Opr res, CodeEmitInfo* info = NULL) { append(new LIR_Op2(lir_sub, left, right, res, info)); }
diff --git a/hotspot/src/share/vm/c1/c1_LIRAssembler.cpp b/hotspot/src/share/vm/c1/c1_LIRAssembler.cpp
index d6b687dc01c..4d016513ee7 100644
--- a/hotspot/src/share/vm/c1/c1_LIRAssembler.cpp
+++ b/hotspot/src/share/vm/c1/c1_LIRAssembler.cpp
@@ -740,7 +740,6 @@ void LIR_Assembler::emit_op2(LIR_Op2* op) {
case lir_tan:
case lir_cos:
case lir_log10:
- case lir_pow:
intrinsic_op(op->code(), op->in_opr1(), op->in_opr2(), op->result_opr(), op);
break;
diff --git a/hotspot/src/share/vm/c1/c1_LIRGenerator.cpp b/hotspot/src/share/vm/c1/c1_LIRGenerator.cpp
index 98b519b58eb..8fa61f1e975 100644
--- a/hotspot/src/share/vm/c1/c1_LIRGenerator.cpp
+++ b/hotspot/src/share/vm/c1/c1_LIRGenerator.cpp
@@ -3055,13 +3055,16 @@ void LIRGenerator::do_IfOp(IfOp* x) {
__ cmove(lir_cond(x->cond()), t_val.result(), f_val.result(), reg, as_BasicType(x->x()->type()));
}
-void LIRGenerator::do_RuntimeCall(address routine, int expected_arguments, Intrinsic* x) {
- assert(x->number_of_arguments() == expected_arguments, "wrong type");
- LIR_Opr reg = result_register_for(x->type());
- __ call_runtime_leaf(routine, getThreadTemp(),
- reg, new LIR_OprList());
- LIR_Opr result = rlock_result(x);
- __ move(reg, result);
+void LIRGenerator::do_RuntimeCall(address routine, Intrinsic* x) {
+ assert(x->number_of_arguments() == 0, "wrong type");
+ // Enforce computation of _reserved_argument_area_size which is required on some platforms.
+ BasicTypeList signature;
+ CallingConvention* cc = frame_map()->c_calling_convention(&signature);
+ LIR_Opr reg = result_register_for(x->type());
+ __ call_runtime_leaf(routine, getThreadTemp(),
+ reg, new LIR_OprList());
+ LIR_Opr result = rlock_result(x);
+ __ move(reg, result);
}
#ifdef TRACE_HAVE_INTRINSICS
@@ -3115,16 +3118,16 @@ void LIRGenerator::do_Intrinsic(Intrinsic* x) {
case vmIntrinsics::_threadID: do_ThreadIDIntrinsic(x); break;
case vmIntrinsics::_classID: do_ClassIDIntrinsic(x); break;
case vmIntrinsics::_counterTime:
- do_RuntimeCall(CAST_FROM_FN_PTR(address, TRACE_TIME_METHOD), 0, x);
+ do_RuntimeCall(CAST_FROM_FN_PTR(address, TRACE_TIME_METHOD), x);
break;
#endif
case vmIntrinsics::_currentTimeMillis:
- do_RuntimeCall(CAST_FROM_FN_PTR(address, os::javaTimeMillis), 0, x);
+ do_RuntimeCall(CAST_FROM_FN_PTR(address, os::javaTimeMillis), x);
break;
case vmIntrinsics::_nanoTime:
- do_RuntimeCall(CAST_FROM_FN_PTR(address, os::javaTimeNanos), 0, x);
+ do_RuntimeCall(CAST_FROM_FN_PTR(address, os::javaTimeNanos), x);
break;
case vmIntrinsics::_Object_init: do_RegisterFinalizer(x); break;
diff --git a/hotspot/src/share/vm/c1/c1_LIRGenerator.hpp b/hotspot/src/share/vm/c1/c1_LIRGenerator.hpp
index 89f5960182a..9438d77288c 100644
--- a/hotspot/src/share/vm/c1/c1_LIRGenerator.hpp
+++ b/hotspot/src/share/vm/c1/c1_LIRGenerator.hpp
@@ -157,8 +157,8 @@ class LIRGenerator: public InstructionVisitor, public BlockClosure {
private:
void* operator new(size_t size) throw();
void* operator new[](size_t size) throw();
- void operator delete(void* p);
- void operator delete[](void* p);
+ void operator delete(void* p) { ShouldNotReachHere(); }
+ void operator delete[](void* p) { ShouldNotReachHere(); }
Compilation* _compilation;
ciMethod* _method; // method that we are compiling
@@ -439,7 +439,7 @@ class LIRGenerator: public InstructionVisitor, public BlockClosure {
SwitchRangeArray* create_lookup_ranges(LookupSwitch* x);
void do_SwitchRanges(SwitchRangeArray* x, LIR_Opr value, BlockBegin* default_sux);
- void do_RuntimeCall(address routine, int expected_arguments, Intrinsic* x);
+ void do_RuntimeCall(address routine, Intrinsic* x);
#ifdef TRACE_HAVE_INTRINSICS
void do_ThreadIDIntrinsic(Intrinsic* x);
void do_ClassIDIntrinsic(Intrinsic* x);
diff --git a/hotspot/src/share/vm/c1/c1_LinearScan.cpp b/hotspot/src/share/vm/c1/c1_LinearScan.cpp
index d87862707cb..f474b00d20b 100644
--- a/hotspot/src/share/vm/c1/c1_LinearScan.cpp
+++ b/hotspot/src/share/vm/c1/c1_LinearScan.cpp
@@ -6603,7 +6603,6 @@ void LinearScanStatistic::collect(LinearScan* allocator) {
case lir_cos:
case lir_abs:
case lir_log10:
- case lir_pow:
case lir_logic_and:
case lir_logic_or:
case lir_logic_xor:
diff --git a/hotspot/src/share/vm/c1/c1_RangeCheckElimination.hpp b/hotspot/src/share/vm/c1/c1_RangeCheckElimination.hpp
index 608f39a9196..0552125b8dc 100644
--- a/hotspot/src/share/vm/c1/c1_RangeCheckElimination.hpp
+++ b/hotspot/src/share/vm/c1/c1_RangeCheckElimination.hpp
@@ -50,8 +50,8 @@ private:
private:
void* operator new(size_t size) throw();
void* operator new[](size_t size) throw();
- void operator delete(void* p);
- void operator delete[](void* p);
+ void operator delete(void* p) { ShouldNotReachHere(); }
+ void operator delete[](void* p) { ShouldNotReachHere(); }
IR *_ir;
boolArray _used;
diff --git a/hotspot/src/share/vm/c1/c1_Runtime1.cpp b/hotspot/src/share/vm/c1/c1_Runtime1.cpp
index 73cbdc53a50..4896b13752b 100644
--- a/hotspot/src/share/vm/c1/c1_Runtime1.cpp
+++ b/hotspot/src/share/vm/c1/c1_Runtime1.cpp
@@ -320,6 +320,7 @@ const char* Runtime1::name_for_address(address entry) {
FUNCTION_CASE(entry, StubRoutines::updateBytesCRC32());
FUNCTION_CASE(entry, StubRoutines::dexp());
FUNCTION_CASE(entry, StubRoutines::dlog());
+ FUNCTION_CASE(entry, StubRoutines::dpow());
#undef FUNCTION_CASE
diff --git a/hotspot/src/share/vm/ci/ciMethod.hpp b/hotspot/src/share/vm/ci/ciMethod.hpp
index 2adb4e52bb9..6e350b41f97 100644
--- a/hotspot/src/share/vm/ci/ciMethod.hpp
+++ b/hotspot/src/share/vm/ci/ciMethod.hpp
@@ -251,6 +251,12 @@ class ciMethod : public ciMetadata {
ciField* get_field_at_bci( int bci, bool &will_link);
ciMethod* get_method_at_bci(int bci, bool &will_link, ciSignature* *declared_signature);
+ ciMethod* get_method_at_bci(int bci) {
+ bool ignored_will_link;
+ ciSignature* ignored_declared_signature;
+ return get_method_at_bci(bci, ignored_will_link, &ignored_declared_signature);
+ }
+
// Given a certain calling environment, find the monomorphic target
// for the call. Return NULL if the call is not monomorphic in
// its calling environment.
diff --git a/hotspot/src/share/vm/ci/ciReplay.cpp b/hotspot/src/share/vm/ci/ciReplay.cpp
index 27a5c1c8c16..aee1baf56e8 100644
--- a/hotspot/src/share/vm/ci/ciReplay.cpp
+++ b/hotspot/src/share/vm/ci/ciReplay.cpp
@@ -1040,10 +1040,8 @@ void* ciReplay::load_inline_data(ciMethod* method, int entry_bci, int comp_level
}
void* data = rp.process_inline(method, method->get_Method(), entry_bci, comp_level, THREAD);
if (HAS_PENDING_EXCEPTION) {
- oop throwable = PENDING_EXCEPTION;
+ Handle throwable(THREAD, PENDING_EXCEPTION);
CLEAR_PENDING_EXCEPTION;
- java_lang_Throwable::print(throwable, tty);
- tty->cr();
java_lang_Throwable::print_stack_trace(throwable, tty);
tty->cr();
return NULL;
@@ -1085,10 +1083,8 @@ int ciReplay::replay_impl(TRAPS) {
}
if (HAS_PENDING_EXCEPTION) {
- oop throwable = PENDING_EXCEPTION;
+ Handle throwable(THREAD, PENDING_EXCEPTION);
CLEAR_PENDING_EXCEPTION;
- java_lang_Throwable::print(throwable, tty);
- tty->cr();
java_lang_Throwable::print_stack_trace(throwable, tty);
tty->cr();
exit_code = 2;
diff --git a/hotspot/src/share/vm/classfile/classFileParser.cpp b/hotspot/src/share/vm/classfile/classFileParser.cpp
index 60c559e9056..48bb73b41da 100644
--- a/hotspot/src/share/vm/classfile/classFileParser.cpp
+++ b/hotspot/src/share/vm/classfile/classFileParser.cpp
@@ -1970,12 +1970,12 @@ AnnotationCollector::annotation_index(const ClassLoaderData* loader_data,
if (!privileged) break; // only allow in privileged code
return _method_CallerSensitive;
}
- case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_ForceInline_signature): {
+ case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_ForceInline_signature): {
if (_location != _in_method) break; // only allow for methods
if (!privileged) break; // only allow in privileged code
return _method_ForceInline;
}
- case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_DontInline_signature): {
+ case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_DontInline_signature): {
if (_location != _in_method) break; // only allow for methods
if (!privileged) break; // only allow in privileged code
return _method_DontInline;
@@ -2007,7 +2007,7 @@ AnnotationCollector::annotation_index(const ClassLoaderData* loader_data,
return _field_Stable;
}
#endif
- case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_Stable_signature): {
+ case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_Stable_signature): {
if (_location != _in_field) break; // only allow for fields
if (!privileged) break; // only allow in privileged code
return _field_Stable;
diff --git a/hotspot/src/share/vm/classfile/javaClasses.cpp b/hotspot/src/share/vm/classfile/javaClasses.cpp
index 1d9179aa9ef..b80899d324a 100644
--- a/hotspot/src/share/vm/classfile/javaClasses.cpp
+++ b/hotspot/src/share/vm/classfile/javaClasses.cpp
@@ -1493,18 +1493,6 @@ void java_lang_Throwable::clear_stacktrace(oop throwable) {
}
-void java_lang_Throwable::print(oop throwable, outputStream* st) {
- ResourceMark rm;
- Klass* k = throwable->klass();
- assert(k != NULL, "just checking");
- st->print("%s", k->external_name());
- oop msg = message(throwable);
- if (msg != NULL) {
- st->print(": %s", java_lang_String::as_utf8_string(msg));
- }
-}
-
-
void java_lang_Throwable::print(Handle throwable, outputStream* st) {
ResourceMark rm;
Klass* k = throwable->klass();
@@ -1732,20 +1720,25 @@ const char* java_lang_Throwable::no_stack_trace_message() {
return "\t<>";
}
+/**
+ * Print the throwable message and its stack trace plus all causes by walking the
+ * cause chain. The output looks the same as of Throwable.printStackTrace().
+ */
+void java_lang_Throwable::print_stack_trace(Handle throwable, outputStream* st) {
+ // First, print the message.
+ print(throwable, st);
+ st->cr();
-// Currently used only for exceptions occurring during startup
-void java_lang_Throwable::print_stack_trace(oop throwable, outputStream* st) {
- Thread *THREAD = Thread::current();
- Handle h_throwable(THREAD, throwable);
- while (h_throwable.not_null()) {
- objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable())));
+ // Now print the stack trace.
+ Thread* THREAD = Thread::current();
+ while (throwable.not_null()) {
+ objArrayHandle result (THREAD, objArrayOop(backtrace(throwable())));
if (result.is_null()) {
st->print_raw_cr(no_stack_trace_message());
return;
}
while (result.not_null()) {
-
// Get method id, bci, version and mirror from chunk
typeArrayHandle methods (THREAD, BacktraceBuilder::get_methods(result));
typeArrayHandle bcis (THREAD, BacktraceBuilder::get_bcis(result));
@@ -1770,20 +1763,20 @@ void java_lang_Throwable::print_stack_trace(oop throwable, outputStream* st) {
EXCEPTION_MARK;
JavaValue cause(T_OBJECT);
JavaCalls::call_virtual(&cause,
- h_throwable,
- KlassHandle(THREAD, h_throwable->klass()),
+ throwable,
+ KlassHandle(THREAD, throwable->klass()),
vmSymbols::getCause_name(),
vmSymbols::void_throwable_signature(),
THREAD);
// Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
- h_throwable = Handle();
+ throwable = Handle();
} else {
- h_throwable = Handle(THREAD, (oop) cause.get_jobject());
- if (h_throwable.not_null()) {
+ throwable = Handle(THREAD, (oop) cause.get_jobject());
+ if (throwable.not_null()) {
st->print("Caused by: ");
- print(h_throwable, st);
+ print(throwable, st);
st->cr();
}
}
diff --git a/hotspot/src/share/vm/classfile/javaClasses.hpp b/hotspot/src/share/vm/classfile/javaClasses.hpp
index 192d11ccede..3ac5b4191ea 100644
--- a/hotspot/src/share/vm/classfile/javaClasses.hpp
+++ b/hotspot/src/share/vm/classfile/javaClasses.hpp
@@ -240,6 +240,7 @@ class java_lang_String : AllStatic {
class java_lang_Class : AllStatic {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
// The fake offsets are added by the class loader when java.lang.Class is loaded
@@ -551,9 +552,8 @@ class java_lang_Throwable: AllStatic {
static oop get_stack_trace_element(oop throwable, int index, TRAPS);
static int get_stack_trace_depth(oop throwable, TRAPS);
// Printing
- static void print(oop throwable, outputStream* st);
static void print(Handle throwable, outputStream* st);
- static void print_stack_trace(oop throwable, outputStream* st);
+ static void print_stack_trace(Handle throwable, outputStream* st);
// Debugging
friend class JavaClasses;
};
diff --git a/hotspot/src/share/vm/classfile/vmSymbols.cpp b/hotspot/src/share/vm/classfile/vmSymbols.cpp
index e736c9774c8..81dda6e4fd0 100644
--- a/hotspot/src/share/vm/classfile/vmSymbols.cpp
+++ b/hotspot/src/share/vm/classfile/vmSymbols.cpp
@@ -409,6 +409,7 @@ int vmIntrinsics::predicates_needed(vmIntrinsics::ID id) {
switch (id) {
case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
+ case vmIntrinsics::_counterMode_AESCrypt:
return 1;
case vmIntrinsics::_digestBase_implCompressMB:
return 3;
@@ -597,6 +598,9 @@ bool vmIntrinsics::is_disabled_by_flags(const methodHandle& method) {
case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
if (!UseAESIntrinsics) return true;
break;
+ case vmIntrinsics::_counterMode_AESCrypt:
+ if (!UseAESCTRIntrinsics) return true;
+ break;
case vmIntrinsics::_sha_implCompress:
if (!UseSHA1Intrinsics) return true;
break;
@@ -681,6 +685,9 @@ bool vmIntrinsics::is_disabled_by_flags(const methodHandle& method) {
case vmIntrinsics::_montgomerySquare:
if (!UseMontgomerySquareIntrinsic) return true;
break;
+ case vmIntrinsics::_vectorizedMismatch:
+ if (!UseVectorizedMismatchIntrinsic) return true;
+ break;
case vmIntrinsics::_addExactI:
case vmIntrinsics::_addExactL:
case vmIntrinsics::_decrementExactI:
diff --git a/hotspot/src/share/vm/classfile/vmSymbols.hpp b/hotspot/src/share/vm/classfile/vmSymbols.hpp
index cef61cc3aa2..eb27ceb9498 100644
--- a/hotspot/src/share/vm/classfile/vmSymbols.hpp
+++ b/hotspot/src/share/vm/classfile/vmSymbols.hpp
@@ -269,6 +269,9 @@
\
/* Intrinsic Annotation (JDK 9 and above) */ \
template(jdk_internal_HotSpotIntrinsicCandidate_signature, "Ljdk/internal/HotSpotIntrinsicCandidate;") \
+ template(jdk_internal_vm_annotation_ForceInline_signature, "Ljdk/internal/vm/annotation/ForceInline;") \
+ template(jdk_internal_vm_annotation_DontInline_signature, "Ljdk/internal/vm/annotation/DontInline;") \
+ template(jdk_internal_vm_annotation_Stable_signature, "Ljdk/internal/vm/annotation/Stable;") \
\
/* Support for JSR 292 & invokedynamic (JDK 1.7 and above) */ \
template(java_lang_invoke_CallSite, "java/lang/invoke/CallSite") \
@@ -287,10 +290,7 @@
template(java_lang_invoke_MethodHandleNatives, "java/lang/invoke/MethodHandleNatives") \
template(java_lang_invoke_MethodHandleNatives_CallSiteContext, "java/lang/invoke/MethodHandleNatives$CallSiteContext") \
template(java_lang_invoke_LambdaForm, "java/lang/invoke/LambdaForm") \
- template(java_lang_invoke_ForceInline_signature, "Ljava/lang/invoke/ForceInline;") \
- template(java_lang_invoke_DontInline_signature, "Ljava/lang/invoke/DontInline;") \
template(java_lang_invoke_InjectedProfile_signature, "Ljava/lang/invoke/InjectedProfile;") \
- template(java_lang_invoke_Stable_signature, "Ljava/lang/invoke/Stable;") \
template(java_lang_invoke_LambdaForm_Compiled_signature, "Ljava/lang/invoke/LambdaForm$Compiled;") \
template(java_lang_invoke_LambdaForm_Hidden_signature, "Ljava/lang/invoke/LambdaForm$Hidden;") \
template(java_lang_invoke_MethodHandleNatives_CallSiteContext_signature, "Ljava/lang/invoke/MethodHandleNatives$CallSiteContext;") \
@@ -958,6 +958,11 @@
do_name( montgomerySquare_name, "implMontgomerySquare") \
do_signature(montgomerySquare_signature, "([I[IIJ[I)[I") \
\
+ do_class(java_util_ArraysSupport, "java/util/ArraysSupport") \
+ do_intrinsic(_vectorizedMismatch, java_util_ArraysSupport, vectorizedMismatch_name, vectorizedMismatch_signature, F_S)\
+ do_name(vectorizedMismatch_name, "vectorizedMismatch") \
+ do_signature(vectorizedMismatch_signature, "(Ljava/lang/Object;JLjava/lang/Object;JII)I") \
+ \
/* java/lang/ref/Reference */ \
do_intrinsic(_Reference_get, java_lang_ref_Reference, get_name, void_object_signature, F_R) \
\
@@ -976,6 +981,10 @@
do_name( decrypt_name, "implDecrypt") \
do_signature(byteArray_int_int_byteArray_int_signature, "([BII[BI)I") \
\
+ do_class(com_sun_crypto_provider_counterMode, "com/sun/crypto/provider/CounterMode") \
+ do_intrinsic(_counterMode_AESCrypt, com_sun_crypto_provider_counterMode, crypt_name, byteArray_int_int_byteArray_int_signature, F_R) \
+ do_name( crypt_name, "implCrypt") \
+ \
/* support for sun.security.provider.SHA */ \
do_class(sun_security_provider_sha, "sun/security/provider/SHA") \
do_intrinsic(_sha_implCompress, sun_security_provider_sha, implCompress_name, implCompress_signature, F_R) \
@@ -1055,6 +1064,11 @@
do_name( isCompileConstant_name, "isCompileConstant") \
do_alias( isCompileConstant_signature, object_boolean_signature) \
\
+ do_class(sun_hotspot_WhiteBox, "sun/hotspot/WhiteBox") \
+ do_intrinsic(_deoptimize, sun_hotspot_WhiteBox, deoptimize_name, deoptimize_signature, F_R) \
+ do_name( deoptimize_name, "deoptimize") \
+ do_alias( deoptimize_signature, void_method_signature) \
+ \
/* unsafe memory references (there are a lot of them...) */ \
do_signature(getObject_signature, "(Ljava/lang/Object;J)Ljava/lang/Object;") \
do_signature(putObject_signature, "(Ljava/lang/Object;JLjava/lang/Object;)V") \
@@ -1319,6 +1333,7 @@
class vmSymbols: AllStatic {
friend class vmIntrinsics;
friend class VMStructs;
+ friend class JVMCIVMStructs;
public:
// enum for figuring positions and size of array holding Symbol*s
enum SID {
diff --git a/hotspot/src/share/vm/code/codeBlob.hpp b/hotspot/src/share/vm/code/codeBlob.hpp
index cf846940b60..a4a4cab7c8b 100644
--- a/hotspot/src/share/vm/code/codeBlob.hpp
+++ b/hotspot/src/share/vm/code/codeBlob.hpp
@@ -64,6 +64,7 @@ class DeoptimizationBlob;
class CodeBlob VALUE_OBJ_CLASS_SPEC {
friend class VMStructs;
+ friend class JVMCIVMStructs;
friend class CodeCacheDumper;
private:
@@ -374,6 +375,7 @@ class SingletonBlob: public CodeBlob {
class DeoptimizationBlob: public SingletonBlob {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
int _unpack_offset;
int _unpack_with_exception;
diff --git a/hotspot/src/share/vm/code/codeCache.hpp b/hotspot/src/share/vm/code/codeCache.hpp
index 88594bd80a7..a3da713c9e5 100644
--- a/hotspot/src/share/vm/code/codeCache.hpp
+++ b/hotspot/src/share/vm/code/codeCache.hpp
@@ -76,6 +76,7 @@ class DepChange;
class CodeCache : AllStatic {
friend class VMStructs;
+ friend class JVMCIVMStructs;
friend class NMethodIterator;
friend class WhiteBox;
friend class CodeCacheLoader;
diff --git a/hotspot/src/share/vm/code/compiledIC.cpp b/hotspot/src/share/vm/code/compiledIC.cpp
index ec3e3a8e072..b2dde314f54 100644
--- a/hotspot/src/share/vm/code/compiledIC.cpp
+++ b/hotspot/src/share/vm/code/compiledIC.cpp
@@ -434,7 +434,7 @@ void CompiledIC::set_to_monomorphic(CompiledICInfo& info) {
InlineCacheBuffer::create_transition_stub(this, info.cached_metadata(), info.entry());
} else {
if (is_optimized()) {
- set_ic_destination(info.entry());
+ set_ic_destination(info.entry());
} else {
set_ic_destination_and_value(info.entry(), info.cached_metadata());
}
diff --git a/hotspot/src/share/vm/code/dependencies.cpp b/hotspot/src/share/vm/code/dependencies.cpp
index c941f404276..bdb1292a4aa 100644
--- a/hotspot/src/share/vm/code/dependencies.cpp
+++ b/hotspot/src/share/vm/code/dependencies.cpp
@@ -346,7 +346,6 @@ void Dependencies::assert_common_2(DepType dept,
}
}
} else {
- assert(dep_implicit_context_arg(dept) == 0, "sanity");
if (note_dep_seen(dept, x0) && note_dep_seen(dept, x1)) {
// look in this bucket for redundant assertions
const int stride = 2;
diff --git a/hotspot/src/share/vm/code/nmethod.cpp b/hotspot/src/share/vm/code/nmethod.cpp
index 5ff6520581b..4aa365aa058 100644
--- a/hotspot/src/share/vm/code/nmethod.cpp
+++ b/hotspot/src/share/vm/code/nmethod.cpp
@@ -979,19 +979,23 @@ void nmethod::print_nmethod(bool printmethod) {
oop_maps()->print();
}
}
- if (PrintDebugInfo || CompilerOracle::has_option_string(_method, "PrintDebugInfo")) {
+ if (printmethod || PrintDebugInfo || CompilerOracle::has_option_string(_method, "PrintDebugInfo")) {
print_scopes();
}
- if (PrintRelocations || CompilerOracle::has_option_string(_method, "PrintRelocations")) {
+ if (printmethod || PrintRelocations || CompilerOracle::has_option_string(_method, "PrintRelocations")) {
print_relocations();
}
- if (PrintDependencies || CompilerOracle::has_option_string(_method, "PrintDependencies")) {
+ if (printmethod || PrintDependencies || CompilerOracle::has_option_string(_method, "PrintDependencies")) {
print_dependencies();
}
- if (PrintExceptionHandlers) {
+ if (printmethod || PrintExceptionHandlers) {
print_handler_table();
print_nul_chk_table();
}
+ if (printmethod) {
+ print_recorded_oops();
+ print_recorded_metadata();
+ }
if (xtty != NULL) {
xtty->tail("print_nmethod");
}
@@ -1345,6 +1349,9 @@ void nmethod::make_unloaded(BoolObjectClosure* is_alive, oop cause) {
_state = unloaded;
+ // Log the unloading.
+ log_state_change();
+
#if INCLUDE_JVMCI
// The method can only be unloaded after the pointer to the installed code
// Java wrapper is no longer alive. Here we need to clear out this weak
@@ -1352,11 +1359,12 @@ void nmethod::make_unloaded(BoolObjectClosure* is_alive, oop cause) {
// after the method is unregistered since the original value may be still
// tracked by the rset.
maybe_invalidate_installed_code();
+ // Clear these out after the nmethod has been unregistered and any
+ // updates to the InstalledCode instance have been performed.
+ _jvmci_installed_code = NULL;
+ _speculation_log = NULL;
#endif
- // Log the unloading.
- log_state_change();
-
// The Method* is gone at this point
assert(_method == NULL, "Tautology");
@@ -1467,6 +1475,9 @@ bool nmethod::make_not_entrant_or_zombie(unsigned int state) {
// Log the transition once
log_state_change();
+ // Invalidate while holding the patching lock
+ JVMCI_ONLY(maybe_invalidate_installed_code());
+
// Remove nmethod from method.
// We need to check if both the _code and _from_compiled_code_entry_point
// refer to this nmethod because there is a race in setting these two fields
@@ -1493,6 +1504,10 @@ bool nmethod::make_not_entrant_or_zombie(unsigned int state) {
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
if (nmethod_needs_unregister) {
Universe::heap()->unregister_nmethod(this);
+#ifdef JVMCI
+ _jvmci_installed_code = NULL;
+ _speculation_log = NULL;
+#endif
}
flush_dependencies(NULL);
}
@@ -1516,8 +1531,6 @@ bool nmethod::make_not_entrant_or_zombie(unsigned int state) {
assert(state == not_entrant, "other cases may need to be handled differently");
}
- JVMCI_ONLY(maybe_invalidate_installed_code());
-
if (TraceCreateZombies) {
ResourceMark m;
tty->print_cr("nmethod <" INTPTR_FORMAT "> %s code made %s", p2i(this), this->method() ? this->method()->name_and_sig_as_C_string() : "null", (state == not_entrant) ? "not entrant" : "zombie");
@@ -2320,11 +2333,22 @@ bool nmethod::detect_scavenge_root_oops() {
void nmethod::preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) {
#ifndef SHARK
if (method() != NULL && !method()->is_native()) {
- SimpleScopeDesc ssd(this, fr.pc());
+ address pc = fr.pc();
+ SimpleScopeDesc ssd(this, pc);
Bytecode_invoke call(ssd.method(), ssd.bci());
bool has_receiver = call.has_receiver();
bool has_appendix = call.has_appendix();
Symbol* signature = call.signature();
+
+ // The method attached by JIT-compilers should be used, if present.
+ // Bytecode can be inaccurate in such case.
+ Method* callee = attached_method_before_pc(pc);
+ if (callee != NULL) {
+ has_receiver = !(callee->access_flags().is_static());
+ has_appendix = false;
+ signature = callee->signature();
+ }
+
fr.oops_compiled_arguments_do(signature, has_receiver, has_appendix, reg_map, f);
}
#endif // !SHARK
@@ -3014,6 +3038,34 @@ void nmethod::print_pcs() {
}
}
+void nmethod::print_recorded_oops() {
+ tty->print_cr("Recorded oops:");
+ for (int i = 0; i < oops_count(); i++) {
+ oop o = oop_at(i);
+ tty->print("#%3d: " INTPTR_FORMAT " ", i, p2i(o));
+ if (o == (oop)Universe::non_oop_word()) {
+ tty->print("non-oop word");
+ } else {
+ o->print_value();
+ }
+ tty->cr();
+ }
+}
+
+void nmethod::print_recorded_metadata() {
+ tty->print_cr("Recorded metadata:");
+ for (int i = 0; i < metadata_count(); i++) {
+ Metadata* m = metadata_at(i);
+ tty->print("#%3d: " INTPTR_FORMAT " ", i, p2i(m));
+ if (m == (Metadata*)Universe::non_oop_word()) {
+ tty->print("non-metadata word");
+ } else {
+ m->print_value_on_maybe_null(tty);
+ }
+ tty->cr();
+ }
+}
+
#endif // PRODUCT
const char* nmethod::reloc_string_for(u_char* begin, u_char* end) {
@@ -3065,9 +3117,39 @@ const char* nmethod::reloc_string_for(u_char* begin, u_char* end) {
}
return st.as_string();
}
- case relocInfo::virtual_call_type: return "virtual_call";
- case relocInfo::opt_virtual_call_type: return "optimized virtual_call";
- case relocInfo::static_call_type: return "static_call";
+ case relocInfo::virtual_call_type: {
+ stringStream st;
+ st.print_raw("virtual_call");
+ virtual_call_Relocation* r = iter.virtual_call_reloc();
+ Method* m = r->method_value();
+ if (m != NULL) {
+ assert(m->is_method(), "");
+ m->print_short_name(&st);
+ }
+ return st.as_string();
+ }
+ case relocInfo::opt_virtual_call_type: {
+ stringStream st;
+ st.print_raw("optimized virtual_call");
+ opt_virtual_call_Relocation* r = iter.opt_virtual_call_reloc();
+ Method* m = r->method_value();
+ if (m != NULL) {
+ assert(m->is_method(), "");
+ m->print_short_name(&st);
+ }
+ return st.as_string();
+ }
+ case relocInfo::static_call_type: {
+ stringStream st;
+ st.print_raw("static_call");
+ static_call_Relocation* r = iter.static_call_reloc();
+ Method* m = r->method_value();
+ if (m != NULL) {
+ assert(m->is_method(), "");
+ m->print_short_name(&st);
+ }
+ return st.as_string();
+ }
case relocInfo::static_stub_type: return "static_stub";
case relocInfo::external_word_type: return "external_word";
case relocInfo::internal_word_type: return "internal_word";
@@ -3361,26 +3443,80 @@ void nmethod::print_statistics() {
#if INCLUDE_JVMCI
void nmethod::clear_jvmci_installed_code() {
- // This must be done carefully to maintain nmethod remembered sets properly
- BarrierSet* bs = Universe::heap()->barrier_set();
- bs->write_ref_nmethod_pre(&_jvmci_installed_code, this);
- _jvmci_installed_code = NULL;
- bs->write_ref_nmethod_post(&_jvmci_installed_code, this);
+ // write_ref_method_pre/post can only be safely called at a
+ // safepoint or while holding the CodeCache_lock
+ assert(CodeCache_lock->is_locked() ||
+ SafepointSynchronize::is_at_safepoint(), "should be performed under a lock for consistency");
+ if (_jvmci_installed_code != NULL) {
+ // This must be done carefully to maintain nmethod remembered sets properly
+ BarrierSet* bs = Universe::heap()->barrier_set();
+ bs->write_ref_nmethod_pre(&_jvmci_installed_code, this);
+ _jvmci_installed_code = NULL;
+ bs->write_ref_nmethod_post(&_jvmci_installed_code, this);
+ }
}
void nmethod::maybe_invalidate_installed_code() {
- if (_jvmci_installed_code != NULL) {
- if (!is_alive()) {
- // Break the link between nmethod and InstalledCode such that the nmethod
- // can subsequently be flushed safely. The link must be maintained while
- // the method could have live activations since invalidateInstalledCode
- // might want to invalidate all existing activations.
- InstalledCode::set_address(_jvmci_installed_code, 0);
- InstalledCode::set_entryPoint(_jvmci_installed_code, 0);
- clear_jvmci_installed_code();
- } else if (is_not_entrant()) {
- InstalledCode::set_entryPoint(_jvmci_installed_code, 0);
- }
+ assert(Patching_lock->is_locked() ||
+ SafepointSynchronize::is_at_safepoint(), "should be performed under a lock for consistency");
+ oop installed_code = jvmci_installed_code();
+ if (installed_code != NULL) {
+ nmethod* nm = (nmethod*)InstalledCode::address(installed_code);
+ if (nm == NULL || nm != this) {
+ // The link has been broken or the InstalledCode instance is
+ // associated with another nmethod so do nothing.
+ return;
+ }
+ if (!is_alive()) {
+ // Break the link between nmethod and InstalledCode such that the nmethod
+ // can subsequently be flushed safely. The link must be maintained while
+ // the method could have live activations since invalidateInstalledCode
+ // might want to invalidate all existing activations.
+ InstalledCode::set_address(installed_code, 0);
+ InstalledCode::set_entryPoint(installed_code, 0);
+ } else if (is_not_entrant()) {
+ // Remove the entry point so any invocation will fail but keep
+ // the address link around that so that existing activations can
+ // be invalidated.
+ InstalledCode::set_entryPoint(installed_code, 0);
+ }
+ }
+}
+
+void nmethod::invalidate_installed_code(Handle installedCode, TRAPS) {
+ if (installedCode() == NULL) {
+ THROW(vmSymbols::java_lang_NullPointerException());
+ }
+ jlong nativeMethod = InstalledCode::address(installedCode);
+ nmethod* nm = (nmethod*)nativeMethod;
+ if (nm == NULL) {
+ // Nothing to do
+ return;
+ }
+
+ nmethodLocker nml(nm);
+#ifdef ASSERT
+ {
+ MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
+ // This relationship can only be checked safely under a lock
+ assert(nm == NULL || !nm->is_alive() || nm->jvmci_installed_code() == installedCode(), "sanity check");
+ }
+#endif
+
+ if (nm->is_alive()) {
+ // The nmethod state machinery maintains the link between the
+ // HotSpotInstalledCode and nmethod* so as long as the nmethod appears to be
+ // alive assume there is work to do and deoptimize the nmethod.
+ nm->mark_for_deoptimization();
+ VM_Deoptimize op;
+ VMThread::execute(&op);
+ }
+
+ MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
+ // Check that it's still associated with the same nmethod and break
+ // the link if it is.
+ if (InstalledCode::address(installedCode) == nativeMethod) {
+ InstalledCode::set_address(installedCode, 0);
}
}
@@ -3405,3 +3541,27 @@ char* nmethod::jvmci_installed_code_name(char* buf, size_t buflen) {
return buf;
}
#endif
+
+Method* nmethod::attached_method(address call_instr) {
+ assert(code_contains(call_instr), "not part of the nmethod");
+ RelocIterator iter(this, call_instr, call_instr + 1);
+ while (iter.next()) {
+ if (iter.addr() == call_instr) {
+ switch(iter.type()) {
+ case relocInfo::static_call_type: return iter.static_call_reloc()->method_value();
+ case relocInfo::opt_virtual_call_type: return iter.opt_virtual_call_reloc()->method_value();
+ case relocInfo::virtual_call_type: return iter.virtual_call_reloc()->method_value();
+ }
+ }
+ }
+ return NULL; // not found
+}
+
+Method* nmethod::attached_method_before_pc(address pc) {
+ if (NativeCall::is_call_before(pc)) {
+ NativeCall* ncall = nativeCall_before(pc);
+ return attached_method(ncall->instruction_address());
+ }
+ return NULL; // not a call
+}
+
diff --git a/hotspot/src/share/vm/code/nmethod.hpp b/hotspot/src/share/vm/code/nmethod.hpp
index 6134378aac0..f38ed2edb36 100644
--- a/hotspot/src/share/vm/code/nmethod.hpp
+++ b/hotspot/src/share/vm/code/nmethod.hpp
@@ -113,6 +113,7 @@ class xmlStream;
class nmethod : public CodeBlob {
friend class VMStructs;
+ friend class JVMCIVMStructs;
friend class NMethodSweeper;
friend class CodeCache; // scavengable oops
private:
@@ -392,6 +393,9 @@ class nmethod : public CodeBlob {
int handler_table_size() const { return handler_table_end() - handler_table_begin(); }
int nul_chk_table_size() const { return nul_chk_table_end() - nul_chk_table_begin(); }
+ int oops_count() const { assert(oops_size() % oopSize == 0, ""); return (oops_size() / oopSize) + 1; }
+ int metadata_count() const { assert(metadata_size() % wordSize == 0, ""); return (metadata_size() / wordSize) + 1; }
+
int total_size () const;
void dec_hotness_counter() { _hotness_counter--; }
@@ -491,7 +495,7 @@ class nmethod : public CodeBlob {
oop oop_at(int index) const { return index == 0 ? (oop) NULL: *oop_addr_at(index); }
oop* oop_addr_at(int index) const { // for GC
// relocation indexes are biased by 1 (because 0 is reserved)
- assert(index > 0 && index <= oops_size(), "must be a valid non-zero index");
+ assert(index > 0 && index <= oops_count(), "must be a valid non-zero index");
assert(!_oops_are_stale, "oops are stale");
return &oops_begin()[index - 1];
}
@@ -501,13 +505,16 @@ class nmethod : public CodeBlob {
Metadata* metadata_at(int index) const { return index == 0 ? NULL: *metadata_addr_at(index); }
Metadata** metadata_addr_at(int index) const { // for GC
// relocation indexes are biased by 1 (because 0 is reserved)
- assert(index > 0 && index <= metadata_size(), "must be a valid non-zero index");
+ assert(index > 0 && index <= metadata_count(), "must be a valid non-zero index");
return &metadata_begin()[index - 1];
}
void copy_values(GrowableArray* oops);
void copy_values(GrowableArray* metadata);
+ Method* attached_method(address call_pc);
+ Method* attached_method_before_pc(address pc);
+
// Relocation support
private:
void fix_oop_relocations(address begin, address end, bool initialize_immediates);
@@ -602,10 +609,20 @@ public:
#if INCLUDE_JVMCI
oop jvmci_installed_code() { return _jvmci_installed_code ; }
char* jvmci_installed_code_name(char* buf, size_t buflen);
- void clear_jvmci_installed_code();
+
+ // Update the state of any InstalledCode instance associated with
+ // this nmethod based on the current value of _state.
void maybe_invalidate_installed_code();
+
+ // Helper function to invalidate InstalledCode instances
+ static void invalidate_installed_code(Handle installed_code, TRAPS);
+
oop speculation_log() { return _speculation_log ; }
- void set_speculation_log(oop speculation_log) { _speculation_log = speculation_log; }
+
+ private:
+ void clear_jvmci_installed_code();
+
+ public:
#endif
// GC support
@@ -696,6 +713,8 @@ public:
void print_calls(outputStream* st) PRODUCT_RETURN;
void print_handler_table() PRODUCT_RETURN;
void print_nul_chk_table() PRODUCT_RETURN;
+ void print_recorded_oops() PRODUCT_RETURN;
+ void print_recorded_metadata() PRODUCT_RETURN;
void print_nmethod(bool print_code);
// need to re-define this from CodeBlob else the overload hides it
diff --git a/hotspot/src/share/vm/code/relocInfo.cpp b/hotspot/src/share/vm/code/relocInfo.cpp
index 50b0517457d..ec83dad64a8 100644
--- a/hotspot/src/share/vm/code/relocInfo.cpp
+++ b/hotspot/src/share/vm/code/relocInfo.cpp
@@ -581,13 +581,14 @@ void virtual_call_Relocation::pack_data_to(CodeSection* dest) {
normalize_address(_cached_value, dest);
jint x0 = scaled_offset_null_special(_cached_value, point);
- p = pack_1_int_to(p, x0);
+ p = pack_2_ints_to(p, x0, _method_index);
dest->set_locs_end((relocInfo*) p);
}
void virtual_call_Relocation::unpack_data() {
- jint x0 = unpack_1_int();
+ jint x0 = 0;
+ unpack_2_ints(x0, _method_index);
address point = addr();
_cached_value = x0==0? NULL: address_from_scaled_offset(x0, point);
}
@@ -793,6 +794,12 @@ address virtual_call_Relocation::cached_value() {
return _cached_value;
}
+Method* virtual_call_Relocation::method_value() {
+ Metadata* m = code()->metadata_at(_method_index);
+ assert(m != NULL || _method_index == 0, "should be non-null for non-zero index");
+ assert(m == NULL || m->is_method(), "not a method");
+ return (Method*)m;
+}
void virtual_call_Relocation::clear_inline_cache() {
// No stubs for ICs
@@ -803,6 +810,23 @@ void virtual_call_Relocation::clear_inline_cache() {
}
+void opt_virtual_call_Relocation::pack_data_to(CodeSection* dest) {
+ short* p = (short*) dest->locs_end();
+ p = pack_1_int_to(p, _method_index);
+ dest->set_locs_end((relocInfo*) p);
+}
+
+void opt_virtual_call_Relocation::unpack_data() {
+ _method_index = unpack_1_int();
+}
+
+Method* opt_virtual_call_Relocation::method_value() {
+ Metadata* m = code()->metadata_at(_method_index);
+ assert(m != NULL || _method_index == 0, "should be non-null for non-zero index");
+ assert(m == NULL || m->is_method(), "not a method");
+ return (Method*)m;
+}
+
void opt_virtual_call_Relocation::clear_inline_cache() {
// No stubs for ICs
// Clean IC
@@ -827,6 +851,22 @@ address opt_virtual_call_Relocation::static_stub() {
return NULL;
}
+Method* static_call_Relocation::method_value() {
+ Metadata* m = code()->metadata_at(_method_index);
+ assert(m != NULL || _method_index == 0, "should be non-null for non-zero index");
+ assert(m == NULL || m->is_method(), "not a method");
+ return (Method*)m;
+}
+
+void static_call_Relocation::pack_data_to(CodeSection* dest) {
+ short* p = (short*) dest->locs_end();
+ p = pack_1_int_to(p, _method_index);
+ dest->set_locs_end((relocInfo*) p);
+}
+
+void static_call_Relocation::unpack_data() {
+ _method_index = unpack_1_int();
+}
void static_call_Relocation::clear_inline_cache() {
// Safe call site info
@@ -1014,6 +1054,12 @@ void RelocIterator::print_current() {
break;
}
case relocInfo::static_call_type:
+ {
+ static_call_Relocation* r = (static_call_Relocation*) reloc();
+ tty->print(" | [destination=" INTPTR_FORMAT " metadata=" INTPTR_FORMAT "]",
+ p2i(r->destination()), p2i(r->method_value()));
+ break;
+ }
case relocInfo::runtime_call_type:
{
CallRelocation* r = (CallRelocation*) reloc();
@@ -1023,8 +1069,8 @@ void RelocIterator::print_current() {
case relocInfo::virtual_call_type:
{
virtual_call_Relocation* r = (virtual_call_Relocation*) reloc();
- tty->print(" | [destination=" INTPTR_FORMAT " cached_value=" INTPTR_FORMAT "]",
- p2i(r->destination()), p2i(r->cached_value()));
+ tty->print(" | [destination=" INTPTR_FORMAT " cached_value=" INTPTR_FORMAT " metadata=" INTPTR_FORMAT "]",
+ p2i(r->destination()), p2i(r->cached_value()), p2i(r->method_value()));
break;
}
case relocInfo::static_stub_type:
@@ -1039,6 +1085,13 @@ void RelocIterator::print_current() {
tty->print(" | [trampoline owner=" INTPTR_FORMAT "]", p2i(r->owner()));
break;
}
+ case relocInfo::opt_virtual_call_type:
+ {
+ opt_virtual_call_Relocation* r = (opt_virtual_call_Relocation*) reloc();
+ tty->print(" | [destination=" INTPTR_FORMAT " metadata=" INTPTR_FORMAT "]",
+ p2i(r->destination()), p2i(r->method_value()));
+ break;
+ }
}
tty->cr();
}
diff --git a/hotspot/src/share/vm/code/relocInfo.hpp b/hotspot/src/share/vm/code/relocInfo.hpp
index dc9b11bbcfe..a243bfdbee7 100644
--- a/hotspot/src/share/vm/code/relocInfo.hpp
+++ b/hotspot/src/share/vm/code/relocInfo.hpp
@@ -1044,27 +1044,31 @@ class virtual_call_Relocation : public CallRelocation {
// "cached_value" points to the first associated set-oop.
// The oop_limit helps find the last associated set-oop.
// (See comments at the top of this file.)
- static RelocationHolder spec(address cached_value) {
+ static RelocationHolder spec(address cached_value, jint method_index = 0) {
RelocationHolder rh = newHolder();
- new(rh) virtual_call_Relocation(cached_value);
+ new(rh) virtual_call_Relocation(cached_value, method_index);
return rh;
}
- virtual_call_Relocation(address cached_value) {
+ private:
+ address _cached_value; // location of set-value instruction
+ jint _method_index; // resolved method for a Java call
+
+ virtual_call_Relocation(address cached_value, int method_index) {
_cached_value = cached_value;
+ _method_index = method_index;
assert(cached_value != NULL, "first oop address must be specified");
}
- private:
- address _cached_value; // location of set-value instruction
-
friend class RelocIterator;
virtual_call_Relocation() { }
-
public:
address cached_value();
+ int method_index() { return _method_index; }
+ Method* method_value();
+
// data is packed as scaled offsets in "2_ints" format: [f l] or [Ff Ll]
// oop_limit is set to 0 if the limit falls somewhere within the call.
// When unpacking, a zero oop_limit is taken to refer to the end of the call.
@@ -1080,17 +1084,29 @@ class opt_virtual_call_Relocation : public CallRelocation {
relocInfo::relocType type() { return relocInfo::opt_virtual_call_type; }
public:
- static RelocationHolder spec() {
+ static RelocationHolder spec(int method_index = 0) {
RelocationHolder rh = newHolder();
- new(rh) opt_virtual_call_Relocation();
+ new(rh) opt_virtual_call_Relocation(method_index);
return rh;
}
private:
+ jint _method_index; // resolved method for a Java call
+
+ opt_virtual_call_Relocation(int method_index) {
+ _method_index = method_index;
+ }
+
friend class RelocIterator;
- opt_virtual_call_Relocation() { }
+ opt_virtual_call_Relocation() {}
public:
+ int method_index() { return _method_index; }
+ Method* method_value();
+
+ void pack_data_to(CodeSection* dest);
+ void unpack_data();
+
void clear_inline_cache();
// find the matching static_stub
@@ -1102,17 +1118,29 @@ class static_call_Relocation : public CallRelocation {
relocInfo::relocType type() { return relocInfo::static_call_type; }
public:
- static RelocationHolder spec() {
+ static RelocationHolder spec(int method_index = 0) {
RelocationHolder rh = newHolder();
- new(rh) static_call_Relocation();
+ new(rh) static_call_Relocation(method_index);
return rh;
}
private:
+ jint _method_index; // resolved method for a Java call
+
+ static_call_Relocation(int method_index) {
+ _method_index = method_index;
+ }
+
friend class RelocIterator;
- static_call_Relocation() { }
+ static_call_Relocation() {}
public:
+ int method_index() { return _method_index; }
+ Method* method_value();
+
+ void pack_data_to(CodeSection* dest);
+ void unpack_data();
+
void clear_inline_cache();
// find the matching static_stub
diff --git a/hotspot/src/share/vm/compiler/compileBroker.cpp b/hotspot/src/share/vm/compiler/compileBroker.cpp
index e5eac46910c..41151324bec 100644
--- a/hotspot/src/share/vm/compiler/compileBroker.cpp
+++ b/hotspot/src/share/vm/compiler/compileBroker.cpp
@@ -23,6 +23,7 @@
*/
#include "precompiled.hpp"
+#include "classfile/symbolTable.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/vmSymbols.hpp"
#include "code/codeCache.hpp"
@@ -56,6 +57,7 @@
#if INCLUDE_JVMCI
#include "jvmci/jvmciCompiler.hpp"
#include "jvmci/jvmciRuntime.hpp"
+#include "jvmci/jvmciJavaClasses.hpp"
#include "runtime/vframe.hpp"
#endif
#ifdef COMPILER2
@@ -214,7 +216,7 @@ bool compileBroker_init() {
if (DirectivesParser::has_file()) {
return DirectivesParser::parse_from_flag();
- } else if (PrintCompilerDirectives) {
+ } else if (CompilerDirectivesPrint) {
// Print default directive even when no other was added
DirectivesStack::print(tty);
}
@@ -498,7 +500,7 @@ CompilerCounters::CompilerCounters() {
// CompileBroker::compilation_init
//
// Initialize the Compilation object
-void CompileBroker::compilation_init() {
+void CompileBroker::compilation_init(TRAPS) {
_last_method_compiled[0] = '\0';
// No need to initialize compilation system if we do not use it.
@@ -529,6 +531,17 @@ void CompileBroker::compilation_init() {
} else {
c1_count = JVMCIHostThreads;
}
+
+ if (!UseInterpreter) {
+ // Force initialization of JVMCI compiler otherwise JVMCI
+ // compilations will not block until JVMCI is initialized
+ ResourceMark rm;
+ TempNewSymbol getCompiler = SymbolTable::new_symbol("getCompiler", CHECK);
+ TempNewSymbol sig = SymbolTable::new_symbol("()Ljdk/vm/ci/runtime/JVMCICompiler;", CHECK);
+ Handle jvmciRuntime = JVMCIRuntime::get_HotSpotJVMCIRuntime(CHECK);
+ JavaValue result(T_OBJECT);
+ JavaCalls::call_virtual(&result, jvmciRuntime, HotSpotJVMCIRuntime::klass(), getCompiler, sig, CHECK);
+ }
}
}
#endif // INCLUDE_JVMCI
diff --git a/hotspot/src/share/vm/compiler/compileBroker.hpp b/hotspot/src/share/vm/compiler/compileBroker.hpp
index 9c0709aa28f..448f1f8897d 100644
--- a/hotspot/src/share/vm/compiler/compileBroker.hpp
+++ b/hotspot/src/share/vm/compiler/compileBroker.hpp
@@ -276,7 +276,7 @@ public:
CompileQueue *q = compile_queue(comp_level);
return q != NULL ? q->size() : 0;
}
- static void compilation_init();
+ static void compilation_init(TRAPS);
static void init_compiler_thread_log();
static nmethod* compile_method(const methodHandle& method,
int osr_bci,
diff --git a/hotspot/src/share/vm/compiler/compileTask.hpp b/hotspot/src/share/vm/compiler/compileTask.hpp
index 1ec57bd00ab..17f77b34dee 100644
--- a/hotspot/src/share/vm/compiler/compileTask.hpp
+++ b/hotspot/src/share/vm/compiler/compileTask.hpp
@@ -38,6 +38,7 @@
class CompileTask : public CHeapObj {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
static CompileTask* _task_free_list;
diff --git a/hotspot/src/share/vm/compiler/compilerDirectives.cpp b/hotspot/src/share/vm/compiler/compilerDirectives.cpp
index 4d10aec5307..ba35617fc27 100644
--- a/hotspot/src/share/vm/compiler/compilerDirectives.cpp
+++ b/hotspot/src/share/vm/compiler/compilerDirectives.cpp
@@ -86,16 +86,21 @@ void CompilerDirectives::print(outputStream* st) {
//---
}
-void CompilerDirectives::finalize() {
+void CompilerDirectives::finalize(outputStream* st) {
if (_c1_store != NULL) {
- _c1_store->finalize();
+ _c1_store->finalize(st);
}
if (_c2_store != NULL) {
- _c2_store->finalize();
+ _c2_store->finalize(st);
}
}
-void DirectiveSet::finalize() {
+void DirectiveSet::finalize(outputStream* st) {
+ // Check LogOption and warn
+ if (LogOption && !LogCompilation) {
+ st->print_cr("Warning: +LogCompilation must be set to enable compilation logging from directives");
+ }
+
// if any flag has been modified - set directive as enabled
// unless it already has been explicitly set.
if (!_modified[EnableIndex]) {
@@ -252,12 +257,14 @@ DirectiveSet* DirectiveSet::compilecommand_compatibility_init(methodHandle metho
changed = true;
}
}
- if (CompilerOracle::should_log(method)) {
- if (!_modified[LogIndex]) {
- set->LogOption = true;
+ if (!_modified[LogIndex]) {
+ bool log = CompilerOracle::should_log(method);
+ if (log != set->LogOption) {
+ set->LogOption = log;
changed = true;
}
}
+
if (CompilerOracle::should_print(method)) {
if (!_modified[PrintAssemblyIndex]) {
set->PrintAssemblyOption = true;
@@ -306,7 +313,7 @@ CompilerDirectives* DirectiveSet::directive() {
bool DirectiveSet::matches_inline(methodHandle method, int inline_action) {
if (_inlinematchers != NULL) {
- if (_inlinematchers->match(method, InlineMatcher::force_inline)) {
+ if (_inlinematchers->match(method, inline_action)) {
return true;
}
}
@@ -318,11 +325,11 @@ bool DirectiveSet::should_inline(ciMethod* inlinee) {
VM_ENTRY_MARK;
methodHandle mh(THREAD, inlinee->get_Method());
- if (matches_inline(mh, InlineMatcher::force_inline)) {
- return true;
+ if (_inlinematchers != NULL) {
+ return matches_inline(mh, InlineMatcher::force_inline);
}
- if (!CompilerDirectivesIgnoreCompileCommandsOption && CompilerOracle::should_inline(mh)) {
- return true;
+ if (!CompilerDirectivesIgnoreCompileCommandsOption) {
+ return CompilerOracle::should_inline(mh);
}
return false;
}
@@ -332,11 +339,11 @@ bool DirectiveSet::should_not_inline(ciMethod* inlinee) {
VM_ENTRY_MARK;
methodHandle mh(THREAD, inlinee->get_Method());
- if (matches_inline(mh, InlineMatcher::dont_inline)) {
- return true;
+ if (_inlinematchers != NULL) {
+ return matches_inline(mh, InlineMatcher::dont_inline);
}
- if (!CompilerDirectivesIgnoreCompileCommandsOption && CompilerOracle::should_not_inline(mh)) {
- return true;
+ if (!CompilerDirectivesIgnoreCompileCommandsOption) {
+ return CompilerOracle::should_not_inline(mh);
}
return false;
}
@@ -487,6 +494,14 @@ void DirectivesStack::pop_inner() {
DirectivesStack::release(tmp);
}
+bool DirectivesStack::check_capacity(int request_size, outputStream* st) {
+ if ((request_size + _depth) > CompilerDirectivesLimit) {
+ st->print_cr("Could not add %i more directives. Currently %i/%i directives.", request_size, _depth, CompilerDirectivesLimit);
+ return false;
+ }
+ return true;
+}
+
void DirectivesStack::clear() {
// holding the lock during the whole operation ensuring consistent result
MutexLockerEx locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
@@ -546,10 +561,11 @@ DirectiveSet* DirectivesStack::getMatchingDirective(methodHandle method, Abstrac
match = dir->_c1_store;
break;
}
- }
- if (match->EnableOption) {
- // The directiveSet for this compile is also enabled -> success
- break;
+ } else {
+ if (match->EnableOption) {
+ // The directiveSet for this compile is also enabled -> success
+ break;
+ }
}
}
dir = dir->next();
diff --git a/hotspot/src/share/vm/compiler/compilerDirectives.hpp b/hotspot/src/share/vm/compiler/compilerDirectives.hpp
index a1498fe4859..a754c8bad83 100644
--- a/hotspot/src/share/vm/compiler/compilerDirectives.hpp
+++ b/hotspot/src/share/vm/compiler/compilerDirectives.hpp
@@ -38,7 +38,7 @@
cflags(Exclude, bool, false, X) \
cflags(BreakAtExecute, bool, false, X) \
cflags(BreakAtCompile, bool, false, X) \
- cflags(Log, bool, false, X) \
+ cflags(Log, bool, LogCompilation, X) \
cflags(PrintAssembly, bool, PrintAssembly, PrintAssembly) \
cflags(PrintInlining, bool, PrintInlining, PrintInlining) \
cflags(PrintNMethods, bool, PrintNMethods, PrintNMethods) \
@@ -88,6 +88,7 @@ public:
static DirectiveSet* getDefaultDirective(AbstractCompiler* comp);
static void push(CompilerDirectives* directive);
static void pop();
+ static bool check_capacity(int request_size, outputStream* st);
static void clear();
static void print(outputStream* st);
static void release(DirectiveSet* set);
@@ -115,7 +116,7 @@ public:
bool matches_inline(methodHandle method, int inline_action);
static DirectiveSet* clone(DirectiveSet const* src);
bool is_intrinsic_disabled(methodHandle method);
- void finalize();
+ void finalize(outputStream* st);
typedef enum {
#define enum_of_flags(name, type, dvalue, cc_flag) name##Index,
@@ -175,7 +176,7 @@ public:
DirectiveSet* get_for(AbstractCompiler *comp);
void print(outputStream* st);
bool is_default_directive() { return _next == NULL; }
- void finalize();
+ void finalize(outputStream* st);
void inc_refcount();
void dec_refcount();
diff --git a/hotspot/src/share/vm/compiler/compilerOracle.cpp b/hotspot/src/share/vm/compiler/compilerOracle.cpp
index 15d5d3a091c..4e5b240c6bc 100644
--- a/hotspot/src/share/vm/compiler/compilerOracle.cpp
+++ b/hotspot/src/share/vm/compiler/compilerOracle.cpp
@@ -247,15 +247,6 @@ TypedMethodOptionMatcher::~TypedMethodOptionMatcher() {
if (_option != NULL) {
os::free((void*)_option);
}
- if (_class_name != NULL) {
- _class_name->decrement_refcount();
- }
- if (_method_name != NULL) {
- _method_name->decrement_refcount();
- }
- if (_signature != NULL) {
- _signature->decrement_refcount();
- }
}
TypedMethodOptionMatcher* TypedMethodOptionMatcher::parse_method_pattern(char*& line, const char*& error_msg) {
diff --git a/hotspot/src/share/vm/compiler/directivesParser.cpp b/hotspot/src/share/vm/compiler/directivesParser.cpp
index e916b536dd2..16720ceb4db 100644
--- a/hotspot/src/share/vm/compiler/directivesParser.cpp
+++ b/hotspot/src/share/vm/compiler/directivesParser.cpp
@@ -30,6 +30,7 @@
#include
void DirectivesParser::push_tmp(CompilerDirectives* dir) {
+ _tmp_depth++;
dir->set_next(_tmp_top);
_tmp_top = dir;
}
@@ -41,17 +42,29 @@ CompilerDirectives* DirectivesParser::pop_tmp() {
CompilerDirectives* tmp = _tmp_top;
_tmp_top = _tmp_top->next();
tmp->set_next(NULL);
+ _tmp_depth--;
return tmp;
}
+void DirectivesParser::clean_tmp() {
+ CompilerDirectives* tmp = pop_tmp();
+ while (tmp != NULL) {
+ delete tmp;
+ tmp = pop_tmp();
+ }
+ assert(_tmp_depth == 0, "Consistency");
+}
+
bool DirectivesParser::parse_string(const char* text, outputStream* st) {
DirectivesParser cd(text, st);
if (cd.valid()) {
return cd.install_directives();
+ } else {
+ cd.clean_tmp();
+ st->flush();
+ st->print_cr("Parsing of compiler directives failed");
+ return false;
}
- st->flush();
- st->print_cr("Parsing of compiler directives failed");
- return false;
}
bool DirectivesParser::has_file() {
@@ -91,6 +104,12 @@ bool DirectivesParser::parse_from_file_inner(const char* filename, outputStream*
}
bool DirectivesParser::install_directives() {
+ // Check limit
+ if (!DirectivesStack::check_capacity(_tmp_depth, _st)) {
+ clean_tmp();
+ return false;
+ }
+
// Pop from internal temporary stack and push to compileBroker.
CompilerDirectives* tmp = pop_tmp();
int i = 0;
@@ -104,7 +123,7 @@ bool DirectivesParser::install_directives() {
return false;
} else {
_st->print_cr("%i compiler directives added", i);
- if (PrintCompilerDirectives) {
+ if (CompilerDirectivesPrint) {
// Print entire directives stack after new has been pushed.
DirectivesStack::print(_st);
}
@@ -113,7 +132,7 @@ bool DirectivesParser::install_directives() {
}
DirectivesParser::DirectivesParser(const char* text, outputStream* st)
-: JSON(text, false, st), depth(0), current_directive(NULL), current_directiveset(NULL), _tmp_top(NULL) {
+: JSON(text, false, st), depth(0), current_directive(NULL), current_directiveset(NULL), _tmp_top(NULL), _tmp_depth(0) {
#ifndef PRODUCT
memset(stack, 0, MAX_DEPTH * sizeof(stack[0]));
#endif
@@ -121,6 +140,8 @@ DirectivesParser::DirectivesParser(const char* text, outputStream* st)
}
DirectivesParser::~DirectivesParser() {
+ assert(_tmp_top == NULL, "Consistency");
+ assert(_tmp_depth == 0, "Consistency");
}
const DirectivesParser::key DirectivesParser::keys[] = {
@@ -379,11 +400,12 @@ bool DirectivesParser::set_option(JSON_TYPE t, JSON_VAL* v) {
const char* error_msg = NULL;
if (current_directiveset == NULL) {
- if (!current_directive->_c1_store->parse_and_add_inline(s, error_msg)) {
- assert (error_msg != NULL, "Must have valid error message");
- error(VALUE_ERROR, "Method pattern error: %s", error_msg);
- }
- if (!current_directive->_c2_store->parse_and_add_inline(s, error_msg)) {
+ if (current_directive->_c1_store->parse_and_add_inline(s, error_msg)) {
+ if (!current_directive->_c2_store->parse_and_add_inline(s, error_msg)) {
+ assert (error_msg != NULL, "Must have valid error message");
+ error(VALUE_ERROR, "Method pattern error: %s", error_msg);
+ }
+ } else {
assert (error_msg != NULL, "Must have valid error message");
error(VALUE_ERROR, "Method pattern error: %s", error_msg);
}
@@ -520,7 +542,7 @@ bool DirectivesParser::callback(JSON_TYPE t, JSON_VAL* v, uint rlimit) {
error(INTERNAL_ERROR, "Directive missing required match.");
return false;
}
- current_directive->finalize();
+ current_directive->finalize(_st);
push_tmp(current_directive);
current_directive = NULL;
break;
@@ -583,6 +605,7 @@ void DirectivesParser::test(const char* text, bool should_pass) {
tty->print("-- DirectivesParser test failed as expected --\n");
}
}
+ cd.clean_tmp();
}
bool DirectivesParser::test() {
diff --git a/hotspot/src/share/vm/compiler/directivesParser.hpp b/hotspot/src/share/vm/compiler/directivesParser.hpp
index 9defc95fab9..d0d7eb31388 100644
--- a/hotspot/src/share/vm/compiler/directivesParser.hpp
+++ b/hotspot/src/share/vm/compiler/directivesParser.hpp
@@ -126,8 +126,10 @@ private:
DirectiveSet* current_directiveset;
void push_tmp(CompilerDirectives* dir);
+ void clean_tmp();
CompilerDirectives* pop_tmp();
CompilerDirectives* _tmp_top; // temporary storage for dirs while parsing
+ int _tmp_depth; // Number of directives that has been parsed but not installed.
static uint mask(keytype kt);
diff --git a/hotspot/src/share/vm/gc/g1/vmStructs_g1.hpp b/hotspot/src/share/vm/gc/g1/vmStructs_g1.hpp
index 672c4f855ac..5be8f6c7891 100644
--- a/hotspot/src/share/vm/gc/g1/vmStructs_g1.hpp
+++ b/hotspot/src/share/vm/gc/g1/vmStructs_g1.hpp
@@ -67,27 +67,6 @@
#define VM_INT_CONSTANTS_G1(declare_constant, declare_constant_with_value) \
- \
- JVMCI_ONLY( \
- declare_constant_with_value( \
- "dirtyCardQueueBufferOffset", \
- in_bytes(DirtyCardQueue::byte_offset_of_buf())) \
- declare_constant_with_value( \
- "dirtyCardQueueIndexOffset", \
- in_bytes(DirtyCardQueue::byte_offset_of_index())) \
- ) /* JVMCI_ONLY */ \
- \
- JVMCI_ONLY( \
- declare_constant_with_value( \
- "satbMarkQueueBufferOffset", \
- in_bytes(SATBMarkQueue::byte_offset_of_buf())) \
- declare_constant_with_value( \
- "satbMarkQueueIndexOffset", \
- in_bytes(SATBMarkQueue::byte_offset_of_index())) \
- declare_constant_with_value( \
- "satbMarkQueueActiveOffset", \
- in_bytes(SATBMarkQueue::byte_offset_of_active())) \
- ) /* JVMCI_ONLY */ \
#define VM_TYPES_G1(declare_type, declare_toplevel_type) \
diff --git a/hotspot/src/share/vm/gc/shared/collectedHeap.hpp b/hotspot/src/share/vm/gc/shared/collectedHeap.hpp
index b0da1f7a1f1..7b959e994b8 100644
--- a/hotspot/src/share/vm/gc/shared/collectedHeap.hpp
+++ b/hotspot/src/share/vm/gc/shared/collectedHeap.hpp
@@ -83,6 +83,7 @@ class GCHeapLog : public EventLogBase {
//
class CollectedHeap : public CHeapObj {
friend class VMStructs;
+ friend class JVMCIVMStructs;
friend class IsGCActiveMark; // Block structured external access to _is_gc_active
private:
diff --git a/hotspot/src/share/vm/gc/shared/threadLocalAllocBuffer.hpp b/hotspot/src/share/vm/gc/shared/threadLocalAllocBuffer.hpp
index 60e05dcab26..eca56006510 100644
--- a/hotspot/src/share/vm/gc/shared/threadLocalAllocBuffer.hpp
+++ b/hotspot/src/share/vm/gc/shared/threadLocalAllocBuffer.hpp
@@ -39,6 +39,7 @@ class GlobalTLABStats;
// used to make it available for such multiplexing.
class ThreadLocalAllocBuffer: public CHeapObj {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
HeapWord* _start; // address of TLAB
HeapWord* _top; // address after last allocation
diff --git a/hotspot/src/share/vm/interpreter/linkResolver.cpp b/hotspot/src/share/vm/interpreter/linkResolver.cpp
index e0d15337001..48018a55e62 100644
--- a/hotspot/src/share/vm/interpreter/linkResolver.cpp
+++ b/hotspot/src/share/vm/interpreter/linkResolver.cpp
@@ -1457,6 +1457,33 @@ void LinkResolver::resolve_invoke(CallInfo& result, Handle recv, const constantP
return;
}
+void LinkResolver::resolve_invoke(CallInfo& result, Handle& recv,
+ const methodHandle& attached_method,
+ Bytecodes::Code byte, TRAPS) {
+ KlassHandle defc = attached_method->method_holder();
+ Symbol* name = attached_method->name();
+ Symbol* type = attached_method->signature();
+ LinkInfo link_info(defc, name, type, KlassHandle(), /*check_access=*/false);
+ switch(byte) {
+ case Bytecodes::_invokevirtual:
+ resolve_virtual_call(result, recv, recv->klass(), link_info,
+ /*check_null_and_abstract=*/true, CHECK);
+ break;
+ case Bytecodes::_invokeinterface:
+ resolve_interface_call(result, recv, recv->klass(), link_info,
+ /*check_null_and_abstract=*/true, CHECK);
+ break;
+ case Bytecodes::_invokestatic:
+ resolve_static_call(result, link_info, /*initialize_class=*/false, CHECK);
+ break;
+ case Bytecodes::_invokespecial:
+ resolve_special_call(result, link_info, CHECK);
+ break;
+ default:
+ fatal("bad call: %s", Bytecodes::name(byte));
+ }
+}
+
void LinkResolver::resolve_invokestatic(CallInfo& result, const constantPoolHandle& pool, int index, TRAPS) {
LinkInfo link_info(pool, index, CHECK);
resolve_static_call(result, link_info, /*initialize_class*/true, CHECK);
diff --git a/hotspot/src/share/vm/interpreter/linkResolver.hpp b/hotspot/src/share/vm/interpreter/linkResolver.hpp
index 198eefbe2c0..7d7a27944c8 100644
--- a/hotspot/src/share/vm/interpreter/linkResolver.hpp
+++ b/hotspot/src/share/vm/interpreter/linkResolver.hpp
@@ -295,6 +295,12 @@ class LinkResolver: AllStatic {
static void resolve_invoke(CallInfo& result, Handle recv,
const constantPoolHandle& pool, int index,
Bytecodes::Code byte, TRAPS);
+
+ // runtime resolving from attached method
+ static void resolve_invoke(CallInfo& result, Handle& recv,
+ const methodHandle& attached_method,
+ Bytecodes::Code byte, TRAPS);
+
private:
static void trace_method_resolution(const char* prefix, KlassHandle klass,
KlassHandle resolved_klass,
diff --git a/hotspot/src/share/vm/jvmci/jvmciCodeInstaller.hpp b/hotspot/src/share/vm/jvmci/jvmciCodeInstaller.hpp
index 394d263f668..1157759d0ed 100644
--- a/hotspot/src/share/vm/jvmci/jvmciCodeInstaller.hpp
+++ b/hotspot/src/share/vm/jvmci/jvmciCodeInstaller.hpp
@@ -89,7 +89,7 @@ private:
* This class handles the conversion from a InstalledCode to a CodeBlob or an nmethod.
*/
class CodeInstaller : public StackObj {
- friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
enum MarkId {
VERIFIED_ENTRY = 1,
diff --git a/hotspot/src/share/vm/jvmci/jvmciCompiler.cpp b/hotspot/src/share/vm/jvmci/jvmciCompiler.cpp
index c07f9b4c250..8e5a2ff86f7 100644
--- a/hotspot/src/share/vm/jvmci/jvmciCompiler.cpp
+++ b/hotspot/src/share/vm/jvmci/jvmciCompiler.cpp
@@ -112,6 +112,15 @@ void JVMCICompiler::bootstrap() {
_bootstrapping = false;
}
+#define CHECK_ABORT THREAD); \
+if (HAS_PENDING_EXCEPTION) { \
+ char buf[256]; \
+ jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
+ JVMCICompiler::abort_on_pending_exception(PENDING_EXCEPTION, buf); \
+ return; \
+} \
+(void)(0
+
void JVMCICompiler::compile_method(const methodHandle& method, int entry_bci, JVMCIEnv* env) {
JVMCI_EXCEPTION_CONTEXT
@@ -150,12 +159,12 @@ void JVMCICompiler::compile_method(const methodHandle& method, int entry_bci, JV
// should be handled by the Java code in some useful way but if they leak
// through to here report them instead of dying or silently ignoring them.
if (HAS_PENDING_EXCEPTION) {
- Handle throwable = PENDING_EXCEPTION;
+ Handle exception(THREAD, PENDING_EXCEPTION);
CLEAR_PENDING_EXCEPTION;
- JVMCIRuntime::call_printStackTrace(throwable, THREAD);
- if (HAS_PENDING_EXCEPTION) {
- CLEAR_PENDING_EXCEPTION;
+ {
+ ttyLocker ttyl;
+ java_lang_Throwable::print_stack_trace(exception, tty);
}
// Something went wrong so disable compilation at this level
@@ -165,6 +174,28 @@ void JVMCICompiler::compile_method(const methodHandle& method, int entry_bci, JV
}
}
+/**
+ * Aborts the VM due to an unexpected exception.
+ */
+void JVMCICompiler::abort_on_pending_exception(Handle exception, const char* message, bool dump_core) {
+ Thread* THREAD = Thread::current();
+ CLEAR_PENDING_EXCEPTION;
+
+ {
+ ttyLocker ttyl;
+ tty->print_raw_cr(message);
+ java_lang_Throwable::print_stack_trace(exception, tty);
+ }
+
+ // Give other aborting threads to also print their stack traces.
+ // This can be very useful when debugging class initialization
+ // failures.
+ assert(THREAD->is_Java_thread(), "compiler threads should be Java threads");
+ const bool interruptible = true;
+ os::sleep(THREAD, 200, interruptible);
+
+ vm_abort(dump_core);
+}
// Compilation entry point for methods
void JVMCICompiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, DirectiveSet* directive) {
diff --git a/hotspot/src/share/vm/jvmci/jvmciCompiler.hpp b/hotspot/src/share/vm/jvmci/jvmciCompiler.hpp
index f1f5c079433..fabee997500 100644
--- a/hotspot/src/share/vm/jvmci/jvmciCompiler.hpp
+++ b/hotspot/src/share/vm/jvmci/jvmciCompiler.hpp
@@ -42,6 +42,8 @@ private:
static elapsedTimer _codeInstallTimer;
+ static void abort_on_pending_exception(Handle exception, const char* message, bool dump_core = false);
+
public:
JVMCICompiler();
diff --git a/hotspot/src/share/vm/jvmci/jvmciCompilerToVM.cpp b/hotspot/src/share/vm/jvmci/jvmciCompilerToVM.cpp
index 558331e64a7..2205ff479fd 100644
--- a/hotspot/src/share/vm/jvmci/jvmciCompilerToVM.cpp
+++ b/hotspot/src/share/vm/jvmci/jvmciCompilerToVM.cpp
@@ -43,6 +43,7 @@
#include "jvmci/jvmciEnv.hpp"
#include "jvmci/jvmciJavaClasses.hpp"
#include "jvmci/jvmciCodeInstaller.hpp"
+#include "jvmci/vmStructs_jvmci.hpp"
#include "gc/g1/heapRegion.hpp"
#include "runtime/javaCalls.hpp"
#include "runtime/deoptimization.hpp"
@@ -84,107 +85,161 @@ oop CompilerToVM::get_jvmci_type(KlassHandle klass, TRAPS) {
return NULL;
}
-void CompilerToVM::invalidate_installed_code(Handle installedCode, TRAPS) {
- if (installedCode() == NULL) {
- THROW(vmSymbols::java_lang_NullPointerException());
- }
- jlong nativeMethod = InstalledCode::address(installedCode);
- nmethod* nm = (nmethod*)nativeMethod;
- assert(nm == NULL || nm->jvmci_installed_code() == installedCode(), "sanity check");
- if (nm != NULL && nm->is_alive()) {
- // The nmethod state machinery maintains the link between the
- // HotSpotInstalledCode and nmethod* so as long as the nmethod appears to be
- // alive assume there is work to do and deoptimize the nmethod.
- nm->mark_for_deoptimization();
- VM_Deoptimize op;
- VMThread::execute(&op);
- }
- InstalledCode::set_address(installedCode, 0);
-}
-
extern "C" {
-extern VMStructEntry* gHotSpotVMStructs;
-extern uint64_t gHotSpotVMStructEntryTypeNameOffset;
-extern uint64_t gHotSpotVMStructEntryFieldNameOffset;
-extern uint64_t gHotSpotVMStructEntryTypeStringOffset;
-extern uint64_t gHotSpotVMStructEntryIsStaticOffset;
-extern uint64_t gHotSpotVMStructEntryOffsetOffset;
-extern uint64_t gHotSpotVMStructEntryAddressOffset;
-extern uint64_t gHotSpotVMStructEntryArrayStride;
+extern VMStructEntry* jvmciHotSpotVMStructs;
+extern uint64_t jvmciHotSpotVMStructEntryTypeNameOffset;
+extern uint64_t jvmciHotSpotVMStructEntryFieldNameOffset;
+extern uint64_t jvmciHotSpotVMStructEntryTypeStringOffset;
+extern uint64_t jvmciHotSpotVMStructEntryIsStaticOffset;
+extern uint64_t jvmciHotSpotVMStructEntryOffsetOffset;
+extern uint64_t jvmciHotSpotVMStructEntryAddressOffset;
+extern uint64_t jvmciHotSpotVMStructEntryArrayStride;
-extern VMTypeEntry* gHotSpotVMTypes;
-extern uint64_t gHotSpotVMTypeEntryTypeNameOffset;
-extern uint64_t gHotSpotVMTypeEntrySuperclassNameOffset;
-extern uint64_t gHotSpotVMTypeEntryIsOopTypeOffset;
-extern uint64_t gHotSpotVMTypeEntryIsIntegerTypeOffset;
-extern uint64_t gHotSpotVMTypeEntryIsUnsignedOffset;
-extern uint64_t gHotSpotVMTypeEntrySizeOffset;
-extern uint64_t gHotSpotVMTypeEntryArrayStride;
+extern VMTypeEntry* jvmciHotSpotVMTypes;
+extern uint64_t jvmciHotSpotVMTypeEntryTypeNameOffset;
+extern uint64_t jvmciHotSpotVMTypeEntrySuperclassNameOffset;
+extern uint64_t jvmciHotSpotVMTypeEntryIsOopTypeOffset;
+extern uint64_t jvmciHotSpotVMTypeEntryIsIntegerTypeOffset;
+extern uint64_t jvmciHotSpotVMTypeEntryIsUnsignedOffset;
+extern uint64_t jvmciHotSpotVMTypeEntrySizeOffset;
+extern uint64_t jvmciHotSpotVMTypeEntryArrayStride;
-extern VMIntConstantEntry* gHotSpotVMIntConstants;
-extern uint64_t gHotSpotVMIntConstantEntryNameOffset;
-extern uint64_t gHotSpotVMIntConstantEntryValueOffset;
-extern uint64_t gHotSpotVMIntConstantEntryArrayStride;
+extern VMIntConstantEntry* jvmciHotSpotVMIntConstants;
+extern uint64_t jvmciHotSpotVMIntConstantEntryNameOffset;
+extern uint64_t jvmciHotSpotVMIntConstantEntryValueOffset;
+extern uint64_t jvmciHotSpotVMIntConstantEntryArrayStride;
-extern VMLongConstantEntry* gHotSpotVMLongConstants;
-extern uint64_t gHotSpotVMLongConstantEntryNameOffset;
-extern uint64_t gHotSpotVMLongConstantEntryValueOffset;
-extern uint64_t gHotSpotVMLongConstantEntryArrayStride;
+extern VMLongConstantEntry* jvmciHotSpotVMLongConstants;
+extern uint64_t jvmciHotSpotVMLongConstantEntryNameOffset;
+extern uint64_t jvmciHotSpotVMLongConstantEntryValueOffset;
+extern uint64_t jvmciHotSpotVMLongConstantEntryArrayStride;
-extern VMAddressEntry* gHotSpotVMAddresses;
-extern uint64_t gHotSpotVMAddressEntryNameOffset;
-extern uint64_t gHotSpotVMAddressEntryValueOffset;
-extern uint64_t gHotSpotVMAddressEntryArrayStride;
+extern VMAddressEntry* jvmciHotSpotVMAddresses;
+extern uint64_t jvmciHotSpotVMAddressEntryNameOffset;
+extern uint64_t jvmciHotSpotVMAddressEntryValueOffset;
+extern uint64_t jvmciHotSpotVMAddressEntryArrayStride;
}
-// FIXME This is only temporary until the GC code is changed.
-bool CompilerToVM::_supports_inline_contig_alloc;
-HeapWord** CompilerToVM::_heap_end_addr;
-HeapWord** CompilerToVM::_heap_top_addr;
+int CompilerToVM::Data::InstanceKlass_vtable_start_offset;
+int CompilerToVM::Data::InstanceKlass_vtable_length_offset;
+
+int CompilerToVM::Data::Method_extra_stack_entries;
+
+address CompilerToVM::Data::SharedRuntime_ic_miss_stub;
+address CompilerToVM::Data::SharedRuntime_handle_wrong_method_stub;
+address CompilerToVM::Data::SharedRuntime_deopt_blob_unpack;
+address CompilerToVM::Data::SharedRuntime_deopt_blob_uncommon_trap;
+
+size_t CompilerToVM::Data::ThreadLocalAllocBuffer_alignment_reserve;
+
+CollectedHeap* CompilerToVM::Data::Universe_collectedHeap;
+int CompilerToVM::Data::Universe_base_vtable_size;
+address CompilerToVM::Data::Universe_narrow_oop_base;
+int CompilerToVM::Data::Universe_narrow_oop_shift;
+address CompilerToVM::Data::Universe_narrow_klass_base;
+int CompilerToVM::Data::Universe_narrow_klass_shift;
+void* CompilerToVM::Data::Universe_non_oop_bits;
+uintptr_t CompilerToVM::Data::Universe_verify_oop_mask;
+uintptr_t CompilerToVM::Data::Universe_verify_oop_bits;
+
+bool CompilerToVM::Data::_supports_inline_contig_alloc;
+HeapWord** CompilerToVM::Data::_heap_end_addr;
+HeapWord** CompilerToVM::Data::_heap_top_addr;
+
+jbyte* CompilerToVM::Data::cardtable_start_address;
+int CompilerToVM::Data::cardtable_shift;
+
+void CompilerToVM::Data::initialize() {
+ InstanceKlass_vtable_start_offset = InstanceKlass::vtable_start_offset();
+ InstanceKlass_vtable_length_offset = InstanceKlass::vtable_length_offset() * HeapWordSize;
+
+ Method_extra_stack_entries = Method::extra_stack_entries();
+
+ SharedRuntime_ic_miss_stub = SharedRuntime::get_ic_miss_stub();
+ SharedRuntime_handle_wrong_method_stub = SharedRuntime::get_handle_wrong_method_stub();
+ SharedRuntime_deopt_blob_unpack = SharedRuntime::deopt_blob()->unpack();
+ SharedRuntime_deopt_blob_uncommon_trap = SharedRuntime::deopt_blob()->uncommon_trap();
+
+ ThreadLocalAllocBuffer_alignment_reserve = ThreadLocalAllocBuffer::alignment_reserve();
+
+ Universe_collectedHeap = Universe::heap();
+ Universe_base_vtable_size = Universe::base_vtable_size();
+ Universe_narrow_oop_base = Universe::narrow_oop_base();
+ Universe_narrow_oop_shift = Universe::narrow_oop_shift();
+ Universe_narrow_klass_base = Universe::narrow_klass_base();
+ Universe_narrow_klass_shift = Universe::narrow_klass_shift();
+ Universe_non_oop_bits = Universe::non_oop_word();
+ Universe_verify_oop_mask = Universe::verify_oop_mask();
+ Universe_verify_oop_bits = Universe::verify_oop_bits();
+
+ _supports_inline_contig_alloc = Universe::heap()->supports_inline_contig_alloc();
+ _heap_end_addr = _supports_inline_contig_alloc ? Universe::heap()->end_addr() : (HeapWord**) -1;
+ _heap_top_addr = _supports_inline_contig_alloc ? Universe::heap()->top_addr() : (HeapWord**) -1;
+
+ BarrierSet* bs = Universe::heap()->barrier_set();
+ switch (bs->kind()) {
+ case BarrierSet::CardTableModRef:
+ case BarrierSet::CardTableForRS:
+ case BarrierSet::CardTableExtension:
+ case BarrierSet::G1SATBCT:
+ case BarrierSet::G1SATBCTLogging: {
+ jbyte* base = barrier_set_cast(bs)->byte_map_base;
+ assert(base != 0, "unexpected byte_map_base");
+ cardtable_start_address = base;
+ cardtable_shift = CardTableModRefBS::card_shift;
+ break;
+ }
+ case BarrierSet::ModRef:
+ cardtable_start_address = 0;
+ cardtable_shift = 0;
+ // No post barriers
+ break;
+ default:
+ ShouldNotReachHere();
+ break;
+ }
+}
/**
- * We put all gHotSpotVM values in an array so we can read them easily from Java.
+ * We put all jvmciHotSpotVM values in an array so we can read them easily from Java.
*/
static uintptr_t ciHotSpotVMData[28];
C2V_VMENTRY(jlong, initializeConfiguration, (JNIEnv *env, jobject))
- ciHotSpotVMData[0] = (uintptr_t) gHotSpotVMStructs;
- ciHotSpotVMData[1] = gHotSpotVMStructEntryTypeNameOffset;
- ciHotSpotVMData[2] = gHotSpotVMStructEntryFieldNameOffset;
- ciHotSpotVMData[3] = gHotSpotVMStructEntryTypeStringOffset;
- ciHotSpotVMData[4] = gHotSpotVMStructEntryIsStaticOffset;
- ciHotSpotVMData[5] = gHotSpotVMStructEntryOffsetOffset;
- ciHotSpotVMData[6] = gHotSpotVMStructEntryAddressOffset;
- ciHotSpotVMData[7] = gHotSpotVMStructEntryArrayStride;
+ ciHotSpotVMData[0] = (uintptr_t) jvmciHotSpotVMStructs;
+ ciHotSpotVMData[1] = jvmciHotSpotVMStructEntryTypeNameOffset;
+ ciHotSpotVMData[2] = jvmciHotSpotVMStructEntryFieldNameOffset;
+ ciHotSpotVMData[3] = jvmciHotSpotVMStructEntryTypeStringOffset;
+ ciHotSpotVMData[4] = jvmciHotSpotVMStructEntryIsStaticOffset;
+ ciHotSpotVMData[5] = jvmciHotSpotVMStructEntryOffsetOffset;
+ ciHotSpotVMData[6] = jvmciHotSpotVMStructEntryAddressOffset;
+ ciHotSpotVMData[7] = jvmciHotSpotVMStructEntryArrayStride;
- ciHotSpotVMData[8] = (uintptr_t) gHotSpotVMTypes;
- ciHotSpotVMData[9] = gHotSpotVMTypeEntryTypeNameOffset;
- ciHotSpotVMData[10] = gHotSpotVMTypeEntrySuperclassNameOffset;
- ciHotSpotVMData[11] = gHotSpotVMTypeEntryIsOopTypeOffset;
- ciHotSpotVMData[12] = gHotSpotVMTypeEntryIsIntegerTypeOffset;
- ciHotSpotVMData[13] = gHotSpotVMTypeEntryIsUnsignedOffset;
- ciHotSpotVMData[14] = gHotSpotVMTypeEntrySizeOffset;
- ciHotSpotVMData[15] = gHotSpotVMTypeEntryArrayStride;
+ ciHotSpotVMData[8] = (uintptr_t) jvmciHotSpotVMTypes;
+ ciHotSpotVMData[9] = jvmciHotSpotVMTypeEntryTypeNameOffset;
+ ciHotSpotVMData[10] = jvmciHotSpotVMTypeEntrySuperclassNameOffset;
+ ciHotSpotVMData[11] = jvmciHotSpotVMTypeEntryIsOopTypeOffset;
+ ciHotSpotVMData[12] = jvmciHotSpotVMTypeEntryIsIntegerTypeOffset;
+ ciHotSpotVMData[13] = jvmciHotSpotVMTypeEntryIsUnsignedOffset;
+ ciHotSpotVMData[14] = jvmciHotSpotVMTypeEntrySizeOffset;
+ ciHotSpotVMData[15] = jvmciHotSpotVMTypeEntryArrayStride;
- ciHotSpotVMData[16] = (uintptr_t) gHotSpotVMIntConstants;
- ciHotSpotVMData[17] = gHotSpotVMIntConstantEntryNameOffset;
- ciHotSpotVMData[18] = gHotSpotVMIntConstantEntryValueOffset;
- ciHotSpotVMData[19] = gHotSpotVMIntConstantEntryArrayStride;
+ ciHotSpotVMData[16] = (uintptr_t) jvmciHotSpotVMIntConstants;
+ ciHotSpotVMData[17] = jvmciHotSpotVMIntConstantEntryNameOffset;
+ ciHotSpotVMData[18] = jvmciHotSpotVMIntConstantEntryValueOffset;
+ ciHotSpotVMData[19] = jvmciHotSpotVMIntConstantEntryArrayStride;
- ciHotSpotVMData[20] = (uintptr_t) gHotSpotVMLongConstants;
- ciHotSpotVMData[21] = gHotSpotVMLongConstantEntryNameOffset;
- ciHotSpotVMData[22] = gHotSpotVMLongConstantEntryValueOffset;
- ciHotSpotVMData[23] = gHotSpotVMLongConstantEntryArrayStride;
+ ciHotSpotVMData[20] = (uintptr_t) jvmciHotSpotVMLongConstants;
+ ciHotSpotVMData[21] = jvmciHotSpotVMLongConstantEntryNameOffset;
+ ciHotSpotVMData[22] = jvmciHotSpotVMLongConstantEntryValueOffset;
+ ciHotSpotVMData[23] = jvmciHotSpotVMLongConstantEntryArrayStride;
- ciHotSpotVMData[24] = (uintptr_t) gHotSpotVMAddresses;
- ciHotSpotVMData[25] = gHotSpotVMAddressEntryNameOffset;
- ciHotSpotVMData[26] = gHotSpotVMAddressEntryValueOffset;
- ciHotSpotVMData[27] = gHotSpotVMAddressEntryArrayStride;
+ ciHotSpotVMData[24] = (uintptr_t) jvmciHotSpotVMAddresses;
+ ciHotSpotVMData[25] = jvmciHotSpotVMAddressEntryNameOffset;
+ ciHotSpotVMData[26] = jvmciHotSpotVMAddressEntryValueOffset;
+ ciHotSpotVMData[27] = jvmciHotSpotVMAddressEntryArrayStride;
- // FIXME This is only temporary until the GC code is changed.
- CompilerToVM::_supports_inline_contig_alloc = Universe::heap()->supports_inline_contig_alloc();
- CompilerToVM::_heap_end_addr = CompilerToVM::_supports_inline_contig_alloc ? Universe::heap()->end_addr() : (HeapWord**) -1;
- CompilerToVM::_heap_top_addr = CompilerToVM::_supports_inline_contig_alloc ? Universe::heap()->top_addr() : (HeapWord**) -1;
+ CompilerToVM::Data::initialize();
return (jlong) (address) &ciHotSpotVMData;
C2V_END
@@ -688,18 +743,22 @@ C2V_VMENTRY(jint, installCode, (JNIEnv *jniEnv, jobject, jobject target, jobject
} else {
if (!installed_code_handle.is_null()) {
assert(installed_code_handle->is_a(InstalledCode::klass()), "wrong type");
- CompilerToVM::invalidate_installed_code(installed_code_handle, CHECK_0);
- InstalledCode::set_address(installed_code_handle, (jlong) cb);
- InstalledCode::set_version(installed_code_handle, InstalledCode::version(installed_code_handle) + 1);
- if (cb->is_nmethod()) {
- InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->as_nmethod_or_null()->verified_entry_point());
- } else {
- InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->code_begin());
- }
- if (installed_code_handle->is_a(HotSpotInstalledCode::klass())) {
- HotSpotInstalledCode::set_size(installed_code_handle, cb->size());
- HotSpotInstalledCode::set_codeStart(installed_code_handle, (jlong) cb->code_begin());
- HotSpotInstalledCode::set_codeSize(installed_code_handle, cb->code_size());
+ nmethod::invalidate_installed_code(installed_code_handle, CHECK_0);
+ {
+ // Ensure that all updates to the InstalledCode fields are consistent.
+ MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
+ InstalledCode::set_address(installed_code_handle, (jlong) cb);
+ InstalledCode::set_version(installed_code_handle, InstalledCode::version(installed_code_handle) + 1);
+ if (cb->is_nmethod()) {
+ InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->as_nmethod_or_null()->verified_entry_point());
+ } else {
+ InstalledCode::set_entryPoint(installed_code_handle, (jlong) cb->code_begin());
+ }
+ if (installed_code_handle->is_a(HotSpotInstalledCode::klass())) {
+ HotSpotInstalledCode::set_size(installed_code_handle, cb->size());
+ HotSpotInstalledCode::set_codeStart(installed_code_handle, (jlong) cb->code_begin());
+ HotSpotInstalledCode::set_codeSize(installed_code_handle, cb->code_size());
+ }
}
nmethod* nm = cb->as_nmethod_or_null();
if (nm != NULL && installed_code_handle->is_scavengable()) {
@@ -971,7 +1030,7 @@ C2V_END
C2V_VMENTRY(void, invalidateInstalledCode, (JNIEnv*, jobject, jobject installed_code))
Handle installed_code_handle = JNIHandles::resolve(installed_code);
- CompilerToVM::invalidate_installed_code(installed_code_handle, CHECK);
+ nmethod::invalidate_installed_code(installed_code_handle, CHECK);
C2V_END
C2V_VMENTRY(jobject, readUncompressedOop, (JNIEnv*, jobject, jlong addr))
diff --git a/hotspot/src/share/vm/jvmci/jvmciCompilerToVM.hpp b/hotspot/src/share/vm/jvmci/jvmciCompilerToVM.hpp
index 4acce0bcb93..1947324556b 100644
--- a/hotspot/src/share/vm/jvmci/jvmciCompilerToVM.hpp
+++ b/hotspot/src/share/vm/jvmci/jvmciCompilerToVM.hpp
@@ -29,28 +29,45 @@
#include "jvmci/jvmciJavaClasses.hpp"
class CompilerToVM {
-public:
- /**
- * Tag bits used by lookupKlassInPool to distinguish the types in Java.
- */
- enum Tags {
- KLASS_TAG = 0x0,
- SYMBOL_TAG = 0x1
+ public:
+ class Data {
+ friend class JVMCIVMStructs;
+
+ private:
+ static int InstanceKlass_vtable_start_offset;
+ static int InstanceKlass_vtable_length_offset;
+
+ static int Method_extra_stack_entries;
+
+ static address SharedRuntime_ic_miss_stub;
+ static address SharedRuntime_handle_wrong_method_stub;
+ static address SharedRuntime_deopt_blob_unpack;
+ static address SharedRuntime_deopt_blob_uncommon_trap;
+
+ static size_t ThreadLocalAllocBuffer_alignment_reserve;
+
+ static CollectedHeap* Universe_collectedHeap;
+ static int Universe_base_vtable_size;
+ static address Universe_narrow_oop_base;
+ static int Universe_narrow_oop_shift;
+ static address Universe_narrow_klass_base;
+ static int Universe_narrow_klass_shift;
+ static uintptr_t Universe_verify_oop_mask;
+ static uintptr_t Universe_verify_oop_bits;
+ static void* Universe_non_oop_bits;
+
+ static bool _supports_inline_contig_alloc;
+ static HeapWord** _heap_end_addr;
+ static HeapWord** _heap_top_addr;
+
+ static jbyte* cardtable_start_address;
+ static int cardtable_shift;
+
+ public:
+ static void initialize();
};
- // FIXME This is only temporary until the GC code is changed.
- static bool _supports_inline_contig_alloc;
- static HeapWord** _heap_end_addr;
- static HeapWord** _heap_top_addr;
-
- static intptr_t tag_pointer(Klass* klass) {
- return ((intptr_t) klass) | KLASS_TAG;
- }
-
- static intptr_t tag_pointer(Symbol* symbol) {
- return ((intptr_t) symbol) | SYMBOL_TAG;
- }
-
+ public:
static JNINativeMethod methods[];
static int methods_count();
@@ -97,8 +114,6 @@ public:
static oop get_jvmci_method(const methodHandle& method, TRAPS);
static oop get_jvmci_type(KlassHandle klass, TRAPS);
-
- static void invalidate_installed_code(Handle installedCode, TRAPS);
};
class JavaArgumentUnboxer : public SignatureIterator {
diff --git a/hotspot/src/share/vm/jvmci/jvmciEnv.hpp b/hotspot/src/share/vm/jvmci/jvmciEnv.hpp
index 173729259fe..2bc95d3308c 100644
--- a/hotspot/src/share/vm/jvmci/jvmciEnv.hpp
+++ b/hotspot/src/share/vm/jvmci/jvmciEnv.hpp
@@ -53,6 +53,7 @@ class CompileTask;
class JVMCIEnv : StackObj {
CI_PACKAGE_ACCESS_TO
+ friend class JVMCIVMStructs;
friend class CompileBroker;
friend class Dependencies; // for get_object, during logging
diff --git a/hotspot/src/share/vm/jvmci/jvmciRuntime.cpp b/hotspot/src/share/vm/jvmci/jvmciRuntime.cpp
index b9691e4eb66..fafc68b0ac1 100644
--- a/hotspot/src/share/vm/jvmci/jvmciRuntime.cpp
+++ b/hotspot/src/share/vm/jvmci/jvmciRuntime.cpp
@@ -51,15 +51,10 @@ jobject JVMCIRuntime::_HotSpotJVMCIRuntime_instance = NULL;
bool JVMCIRuntime::_HotSpotJVMCIRuntime_initialized = false;
bool JVMCIRuntime::_well_known_classes_initialized = false;
const char* JVMCIRuntime::_compiler = NULL;
-int JVMCIRuntime::_options_count = 0;
-SystemProperty** JVMCIRuntime::_options = NULL;
int JVMCIRuntime::_trivial_prefixes_count = 0;
char** JVMCIRuntime::_trivial_prefixes = NULL;
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(Handle kind, TRAPS) {
if (kind.is_null()) {
THROW_(vmSymbols::java_lang_NullPointerException(), T_ILLEGAL);
@@ -636,16 +631,6 @@ Handle JVMCIRuntime::callStatic(const char* className, const char* methodName, c
return Handle((oop)result.get_jobject());
}
-static bool jvmci_options_file_exists() {
- const char* home = Arguments::get_java_home();
- size_t path_len = strlen(home) + strlen("/lib/jvmci.options") + 1;
- char path[JVM_MAXPATHLEN];
- char sep = os::file_separator()[0];
- jio_snprintf(path, JVM_MAXPATHLEN, "%s%clib%cjvmci.options", home, sep, sep);
- struct stat st;
- return os::stat(path, &st) == 0;
-}
-
void JVMCIRuntime::initialize_HotSpotJVMCIRuntime(TRAPS) {
if (JNIHandles::resolve(_HotSpotJVMCIRuntime_instance) == NULL) {
#ifdef ASSERT
@@ -657,30 +642,6 @@ void JVMCIRuntime::initialize_HotSpotJVMCIRuntime(TRAPS) {
"HotSpotJVMCIRuntime initialization should only be triggered through JVMCI initialization");
#endif
- bool parseOptionsFile = jvmci_options_file_exists();
- if (_options != NULL || parseOptionsFile) {
- JavaCallArguments args;
- objArrayOop options;
- if (_options != NULL) {
- options = oopFactory::new_objArray(SystemDictionary::String_klass(), _options_count * 2, CHECK);
- for (int i = 0; i < _options_count; i++) {
- SystemProperty* prop = _options[i];
- oop name = java_lang_String::create_oop_from_str(prop->key() + OPTION_PREFIX_LEN, CHECK);
- const char* prop_value = prop->value() != NULL ? prop->value() : "";
- oop value = java_lang_String::create_oop_from_str(prop_value, CHECK);
- options->obj_at_put(i * 2, name);
- options->obj_at_put((i * 2) + 1, value);
- }
- } else {
- options = NULL;
- }
- args.push_oop(options);
- args.push_int(parseOptionsFile);
- callStatic("jdk/vm/ci/options/OptionsParser",
- "parseOptionsFromVM",
- "([Ljava/lang/String;Z)Ljava/lang/Boolean;", &args, CHECK);
- }
-
if (_compiler != NULL) {
JavaCallArguments args;
oop compiler = java_lang_String::create_oop_from_str(_compiler, CHECK);
@@ -818,10 +779,6 @@ JVM_ENTRY(void, JVM_RegisterJVMCINatives(JNIEnv *env, jclass c2vmClass))
{
ThreadToNativeFromVM trans(thread);
-
- // Ensure _non_oop_bits is initialized
- Universe::non_oop_word();
-
env->RegisterNatives(c2vmClass, CompilerToVM::methods, CompilerToVM::methods_count());
}
JVM_END
@@ -902,58 +859,15 @@ void JVMCIRuntime::save_compiler(const char* compiler) {
_compiler = compiler;
}
-void JVMCIRuntime::maybe_print_flags(TRAPS) {
- if (_options != NULL) {
- for (int i = 0; i < _options_count; i++) {
- SystemProperty* p = _options[i];
- const char* name = p->key() + OPTION_PREFIX_LEN;
- if (strcmp(name, "PrintFlags") == 0 || strcmp(name, "ShowFlags") == 0) {
- JVMCIRuntime::initialize_well_known_classes(CHECK);
- HandleMark hm;
- ResourceMark rm;
- JVMCIRuntime::get_HotSpotJVMCIRuntime(CHECK);
- return;
- }
- }
- }
-}
-
-void JVMCIRuntime::save_options(SystemProperty* props) {
- int count = 0;
- SystemProperty* first = NULL;
- for (SystemProperty* p = props; p != NULL; p = p->next()) {
- if (strncmp(p->key(), OPTION_PREFIX, OPTION_PREFIX_LEN) == 0) {
- if (first == NULL) {
- first = p;
- }
- count++;
- }
- }
- if (count != 0) {
- _options_count = count;
- _options = NEW_C_HEAP_ARRAY(SystemProperty*, count, mtCompiler);
- _options[0] = first;
- SystemProperty** insert_pos = _options + 1;
- for (SystemProperty* p = first->next(); p != NULL; p = p->next()) {
- if (strncmp(p->key(), OPTION_PREFIX, OPTION_PREFIX_LEN) == 0) {
- *insert_pos = p;
- insert_pos++;
- }
- }
- assert (insert_pos - _options == count, "must be");
- }
-}
-
-void JVMCIRuntime::shutdown() {
+void JVMCIRuntime::shutdown(TRAPS) {
if (_HotSpotJVMCIRuntime_instance != NULL) {
_shutdown_called = true;
- JavaThread* THREAD = JavaThread::current();
HandleMark hm(THREAD);
- Handle receiver = get_HotSpotJVMCIRuntime(CHECK_ABORT);
+ Handle receiver = get_HotSpotJVMCIRuntime(CHECK);
JavaValue result(T_VOID);
JavaCallArguments args;
args.push_oop(receiver);
- JavaCalls::call_special(&result, receiver->klass(), vmSymbols::shutdown_method_name(), vmSymbols::void_method_signature(), &args, CHECK_ABORT);
+ JavaCalls::call_special(&result, receiver->klass(), vmSymbols::shutdown_method_name(), vmSymbols::void_method_signature(), &args, CHECK);
}
}
@@ -971,32 +885,6 @@ bool JVMCIRuntime::treat_as_trivial(Method* method) {
return false;
}
-void JVMCIRuntime::call_printStackTrace(Handle exception, Thread* thread) {
- assert(exception->is_a(SystemDictionary::Throwable_klass()), "Throwable instance expected");
- JavaValue result(T_VOID);
- JavaCalls::call_virtual(&result,
- exception,
- KlassHandle(thread,
- SystemDictionary::Throwable_klass()),
- vmSymbols::printStackTrace_name(),
- vmSymbols::void_method_signature(),
- thread);
-}
-
-void JVMCIRuntime::abort_on_pending_exception(Handle exception, const char* message, bool dump_core) {
- Thread* THREAD = Thread::current();
- CLEAR_PENDING_EXCEPTION;
- tty->print_raw_cr(message);
- call_printStackTrace(exception, THREAD);
-
- // Give other aborting threads to also print their stack traces.
- // This can be very useful when debugging class initialization
- // failures.
- os::sleep(THREAD, 200, false);
-
- vm_abort(dump_core);
-}
-
void JVMCIRuntime::parse_lines(char* path, ParseClosure* closure, bool warnStatFailure) {
struct stat st;
if (::stat(path, &st) == 0 && (st.st_mode & S_IFREG) == S_IFREG) { // exists & is regular file
diff --git a/hotspot/src/share/vm/jvmci/jvmciRuntime.hpp b/hotspot/src/share/vm/jvmci/jvmciRuntime.hpp
index 9e69965f19d..17476d65af9 100644
--- a/hotspot/src/share/vm/jvmci/jvmciRuntime.hpp
+++ b/hotspot/src/share/vm/jvmci/jvmciRuntime.hpp
@@ -71,8 +71,6 @@ class JVMCIRuntime: public AllStatic {
static bool _HotSpotJVMCIRuntime_initialized;
static bool _well_known_classes_initialized;
static const char* _compiler;
- static int _options_count;
- static SystemProperty** _options;
static int _trivial_prefixes_count;
static char** _trivial_prefixes;
@@ -99,20 +97,6 @@ class JVMCIRuntime: public AllStatic {
*/
static void save_compiler(const char* compiler);
- /**
- * Saves the value of the system properties starting with "jvmci.option." for processing
- * when JVMCI is initialized.
- *
- * @param props the head of the system property list
- */
- static void save_options(SystemProperty* props);
-
- /**
- * If either the PrintFlags or ShowFlags JVMCI option is present,
- * then JVMCI is initialized to show the help message.
- */
- static void maybe_print_flags(TRAPS);
-
static bool is_HotSpotJVMCIRuntime_initialized() { return _HotSpotJVMCIRuntime_initialized; }
/**
@@ -145,7 +129,7 @@ class JVMCIRuntime: public AllStatic {
static void metadata_do(void f(Metadata*));
- static void shutdown();
+ static void shutdown(TRAPS);
static bool shutdown_called() {
return _shutdown_called;
@@ -154,34 +138,6 @@ class JVMCIRuntime: public AllStatic {
static bool treat_as_trivial(Method* method);
static void parse_lines(char* path, ParseClosure* closure, bool warnStatFailure);
- /**
- * Aborts the VM due to an unexpected exception.
- */
- static void abort_on_pending_exception(Handle exception, const char* message, bool dump_core = false);
-
- /**
- * Calls Throwable.printStackTrace() on a given exception.
- */
- static void call_printStackTrace(Handle exception, Thread* thread);
-
-#define CHECK_ABORT THREAD); \
- if (HAS_PENDING_EXCEPTION) { \
- char buf[256]; \
- jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
- JVMCIRuntime::abort_on_pending_exception(PENDING_EXCEPTION, buf); \
- return; \
- } \
- (void)(0
-
-#define CHECK_ABORT_(result) THREAD); \
- if (HAS_PENDING_EXCEPTION) { \
- char buf[256]; \
- jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
- JVMCIRuntime::abort_on_pending_exception(PENDING_EXCEPTION, buf); \
- return result; \
- } \
- (void)(0
-
static BasicType kindToBasicType(Handle kind, TRAPS);
// The following routines are all called from compiled JVMCI code
diff --git a/hotspot/src/share/vm/jvmci/vmStructs_jvmci.cpp b/hotspot/src/share/vm/jvmci/vmStructs_jvmci.cpp
new file mode 100644
index 00000000000..84f7dca06ef
--- /dev/null
+++ b/hotspot/src/share/vm/jvmci/vmStructs_jvmci.cpp
@@ -0,0 +1,880 @@
+/*
+ * 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.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "code/codeBlob.hpp"
+#include "compiler/abstractCompiler.hpp"
+#include "compiler/compileBroker.hpp"
+#include "jvmci/jvmciCodeInstaller.hpp"
+#include "jvmci/jvmciCompilerToVM.hpp"
+#include "jvmci/jvmciEnv.hpp"
+#include "jvmci/jvmciRuntime.hpp"
+#include "jvmci/vmStructs_jvmci.hpp"
+#include "oops/oop.hpp"
+#include "oops/objArrayKlass.hpp"
+#include "runtime/globals.hpp"
+#include "runtime/sharedRuntime.hpp"
+#include "runtime/thread.hpp"
+#include "runtime/vm_version.hpp"
+
+#if INCLUDE_ALL_GCS
+#include "gc/g1/g1SATBCardTableModRefBS.hpp"
+#include "gc/g1/heapRegion.hpp"
+#endif
+
+
+#define VM_STRUCTS(nonstatic_field, static_field, unchecked_nonstatic_field, volatile_nonstatic_field) \
+ static_field(CompilerToVM::Data, InstanceKlass_vtable_start_offset, int) \
+ static_field(CompilerToVM::Data, InstanceKlass_vtable_length_offset, int) \
+ \
+ static_field(CompilerToVM::Data, Method_extra_stack_entries, int) \
+ \
+ static_field(CompilerToVM::Data, SharedRuntime_ic_miss_stub, address) \
+ static_field(CompilerToVM::Data, SharedRuntime_handle_wrong_method_stub, address) \
+ static_field(CompilerToVM::Data, SharedRuntime_deopt_blob_unpack, address) \
+ static_field(CompilerToVM::Data, SharedRuntime_deopt_blob_uncommon_trap, address) \
+ \
+ static_field(CompilerToVM::Data, ThreadLocalAllocBuffer_alignment_reserve, size_t) \
+ \
+ static_field(CompilerToVM::Data, Universe_collectedHeap, CollectedHeap*) \
+ static_field(CompilerToVM::Data, Universe_base_vtable_size, int) \
+ static_field(CompilerToVM::Data, Universe_narrow_oop_base, address) \
+ static_field(CompilerToVM::Data, Universe_narrow_oop_shift, int) \
+ static_field(CompilerToVM::Data, Universe_narrow_klass_base, address) \
+ static_field(CompilerToVM::Data, Universe_narrow_klass_shift, int) \
+ static_field(CompilerToVM::Data, Universe_non_oop_bits, void*) \
+ static_field(CompilerToVM::Data, Universe_verify_oop_mask, uintptr_t) \
+ static_field(CompilerToVM::Data, Universe_verify_oop_bits, uintptr_t) \
+ \
+ static_field(CompilerToVM::Data, _supports_inline_contig_alloc, bool) \
+ static_field(CompilerToVM::Data, _heap_end_addr, HeapWord**) \
+ static_field(CompilerToVM::Data, _heap_top_addr, HeapWord**) \
+ \
+ static_field(CompilerToVM::Data, cardtable_start_address, jbyte*) \
+ static_field(CompilerToVM::Data, cardtable_shift, int) \
+ \
+ static_field(Abstract_VM_Version, _features, uint64_t) \
+ \
+ nonstatic_field(Array, _length, int) \
+ unchecked_nonstatic_field(Array, _data, sizeof(u1)) \
+ unchecked_nonstatic_field(Array, _data, sizeof(u2)) \
+ nonstatic_field(Array, _length, int) \
+ nonstatic_field(Array, _data[0], Klass*) \
+ \
+ volatile_nonstatic_field(BasicLock, _displaced_header, markOop) \
+ \
+ static_field(CodeCache, _low_bound, address) \
+ static_field(CodeCache, _high_bound, address) \
+ \
+ nonstatic_field(CollectedHeap, _total_collections, unsigned int) \
+ \
+ nonstatic_field(CompileTask, _num_inlined_bytecodes, int) \
+ \
+ nonstatic_field(ConstantPool, _tags, Array*) \
+ nonstatic_field(ConstantPool, _pool_holder, InstanceKlass*) \
+ nonstatic_field(ConstantPool, _length, int) \
+ \
+ nonstatic_field(ConstMethod, _constants, ConstantPool*) \
+ nonstatic_field(ConstMethod, _flags, u2) \
+ nonstatic_field(ConstMethod, _code_size, u2) \
+ nonstatic_field(ConstMethod, _name_index, u2) \
+ nonstatic_field(ConstMethod, _signature_index, u2) \
+ nonstatic_field(ConstMethod, _max_stack, u2) \
+ nonstatic_field(ConstMethod, _max_locals, u2) \
+ \
+ nonstatic_field(DataLayout, _header._struct._tag, u1) \
+ nonstatic_field(DataLayout, _header._struct._flags, u1) \
+ nonstatic_field(DataLayout, _header._struct._bci, u2) \
+ nonstatic_field(DataLayout, _cells[0], intptr_t) \
+ \
+ nonstatic_field(Deoptimization::UnrollBlock, _size_of_deoptimized_frame, int) \
+ nonstatic_field(Deoptimization::UnrollBlock, _caller_adjustment, int) \
+ nonstatic_field(Deoptimization::UnrollBlock, _number_of_frames, int) \
+ nonstatic_field(Deoptimization::UnrollBlock, _total_frame_sizes, int) \
+ nonstatic_field(Deoptimization::UnrollBlock, _frame_sizes, intptr_t*) \
+ nonstatic_field(Deoptimization::UnrollBlock, _frame_pcs, address*) \
+ nonstatic_field(Deoptimization::UnrollBlock, _initial_info, intptr_t) \
+ nonstatic_field(Deoptimization::UnrollBlock, _unpack_kind, int) \
+ \
+ nonstatic_field(ExceptionTableElement, start_pc, u2) \
+ nonstatic_field(ExceptionTableElement, end_pc, u2) \
+ nonstatic_field(ExceptionTableElement, handler_pc, u2) \
+ nonstatic_field(ExceptionTableElement, catch_type_index, u2) \
+ \
+ nonstatic_field(Flag, _type, const char*) \
+ nonstatic_field(Flag, _name, const char*) \
+ unchecked_nonstatic_field(Flag, _addr, sizeof(void*)) \
+ nonstatic_field(Flag, _flags, Flag::Flags) \
+ static_field(Flag, flags, Flag*) \
+ \
+ nonstatic_field(InstanceKlass, _fields, Array*) \
+ nonstatic_field(InstanceKlass, _constants, ConstantPool*) \
+ nonstatic_field(InstanceKlass, _source_file_name_index, u2) \
+ nonstatic_field(InstanceKlass, _init_state, u1) \
+ \
+ volatile_nonstatic_field(JavaFrameAnchor, _last_Java_sp, intptr_t*) \
+ volatile_nonstatic_field(JavaFrameAnchor, _last_Java_pc, address) \
+ \
+ nonstatic_field(JavaThread, _threadObj, oop) \
+ nonstatic_field(JavaThread, _anchor, JavaFrameAnchor) \
+ nonstatic_field(JavaThread, _vm_result, oop) \
+ volatile_nonstatic_field(JavaThread, _exception_oop, oop) \
+ volatile_nonstatic_field(JavaThread, _exception_pc, address) \
+ volatile_nonstatic_field(JavaThread, _is_method_handle_return, int) \
+ nonstatic_field(JavaThread, _osthread, OSThread*) \
+ nonstatic_field(JavaThread, _satb_mark_queue, SATBMarkQueue) \
+ nonstatic_field(JavaThread, _dirty_card_queue, DirtyCardQueue) \
+ nonstatic_field(JavaThread, _pending_deoptimization, int) \
+ nonstatic_field(JavaThread, _pending_failed_speculation, oop) \
+ nonstatic_field(JavaThread, _pending_transfer_to_interpreter, bool) \
+ nonstatic_field(JavaThread, _jvmci_counters, jlong*) \
+ \
+ static_field(java_lang_Class, _klass_offset, int) \
+ static_field(java_lang_Class, _array_klass_offset, int) \
+ \
+ nonstatic_field(JVMCIEnv, _task, CompileTask*) \
+ nonstatic_field(JVMCIEnv, _jvmti_can_hotswap_or_post_breakpoint, bool) \
+ \
+ nonstatic_field(Klass, _secondary_super_cache, Klass*) \
+ nonstatic_field(Klass, _secondary_supers, Array*) \
+ nonstatic_field(Klass, _super, Klass*) \
+ nonstatic_field(Klass, _super_check_offset, juint) \
+ nonstatic_field(Klass, _subklass, Klass*) \
+ nonstatic_field(Klass, _layout_helper, jint) \
+ nonstatic_field(Klass, _prototype_header, markOop) \
+ nonstatic_field(Klass, _next_sibling, Klass*) \
+ nonstatic_field(Klass, _java_mirror, oop) \
+ nonstatic_field(Klass, _modifier_flags, jint) \
+ nonstatic_field(Klass, _access_flags, AccessFlags) \
+ \
+ nonstatic_field(LocalVariableTableElement, start_bci, u2) \
+ nonstatic_field(LocalVariableTableElement, length, u2) \
+ nonstatic_field(LocalVariableTableElement, name_cp_index, u2) \
+ nonstatic_field(LocalVariableTableElement, descriptor_cp_index, u2) \
+ nonstatic_field(LocalVariableTableElement, signature_cp_index, u2) \
+ nonstatic_field(LocalVariableTableElement, slot, u2) \
+ \
+ nonstatic_field(Method, _constMethod, ConstMethod*) \
+ nonstatic_field(Method, _method_data, MethodData*) \
+ nonstatic_field(Method, _method_counters, MethodCounters*) \
+ nonstatic_field(Method, _access_flags, AccessFlags) \
+ nonstatic_field(Method, _vtable_index, int) \
+ nonstatic_field(Method, _intrinsic_id, u2) \
+ nonstatic_field(Method, _flags, u2) \
+ volatile_nonstatic_field(Method, _code, nmethod*) \
+ volatile_nonstatic_field(Method, _from_compiled_entry, address) \
+ \
+ nonstatic_field(MethodCounters, _invocation_counter, InvocationCounter) \
+ nonstatic_field(MethodCounters, _backedge_counter, InvocationCounter) \
+ \
+ nonstatic_field(MethodData, _size, int) \
+ nonstatic_field(MethodData, _data_size, int) \
+ nonstatic_field(MethodData, _data[0], intptr_t) \
+ nonstatic_field(MethodData, _trap_hist._array[0], u1) \
+ nonstatic_field(MethodData, _jvmci_ir_size, int) \
+ \
+ nonstatic_field(nmethod, _verified_entry_point, address) \
+ nonstatic_field(nmethod, _comp_level, int) \
+ \
+ nonstatic_field(ObjArrayKlass, _element_klass, Klass*) \
+ \
+ volatile_nonstatic_field(oopDesc, _mark, markOop) \
+ volatile_nonstatic_field(oopDesc, _metadata._klass, Klass*) \
+ \
+ static_field(os, _polling_page, address) \
+ \
+ volatile_nonstatic_field(OSThread, _interrupted, jint) \
+ \
+ static_field(StubRoutines, _verify_oop_count, jint) \
+ \
+ static_field(StubRoutines, _jbyte_arraycopy, address) \
+ static_field(StubRoutines, _jshort_arraycopy, address) \
+ static_field(StubRoutines, _jint_arraycopy, address) \
+ static_field(StubRoutines, _jlong_arraycopy, address) \
+ static_field(StubRoutines, _oop_arraycopy, address) \
+ static_field(StubRoutines, _oop_arraycopy_uninit, address) \
+ static_field(StubRoutines, _jbyte_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _jshort_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _jint_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _jlong_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _oop_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _oop_disjoint_arraycopy_uninit, address) \
+ static_field(StubRoutines, _arrayof_jbyte_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_jshort_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_jint_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_jlong_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_oop_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_oop_arraycopy_uninit, address) \
+ static_field(StubRoutines, _arrayof_jbyte_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_jshort_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_jint_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_jlong_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_oop_disjoint_arraycopy, address) \
+ static_field(StubRoutines, _arrayof_oop_disjoint_arraycopy_uninit, address) \
+ static_field(StubRoutines, _checkcast_arraycopy, address) \
+ static_field(StubRoutines, _checkcast_arraycopy_uninit, address) \
+ static_field(StubRoutines, _unsafe_arraycopy, address) \
+ static_field(StubRoutines, _generic_arraycopy, address) \
+ \
+ static_field(StubRoutines, _aescrypt_encryptBlock, address) \
+ static_field(StubRoutines, _aescrypt_decryptBlock, address) \
+ static_field(StubRoutines, _cipherBlockChaining_encryptAESCrypt, address) \
+ static_field(StubRoutines, _cipherBlockChaining_decryptAESCrypt, address) \
+ static_field(StubRoutines, _updateBytesCRC32, address) \
+ static_field(StubRoutines, _crc_table_adr, address) \
+ \
+ nonstatic_field(Thread, _tlab, ThreadLocalAllocBuffer) \
+ nonstatic_field(Thread, _allocated_bytes, jlong) \
+ \
+ nonstatic_field(ThreadLocalAllocBuffer, _start, HeapWord*) \
+ nonstatic_field(ThreadLocalAllocBuffer, _top, HeapWord*) \
+ nonstatic_field(ThreadLocalAllocBuffer, _end, HeapWord*) \
+ nonstatic_field(ThreadLocalAllocBuffer, _pf_top, HeapWord*) \
+ nonstatic_field(ThreadLocalAllocBuffer, _desired_size, size_t) \
+ nonstatic_field(ThreadLocalAllocBuffer, _refill_waste_limit, size_t) \
+ nonstatic_field(ThreadLocalAllocBuffer, _number_of_refills, unsigned) \
+ nonstatic_field(ThreadLocalAllocBuffer, _fast_refill_waste, unsigned) \
+ nonstatic_field(ThreadLocalAllocBuffer, _slow_allocations, unsigned) \
+ \
+ nonstatic_field(ThreadShadow, _pending_exception, oop) \
+ \
+ static_field(vmSymbols, _symbols[0], Symbol*) \
+ \
+ nonstatic_field(vtableEntry, _method, Method*) \
+
+#define VM_TYPES(declare_type, declare_toplevel_type, declare_integer_type, declare_unsigned_integer_type) \
+ declare_integer_type(bool) \
+ declare_unsigned_integer_type(size_t) \
+ declare_integer_type(intx) \
+ declare_unsigned_integer_type(uintx) \
+ \
+ declare_toplevel_type(BasicLock) \
+ declare_toplevel_type(CompilerToVM) \
+ declare_toplevel_type(ExceptionTableElement) \
+ declare_toplevel_type(Flag) \
+ declare_toplevel_type(Flag*) \
+ declare_toplevel_type(JVMCIEnv) \
+ declare_toplevel_type(LocalVariableTableElement) \
+ declare_toplevel_type(narrowKlass) \
+ declare_toplevel_type(Symbol*) \
+ declare_toplevel_type(vtableEntry) \
+ \
+ declare_toplevel_type(oopDesc) \
+ declare_type(arrayOopDesc, oopDesc) \
+ \
+ declare_toplevel_type(MetaspaceObj) \
+ declare_type(Metadata, MetaspaceObj) \
+ declare_type(Klass, Metadata) \
+ declare_type(InstanceKlass, Klass) \
+ declare_type(ConstantPool, Metadata) \
+
+#define VM_INT_CONSTANTS(declare_constant, declare_constant_with_value, declare_preprocessor_constant) \
+ declare_preprocessor_constant("ASSERT", DEBUG_ONLY(1) NOT_DEBUG(0)) \
+ declare_preprocessor_constant("FIELDINFO_TAG_SIZE", FIELDINFO_TAG_SIZE) \
+ declare_preprocessor_constant("STACK_BIAS", STACK_BIAS) \
+ \
+ declare_constant(CompLevel_full_optimization) \
+ declare_constant(HeapWordSize) \
+ declare_constant(InvocationEntryBci) \
+ declare_constant(LogKlassAlignmentInBytes) \
+ \
+ declare_constant(JVM_ACC_WRITTEN_FLAGS) \
+ declare_constant(JVM_ACC_MONITOR_MATCH) \
+ declare_constant(JVM_ACC_HAS_MONITOR_BYTECODES) \
+ declare_constant(JVM_ACC_HAS_FINALIZER) \
+ declare_constant(JVM_ACC_FIELD_INTERNAL) \
+ declare_constant(JVM_ACC_FIELD_STABLE) \
+ declare_constant(JVM_ACC_FIELD_HAS_GENERIC_SIGNATURE) \
+ declare_preprocessor_constant("JVM_ACC_SYNTHETIC", JVM_ACC_SYNTHETIC) \
+ declare_preprocessor_constant("JVM_RECOGNIZED_FIELD_MODIFIERS", JVM_RECOGNIZED_FIELD_MODIFIERS) \
+ \
+ declare_constant(JVM_CONSTANT_Utf8) \
+ declare_constant(JVM_CONSTANT_Unicode) \
+ declare_constant(JVM_CONSTANT_Integer) \
+ declare_constant(JVM_CONSTANT_Float) \
+ declare_constant(JVM_CONSTANT_Long) \
+ declare_constant(JVM_CONSTANT_Double) \
+ declare_constant(JVM_CONSTANT_Class) \
+ declare_constant(JVM_CONSTANT_String) \
+ declare_constant(JVM_CONSTANT_Fieldref) \
+ declare_constant(JVM_CONSTANT_Methodref) \
+ declare_constant(JVM_CONSTANT_InterfaceMethodref) \
+ declare_constant(JVM_CONSTANT_NameAndType) \
+ declare_constant(JVM_CONSTANT_MethodHandle) \
+ declare_constant(JVM_CONSTANT_MethodType) \
+ declare_constant(JVM_CONSTANT_InvokeDynamic) \
+ declare_constant(JVM_CONSTANT_ExternalMax) \
+ \
+ declare_constant(JVM_CONSTANT_Invalid) \
+ declare_constant(JVM_CONSTANT_InternalMin) \
+ declare_constant(JVM_CONSTANT_UnresolvedClass) \
+ declare_constant(JVM_CONSTANT_ClassIndex) \
+ declare_constant(JVM_CONSTANT_StringIndex) \
+ declare_constant(JVM_CONSTANT_UnresolvedClassInError) \
+ declare_constant(JVM_CONSTANT_MethodHandleInError) \
+ declare_constant(JVM_CONSTANT_MethodTypeInError) \
+ declare_constant(JVM_CONSTANT_InternalMax) \
+ \
+ declare_constant(ArrayData::array_len_off_set) \
+ declare_constant(ArrayData::array_start_off_set) \
+ \
+ declare_constant(BitData::exception_seen_flag) \
+ declare_constant(BitData::null_seen_flag) \
+ declare_constant(BranchData::not_taken_off_set) \
+ \
+ declare_constant_with_value("CardTableModRefBS::dirty_card", CardTableModRefBS::dirty_card_val()) \
+ \
+ declare_constant(CodeInstaller::VERIFIED_ENTRY) \
+ declare_constant(CodeInstaller::UNVERIFIED_ENTRY) \
+ declare_constant(CodeInstaller::OSR_ENTRY) \
+ declare_constant(CodeInstaller::EXCEPTION_HANDLER_ENTRY) \
+ declare_constant(CodeInstaller::DEOPT_HANDLER_ENTRY) \
+ declare_constant(CodeInstaller::INVOKEINTERFACE) \
+ declare_constant(CodeInstaller::INVOKEVIRTUAL) \
+ declare_constant(CodeInstaller::INVOKESTATIC) \
+ declare_constant(CodeInstaller::INVOKESPECIAL) \
+ declare_constant(CodeInstaller::INLINE_INVOKE) \
+ declare_constant(CodeInstaller::POLL_NEAR) \
+ declare_constant(CodeInstaller::POLL_RETURN_NEAR) \
+ declare_constant(CodeInstaller::POLL_FAR) \
+ declare_constant(CodeInstaller::POLL_RETURN_FAR) \
+ declare_constant(CodeInstaller::CARD_TABLE_SHIFT) \
+ declare_constant(CodeInstaller::CARD_TABLE_ADDRESS) \
+ declare_constant(CodeInstaller::HEAP_TOP_ADDRESS) \
+ declare_constant(CodeInstaller::HEAP_END_ADDRESS) \
+ declare_constant(CodeInstaller::NARROW_KLASS_BASE_ADDRESS) \
+ declare_constant(CodeInstaller::CRC_TABLE_ADDRESS) \
+ declare_constant(CodeInstaller::INVOKE_INVALID) \
+ \
+ declare_constant(ConstantPool::CPCACHE_INDEX_TAG) \
+ \
+ declare_constant(ConstMethod::_has_linenumber_table) \
+ declare_constant(ConstMethod::_has_localvariable_table) \
+ declare_constant(ConstMethod::_has_exception_table) \
+ \
+ declare_constant(CounterData::count_off) \
+ \
+ declare_constant(DataLayout::cell_size) \
+ declare_constant(DataLayout::no_tag) \
+ declare_constant(DataLayout::bit_data_tag) \
+ declare_constant(DataLayout::counter_data_tag) \
+ declare_constant(DataLayout::jump_data_tag) \
+ declare_constant(DataLayout::receiver_type_data_tag) \
+ declare_constant(DataLayout::virtual_call_data_tag) \
+ declare_constant(DataLayout::ret_data_tag) \
+ declare_constant(DataLayout::branch_data_tag) \
+ declare_constant(DataLayout::multi_branch_data_tag) \
+ declare_constant(DataLayout::arg_info_data_tag) \
+ declare_constant(DataLayout::call_type_data_tag) \
+ declare_constant(DataLayout::virtual_call_type_data_tag) \
+ declare_constant(DataLayout::parameters_type_data_tag) \
+ declare_constant(DataLayout::speculative_trap_data_tag) \
+ \
+ declare_constant(Deoptimization::Unpack_deopt) \
+ declare_constant(Deoptimization::Unpack_exception) \
+ declare_constant(Deoptimization::Unpack_uncommon_trap) \
+ declare_constant(Deoptimization::Unpack_reexecute) \
+ \
+ declare_constant(Deoptimization::_action_bits) \
+ declare_constant(Deoptimization::_reason_bits) \
+ declare_constant(Deoptimization::_debug_id_bits) \
+ declare_constant(Deoptimization::_action_shift) \
+ declare_constant(Deoptimization::_reason_shift) \
+ declare_constant(Deoptimization::_debug_id_shift) \
+ \
+ declare_constant(Deoptimization::Action_none) \
+ declare_constant(Deoptimization::Action_maybe_recompile) \
+ declare_constant(Deoptimization::Action_reinterpret) \
+ declare_constant(Deoptimization::Action_make_not_entrant) \
+ declare_constant(Deoptimization::Action_make_not_compilable) \
+ \
+ declare_constant(Deoptimization::Reason_none) \
+ declare_constant(Deoptimization::Reason_null_check) \
+ declare_constant(Deoptimization::Reason_range_check) \
+ declare_constant(Deoptimization::Reason_class_check) \
+ declare_constant(Deoptimization::Reason_array_check) \
+ declare_constant(Deoptimization::Reason_unreached0) \
+ declare_constant(Deoptimization::Reason_constraint) \
+ declare_constant(Deoptimization::Reason_div0_check) \
+ declare_constant(Deoptimization::Reason_loop_limit_check) \
+ declare_constant(Deoptimization::Reason_type_checked_inlining) \
+ declare_constant(Deoptimization::Reason_optimized_type_check) \
+ declare_constant(Deoptimization::Reason_aliasing) \
+ declare_constant(Deoptimization::Reason_transfer_to_interpreter) \
+ declare_constant(Deoptimization::Reason_not_compiled_exception_handler) \
+ declare_constant(Deoptimization::Reason_unresolved) \
+ declare_constant(Deoptimization::Reason_jsr_mismatch) \
+ declare_constant(Deoptimization::Reason_LIMIT) \
+ \
+ declare_constant_with_value("dirtyCardQueueBufferOffset", in_bytes(DirtyCardQueue::byte_offset_of_buf())) \
+ declare_constant_with_value("dirtyCardQueueIndexOffset", in_bytes(DirtyCardQueue::byte_offset_of_index())) \
+ \
+ declare_constant(FieldInfo::access_flags_offset) \
+ declare_constant(FieldInfo::name_index_offset) \
+ declare_constant(FieldInfo::signature_index_offset) \
+ declare_constant(FieldInfo::initval_index_offset) \
+ declare_constant(FieldInfo::low_packed_offset) \
+ declare_constant(FieldInfo::high_packed_offset) \
+ declare_constant(FieldInfo::field_slots) \
+ \
+ declare_constant(InstanceKlass::linked) \
+ declare_constant(InstanceKlass::fully_initialized) \
+ \
+ declare_constant(JumpData::taken_off_set) \
+ declare_constant(JumpData::displacement_off_set) \
+ \
+ declare_constant(JVMCIEnv::ok) \
+ declare_constant(JVMCIEnv::dependencies_failed) \
+ declare_constant(JVMCIEnv::dependencies_invalid) \
+ declare_constant(JVMCIEnv::cache_full) \
+ declare_constant(JVMCIEnv::code_too_large) \
+ \
+ declare_constant(Klass::_lh_neutral_value) \
+ declare_constant(Klass::_lh_instance_slow_path_bit) \
+ declare_constant(Klass::_lh_log2_element_size_shift) \
+ declare_constant(Klass::_lh_log2_element_size_mask) \
+ declare_constant(Klass::_lh_element_type_shift) \
+ declare_constant(Klass::_lh_element_type_mask) \
+ declare_constant(Klass::_lh_header_size_shift) \
+ declare_constant(Klass::_lh_header_size_mask) \
+ declare_constant(Klass::_lh_array_tag_shift) \
+ declare_constant(Klass::_lh_array_tag_type_value) \
+ declare_constant(Klass::_lh_array_tag_obj_value) \
+ \
+ declare_constant(markOopDesc::no_hash) \
+ \
+ declare_constant(Method::_jfr_towrite) \
+ declare_constant(Method::_caller_sensitive) \
+ declare_constant(Method::_force_inline) \
+ declare_constant(Method::_dont_inline) \
+ declare_constant(Method::_hidden) \
+ \
+ declare_constant(Method::nonvirtual_vtable_index) \
+ declare_constant(Method::invalid_vtable_index) \
+ \
+ declare_constant(MultiBranchData::per_case_cell_count) \
+ \
+ declare_constant(ReceiverTypeData::nonprofiled_count_off_set) \
+ declare_constant(ReceiverTypeData::receiver_type_row_cell_count) \
+ declare_constant(ReceiverTypeData::receiver0_offset) \
+ declare_constant(ReceiverTypeData::count0_offset) \
+ \
+ declare_constant_with_value("satbMarkQueueBufferOffset", in_bytes(SATBMarkQueue::byte_offset_of_buf())) \
+ declare_constant_with_value("satbMarkQueueIndexOffset", in_bytes(SATBMarkQueue::byte_offset_of_index())) \
+ declare_constant_with_value("satbMarkQueueActiveOffset", in_bytes(SATBMarkQueue::byte_offset_of_active())) \
+ \
+ declare_constant(vmIntrinsics::_invokeBasic) \
+ declare_constant(vmIntrinsics::_linkToVirtual) \
+ declare_constant(vmIntrinsics::_linkToStatic) \
+ declare_constant(vmIntrinsics::_linkToSpecial) \
+ declare_constant(vmIntrinsics::_linkToInterface) \
+ \
+ declare_constant(vmSymbols::FIRST_SID) \
+ declare_constant(vmSymbols::SID_LIMIT) \
+
+#define VM_LONG_CONSTANTS(declare_constant, declare_preprocessor_constant) \
+ declare_constant(InvocationCounter::count_increment) \
+ declare_constant(InvocationCounter::count_shift) \
+ \
+ declare_constant(markOopDesc::hash_shift) \
+ \
+ declare_constant(markOopDesc::biased_lock_mask_in_place) \
+ declare_constant(markOopDesc::age_mask_in_place) \
+ declare_constant(markOopDesc::epoch_mask_in_place) \
+ declare_constant(markOopDesc::hash_mask) \
+ declare_constant(markOopDesc::hash_mask_in_place) \
+ \
+ declare_constant(markOopDesc::unlocked_value) \
+ declare_constant(markOopDesc::biased_lock_pattern) \
+ \
+ declare_constant(markOopDesc::no_hash_in_place) \
+ declare_constant(markOopDesc::no_lock_in_place) \
+
+#define VM_ADDRESSES(declare_address, declare_preprocessor_address, declare_function) \
+ declare_function(SharedRuntime::register_finalizer) \
+ declare_function(SharedRuntime::exception_handler_for_return_address) \
+ declare_function(SharedRuntime::OSR_migration_end) \
+ declare_function(SharedRuntime::dsin) \
+ declare_function(SharedRuntime::dcos) \
+ declare_function(SharedRuntime::dtan) \
+ declare_function(SharedRuntime::dexp) \
+ declare_function(SharedRuntime::dlog) \
+ declare_function(SharedRuntime::dlog10) \
+ declare_function(SharedRuntime::dpow) \
+ \
+ declare_function(os::dll_load) \
+ declare_function(os::dll_lookup) \
+ declare_function(os::javaTimeMillis) \
+ declare_function(os::javaTimeNanos) \
+ \
+ declare_function(Deoptimization::fetch_unroll_info) \
+ COMPILER2_PRESENT(declare_function(Deoptimization::uncommon_trap)) \
+ declare_function(Deoptimization::unpack_frames) \
+ \
+ declare_function(JVMCIRuntime::new_instance) \
+ declare_function(JVMCIRuntime::new_array) \
+ declare_function(JVMCIRuntime::new_multi_array) \
+ declare_function(JVMCIRuntime::dynamic_new_array) \
+ declare_function(JVMCIRuntime::dynamic_new_instance) \
+ \
+ declare_function(JVMCIRuntime::thread_is_interrupted) \
+ declare_function(JVMCIRuntime::vm_message) \
+ declare_function(JVMCIRuntime::identity_hash_code) \
+ declare_function(JVMCIRuntime::exception_handler_for_pc) \
+ declare_function(JVMCIRuntime::monitorenter) \
+ declare_function(JVMCIRuntime::monitorexit) \
+ declare_function(JVMCIRuntime::create_null_exception) \
+ declare_function(JVMCIRuntime::create_out_of_bounds_exception) \
+ declare_function(JVMCIRuntime::log_primitive) \
+ declare_function(JVMCIRuntime::log_object) \
+ declare_function(JVMCIRuntime::log_printf) \
+ declare_function(JVMCIRuntime::vm_error) \
+ declare_function(JVMCIRuntime::load_and_clear_exception) \
+ declare_function(JVMCIRuntime::write_barrier_pre) \
+ declare_function(JVMCIRuntime::write_barrier_post) \
+ declare_function(JVMCIRuntime::validate_object) \
+ \
+ declare_function(JVMCIRuntime::test_deoptimize_call_int)
+
+
+#if INCLUDE_ALL_GCS
+
+#define VM_STRUCTS_G1(nonstatic_field, static_field) \
+ static_field(HeapRegion, LogOfHRGrainBytes, int)
+
+#define VM_INT_CONSTANTS_G1(declare_constant, declare_constant_with_value, declare_preprocessor_constant) \
+ declare_constant_with_value("G1SATBCardTableModRefBS::g1_young_gen", G1SATBCardTableModRefBS::g1_young_card_val())
+
+#endif // INCLUDE_ALL_GCS
+
+
+#ifdef TARGET_OS_FAMILY_linux
+
+#define VM_ADDRESSES_OS(declare_address, declare_preprocessor_address, declare_function) \
+ declare_preprocessor_address("RTLD_DEFAULT", RTLD_DEFAULT)
+
+#endif // TARGET_OS_FAMILY_linux
+
+
+#ifdef TARGET_OS_FAMILY_bsd
+
+#define VM_ADDRESSES_OS(declare_address, declare_preprocessor_address, declare_function) \
+ declare_preprocessor_address("RTLD_DEFAULT", RTLD_DEFAULT)
+
+#endif // TARGET_OS_FAMILY_bsd
+
+
+#ifdef TARGET_ARCH_x86
+
+#define VM_STRUCTS_CPU(nonstatic_field, static_field, unchecked_nonstatic_field, volatile_nonstatic_field, nonproduct_nonstatic_field, c2_nonstatic_field, unchecked_c1_static_field, unchecked_c2_static_field) \
+ volatile_nonstatic_field(JavaFrameAnchor, _last_Java_fp, intptr_t*)
+
+#define VM_INT_CONSTANTS_CPU(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant) \
+ LP64_ONLY(declare_constant(frame::arg_reg_save_area_bytes)) \
+ declare_constant(frame::interpreter_frame_sender_sp_offset) \
+ declare_constant(frame::interpreter_frame_last_sp_offset) \
+ declare_constant(VM_Version::CPU_CX8) \
+ declare_constant(VM_Version::CPU_CMOV) \
+ declare_constant(VM_Version::CPU_FXSR) \
+ declare_constant(VM_Version::CPU_HT) \
+ declare_constant(VM_Version::CPU_MMX) \
+ declare_constant(VM_Version::CPU_3DNOW_PREFETCH) \
+ declare_constant(VM_Version::CPU_SSE) \
+ declare_constant(VM_Version::CPU_SSE2) \
+ declare_constant(VM_Version::CPU_SSE3) \
+ declare_constant(VM_Version::CPU_SSSE3) \
+ declare_constant(VM_Version::CPU_SSE4A) \
+ declare_constant(VM_Version::CPU_SSE4_1) \
+ declare_constant(VM_Version::CPU_SSE4_2) \
+ declare_constant(VM_Version::CPU_POPCNT) \
+ declare_constant(VM_Version::CPU_LZCNT) \
+ declare_constant(VM_Version::CPU_TSC) \
+ declare_constant(VM_Version::CPU_TSCINV) \
+ declare_constant(VM_Version::CPU_AVX) \
+ declare_constant(VM_Version::CPU_AVX2) \
+ declare_constant(VM_Version::CPU_AES) \
+ declare_constant(VM_Version::CPU_ERMS) \
+ declare_constant(VM_Version::CPU_CLMUL) \
+ declare_constant(VM_Version::CPU_BMI1) \
+ declare_constant(VM_Version::CPU_BMI2) \
+ declare_constant(VM_Version::CPU_RTM) \
+ declare_constant(VM_Version::CPU_ADX) \
+ declare_constant(VM_Version::CPU_AVX512F) \
+ declare_constant(VM_Version::CPU_AVX512DQ) \
+ declare_constant(VM_Version::CPU_AVX512PF) \
+ declare_constant(VM_Version::CPU_AVX512ER) \
+ declare_constant(VM_Version::CPU_AVX512CD) \
+ declare_constant(VM_Version::CPU_AVX512BW)
+
+#define VM_LONG_CONSTANTS_CPU(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant) \
+ declare_preprocessor_constant("VM_Version::CPU_AVX512VL", CPU_AVX512VL)
+
+#endif // TARGET_ARCH_x86
+
+
+#ifdef TARGET_ARCH_sparc
+
+#define VM_STRUCTS_CPU(nonstatic_field, static_field, unchecked_nonstatic_field, volatile_nonstatic_field, nonproduct_nonstatic_field, c2_nonstatic_field, unchecked_c1_static_field, unchecked_c2_static_field) \
+ volatile_nonstatic_field(JavaFrameAnchor, _flags, int)
+
+#define VM_INT_CONSTANTS_CPU(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant) \
+ declare_constant(VM_Version::vis1_instructions_m) \
+ declare_constant(VM_Version::vis2_instructions_m) \
+ declare_constant(VM_Version::vis3_instructions_m) \
+ declare_constant(VM_Version::cbcond_instructions_m) \
+ declare_constant(VM_Version::v8_instructions_m) \
+ declare_constant(VM_Version::hardware_mul32_m) \
+ declare_constant(VM_Version::hardware_div32_m) \
+ declare_constant(VM_Version::hardware_fsmuld_m) \
+ declare_constant(VM_Version::hardware_popc_m) \
+ declare_constant(VM_Version::v9_instructions_m) \
+ declare_constant(VM_Version::sun4v_m) \
+ declare_constant(VM_Version::blk_init_instructions_m) \
+ declare_constant(VM_Version::fmaf_instructions_m) \
+ declare_constant(VM_Version::fmau_instructions_m) \
+ declare_constant(VM_Version::sparc64_family_m) \
+ declare_constant(VM_Version::M_family_m) \
+ declare_constant(VM_Version::T_family_m) \
+ declare_constant(VM_Version::T1_model_m) \
+ declare_constant(VM_Version::sparc5_instructions_m) \
+ declare_constant(VM_Version::aes_instructions_m) \
+ declare_constant(VM_Version::sha1_instruction_m) \
+ declare_constant(VM_Version::sha256_instruction_m) \
+ declare_constant(VM_Version::sha512_instruction_m)
+
+#endif // TARGET_ARCH_sparc
+
+
+/*
+ * Dummy defines for architectures that don't use these.
+ */
+#ifndef VM_STRUCTS_CPU
+#define VM_STRUCTS_CPU(nonstatic_field, static_field, unchecked_nonstatic_field, volatile_nonstatic_field, nonproduct_nonstatic_field, c2_nonstatic_field, unchecked_c1_static_field, unchecked_c2_static_field)
+#endif
+
+#ifndef VM_TYPES_CPU
+#define VM_TYPES_CPU(declare_type, declare_toplevel_type, declare_oop_type, declare_integer_type, declare_unsigned_integer_type, declare_c1_toplevel_type, declare_c2_type, declare_c2_toplevel_type)
+#endif
+
+#ifndef VM_INT_CONSTANTS_CPU
+#define VM_INT_CONSTANTS_CPU(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant)
+#endif
+
+#ifndef VM_LONG_CONSTANTS_CPU
+#define VM_LONG_CONSTANTS_CPU(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant)
+#endif
+
+#ifndef VM_STRUCTS_OS
+#define VM_STRUCTS_OS(nonstatic_field, static_field, unchecked_nonstatic_field, volatile_nonstatic_field, nonproduct_nonstatic_field, c2_nonstatic_field, unchecked_c1_static_field, unchecked_c2_static_field)
+#endif
+
+#ifndef VM_TYPES_OS
+#define VM_TYPES_OS(declare_type, declare_toplevel_type, declare_oop_type, declare_integer_type, declare_unsigned_integer_type, declare_c1_toplevel_type, declare_c2_type, declare_c2_toplevel_type)
+#endif
+
+#ifndef VM_INT_CONSTANTS_OS
+#define VM_INT_CONSTANTS_OS(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant)
+#endif
+
+#ifndef VM_LONG_CONSTANTS_OS
+#define VM_LONG_CONSTANTS_OS(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant)
+#endif
+
+#ifndef VM_ADDRESSES_OS
+#define VM_ADDRESSES_OS(declare_address, declare_preprocessor_address, declare_function)
+#endif
+
+
+// whole purpose of this function is to work around bug c++/27724 in gcc 4.1.1
+// with optimization turned on it doesn't affect produced code
+static inline uint64_t cast_uint64_t(size_t x)
+{
+ return x;
+}
+
+#define ASSIGN_CONST_TO_64BIT_VAR(var, expr) \
+ JNIEXPORT uint64_t var = cast_uint64_t(expr);
+
+#define ASSIGN_OFFSET_TO_64BIT_VAR(var, type, field) \
+ ASSIGN_CONST_TO_64BIT_VAR(var, offset_of(type, field))
+
+#define ASSIGN_STRIDE_TO_64BIT_VAR(var, array) \
+ ASSIGN_CONST_TO_64BIT_VAR(var, (char*)&array[1] - (char*)&array[0])
+
+//
+// Instantiation of VMStructEntries, VMTypeEntries and VMIntConstantEntries
+//
+
+// These initializers are allowed to access private fields in classes
+// as long as class VMStructs is a friend
+VMStructEntry JVMCIVMStructs::localHotSpotVMStructs[] = {
+ VM_STRUCTS(GENERATE_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_STATIC_VM_STRUCT_ENTRY,
+ GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_NONSTATIC_VM_STRUCT_ENTRY)
+
+ VM_STRUCTS_OS(GENERATE_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_STATIC_VM_STRUCT_ENTRY,
+ GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY,
+ GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY)
+
+ VM_STRUCTS_CPU(GENERATE_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_STATIC_VM_STRUCT_ENTRY,
+ GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY,
+ GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY)
+
+#if INCLUDE_ALL_GCS
+ VM_STRUCTS_G1(GENERATE_NONSTATIC_VM_STRUCT_ENTRY,
+ GENERATE_STATIC_VM_STRUCT_ENTRY)
+#endif
+
+ GENERATE_VM_STRUCT_LAST_ENTRY()
+};
+
+VMTypeEntry JVMCIVMStructs::localHotSpotVMTypes[] = {
+ VM_TYPES(GENERATE_VM_TYPE_ENTRY,
+ GENERATE_TOPLEVEL_VM_TYPE_ENTRY,
+ GENERATE_INTEGER_VM_TYPE_ENTRY,
+ GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY)
+
+ VM_TYPES_OS(GENERATE_VM_TYPE_ENTRY,
+ GENERATE_TOPLEVEL_VM_TYPE_ENTRY,
+ GENERATE_OOP_VM_TYPE_ENTRY,
+ GENERATE_INTEGER_VM_TYPE_ENTRY,
+ GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY,
+ GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY,
+ GENERATE_C2_VM_TYPE_ENTRY,
+ GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY)
+
+ VM_TYPES_CPU(GENERATE_VM_TYPE_ENTRY,
+ GENERATE_TOPLEVEL_VM_TYPE_ENTRY,
+ GENERATE_OOP_VM_TYPE_ENTRY,
+ GENERATE_INTEGER_VM_TYPE_ENTRY,
+ GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY,
+ GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY,
+ GENERATE_C2_VM_TYPE_ENTRY,
+ GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY)
+
+ GENERATE_VM_TYPE_LAST_ENTRY()
+};
+
+VMIntConstantEntry JVMCIVMStructs::localHotSpotVMIntConstants[] = {
+ VM_INT_CONSTANTS(GENERATE_VM_INT_CONSTANT_ENTRY,
+ GENERATE_VM_INT_CONSTANT_WITH_VALUE_ENTRY,
+ GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY)
+
+ VM_INT_CONSTANTS_OS(GENERATE_VM_INT_CONSTANT_ENTRY,
+ GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY,
+ GENERATE_C1_VM_INT_CONSTANT_ENTRY,
+ GENERATE_C2_VM_INT_CONSTANT_ENTRY,
+ GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY)
+
+ VM_INT_CONSTANTS_CPU(GENERATE_VM_INT_CONSTANT_ENTRY,
+ GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY,
+ GENERATE_C1_VM_INT_CONSTANT_ENTRY,
+ GENERATE_C2_VM_INT_CONSTANT_ENTRY,
+ GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY)
+
+#if INCLUDE_ALL_GCS
+ VM_INT_CONSTANTS_G1(GENERATE_VM_INT_CONSTANT_ENTRY,
+ GENERATE_VM_INT_CONSTANT_WITH_VALUE_ENTRY,
+ GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY)
+#endif
+
+ GENERATE_VM_INT_CONSTANT_LAST_ENTRY()
+};
+
+VMLongConstantEntry JVMCIVMStructs::localHotSpotVMLongConstants[] = {
+ VM_LONG_CONSTANTS(GENERATE_VM_LONG_CONSTANT_ENTRY,
+ GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY)
+
+ VM_LONG_CONSTANTS_OS(GENERATE_VM_LONG_CONSTANT_ENTRY,
+ GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY,
+ GENERATE_C1_VM_LONG_CONSTANT_ENTRY,
+ GENERATE_C2_VM_LONG_CONSTANT_ENTRY,
+ GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY)
+
+ VM_LONG_CONSTANTS_CPU(GENERATE_VM_LONG_CONSTANT_ENTRY,
+ GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY,
+ GENERATE_C1_VM_LONG_CONSTANT_ENTRY,
+ GENERATE_C2_VM_LONG_CONSTANT_ENTRY,
+ GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY)
+
+ GENERATE_VM_LONG_CONSTANT_LAST_ENTRY()
+};
+
+VMAddressEntry JVMCIVMStructs::localHotSpotVMAddresses[] = {
+ VM_ADDRESSES(GENERATE_VM_ADDRESS_ENTRY,
+ GENERATE_PREPROCESSOR_VM_ADDRESS_ENTRY,
+ GENERATE_VM_FUNCTION_ENTRY)
+
+ VM_ADDRESSES_OS(GENERATE_VM_ADDRESS_ENTRY,
+ GENERATE_PREPROCESSOR_VM_ADDRESS_ENTRY,
+ GENERATE_VM_FUNCTION_ENTRY)
+
+ GENERATE_VM_ADDRESS_LAST_ENTRY()
+};
+
+extern "C" {
+JNIEXPORT VMStructEntry* jvmciHotSpotVMStructs = JVMCIVMStructs::localHotSpotVMStructs;
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMStructEntryTypeNameOffset, VMStructEntry, typeName);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMStructEntryFieldNameOffset, VMStructEntry, fieldName);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMStructEntryTypeStringOffset, VMStructEntry, typeString);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMStructEntryIsStaticOffset, VMStructEntry, isStatic);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMStructEntryOffsetOffset, VMStructEntry, offset);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMStructEntryAddressOffset, VMStructEntry, address);
+ASSIGN_STRIDE_TO_64BIT_VAR(jvmciHotSpotVMStructEntryArrayStride, jvmciHotSpotVMStructs);
+
+JNIEXPORT VMTypeEntry* jvmciHotSpotVMTypes = JVMCIVMStructs::localHotSpotVMTypes;
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMTypeEntryTypeNameOffset, VMTypeEntry, typeName);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMTypeEntrySuperclassNameOffset, VMTypeEntry, superclassName);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMTypeEntryIsOopTypeOffset, VMTypeEntry, isOopType);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMTypeEntryIsIntegerTypeOffset, VMTypeEntry, isIntegerType);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMTypeEntryIsUnsignedOffset, VMTypeEntry, isUnsigned);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMTypeEntrySizeOffset, VMTypeEntry, size);
+ASSIGN_STRIDE_TO_64BIT_VAR(jvmciHotSpotVMTypeEntryArrayStride, jvmciHotSpotVMTypes);
+
+JNIEXPORT VMIntConstantEntry* jvmciHotSpotVMIntConstants = JVMCIVMStructs::localHotSpotVMIntConstants;
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMIntConstantEntryNameOffset, VMIntConstantEntry, name);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMIntConstantEntryValueOffset, VMIntConstantEntry, value);
+ASSIGN_STRIDE_TO_64BIT_VAR(jvmciHotSpotVMIntConstantEntryArrayStride, jvmciHotSpotVMIntConstants);
+
+JNIEXPORT VMLongConstantEntry* jvmciHotSpotVMLongConstants = JVMCIVMStructs::localHotSpotVMLongConstants;
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMLongConstantEntryNameOffset, VMLongConstantEntry, name);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMLongConstantEntryValueOffset, VMLongConstantEntry, value);
+ASSIGN_STRIDE_TO_64BIT_VAR(jvmciHotSpotVMLongConstantEntryArrayStride, jvmciHotSpotVMLongConstants);
+
+JNIEXPORT VMAddressEntry* jvmciHotSpotVMAddresses = JVMCIVMStructs::localHotSpotVMAddresses;
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMAddressEntryNameOffset, VMAddressEntry, name);
+ASSIGN_OFFSET_TO_64BIT_VAR(jvmciHotSpotVMAddressEntryValueOffset, VMAddressEntry, value);
+ASSIGN_STRIDE_TO_64BIT_VAR(jvmciHotSpotVMAddressEntryArrayStride, jvmciHotSpotVMAddresses);
+}
diff --git a/hotspot/src/share/vm/jvmci/vmStructs_jvmci.hpp b/hotspot/src/share/vm/jvmci/vmStructs_jvmci.hpp
index a58a6ef74c7..36bfe7289c9 100644
--- a/hotspot/src/share/vm/jvmci/vmStructs_jvmci.hpp
+++ b/hotspot/src/share/vm/jvmci/vmStructs_jvmci.hpp
@@ -25,113 +25,36 @@
#ifndef SHARE_VM_JVMCI_VMSTRUCTS_JVMCI_HPP
#define SHARE_VM_JVMCI_VMSTRUCTS_JVMCI_HPP
-#include "compiler/abstractCompiler.hpp"
-#include "jvmci/jvmciCodeInstaller.hpp"
-#include "jvmci/jvmciCompilerToVM.hpp"
-#include "jvmci/jvmciEnv.hpp"
-#include "jvmci/jvmciRuntime.hpp"
+#include "runtime/vmStructs.hpp"
-#define VM_STRUCTS_JVMCI(nonstatic_field, static_field) \
- nonstatic_field(JavaThread, _pending_deoptimization, int) \
- nonstatic_field(JavaThread, _pending_failed_speculation, oop) \
- nonstatic_field(JavaThread, _pending_transfer_to_interpreter, bool) \
- nonstatic_field(JavaThread, _jvmci_counters, jlong*) \
- nonstatic_field(MethodData, _jvmci_ir_size, int) \
- nonstatic_field(JVMCIEnv, _task, CompileTask*) \
- nonstatic_field(JVMCIEnv, _jvmti_can_hotswap_or_post_breakpoint, bool) \
- nonstatic_field(DeoptimizationBlob, _uncommon_trap_offset, int) \
- \
- static_field(CompilerToVM, _supports_inline_contig_alloc, bool) \
- static_field(CompilerToVM, _heap_end_addr, HeapWord**) \
- static_field(CompilerToVM, _heap_top_addr, HeapWord**)
+class JVMCIVMStructs {
+public:
+ /**
+ * The last entry has a NULL fieldName.
+ */
+ static VMStructEntry localHotSpotVMStructs[];
-#define VM_TYPES_JVMCI(declare_type, declare_toplevel_type) \
- declare_toplevel_type(CompilerToVM) \
- declare_toplevel_type(JVMCIEnv) \
+ /**
+ * The last entry has a NULL typeName.
+ */
+ static VMTypeEntry localHotSpotVMTypes[];
-#define VM_INT_CONSTANTS_JVMCI(declare_constant, declare_preprocessor_constant) \
- declare_constant(Deoptimization::Reason_unreached0) \
- declare_constant(Deoptimization::Reason_type_checked_inlining) \
- declare_constant(Deoptimization::Reason_optimized_type_check) \
- declare_constant(Deoptimization::Reason_aliasing) \
- declare_constant(Deoptimization::Reason_transfer_to_interpreter) \
- declare_constant(Deoptimization::Reason_not_compiled_exception_handler) \
- declare_constant(Deoptimization::Reason_unresolved) \
- declare_constant(Deoptimization::Reason_jsr_mismatch) \
- declare_constant(JVMCIEnv::ok) \
- declare_constant(JVMCIEnv::dependencies_failed) \
- declare_constant(JVMCIEnv::dependencies_invalid) \
- declare_constant(JVMCIEnv::cache_full) \
- declare_constant(JVMCIEnv::code_too_large) \
- \
- declare_preprocessor_constant("JVM_ACC_SYNTHETIC", JVM_ACC_SYNTHETIC) \
- declare_preprocessor_constant("JVM_RECOGNIZED_FIELD_MODIFIERS", JVM_RECOGNIZED_FIELD_MODIFIERS) \
- \
- declare_constant(CompilerToVM::KLASS_TAG) \
- declare_constant(CompilerToVM::SYMBOL_TAG) \
- \
- declare_constant(BitData::exception_seen_flag) \
- declare_constant(BitData::null_seen_flag) \
- declare_constant(CounterData::count_off) \
- declare_constant(JumpData::taken_off_set) \
- declare_constant(JumpData::displacement_off_set) \
- declare_constant(ReceiverTypeData::nonprofiled_count_off_set) \
- declare_constant(ReceiverTypeData::receiver_type_row_cell_count) \
- declare_constant(ReceiverTypeData::receiver0_offset) \
- declare_constant(ReceiverTypeData::count0_offset) \
- declare_constant(BranchData::not_taken_off_set) \
- declare_constant(ArrayData::array_len_off_set) \
- declare_constant(ArrayData::array_start_off_set) \
- declare_constant(MultiBranchData::per_case_cell_count) \
- \
- declare_constant(CodeInstaller::VERIFIED_ENTRY) \
- declare_constant(CodeInstaller::UNVERIFIED_ENTRY) \
- declare_constant(CodeInstaller::OSR_ENTRY) \
- declare_constant(CodeInstaller::EXCEPTION_HANDLER_ENTRY) \
- declare_constant(CodeInstaller::DEOPT_HANDLER_ENTRY) \
- declare_constant(CodeInstaller::INVOKEINTERFACE) \
- declare_constant(CodeInstaller::INVOKEVIRTUAL) \
- declare_constant(CodeInstaller::INVOKESTATIC) \
- declare_constant(CodeInstaller::INVOKESPECIAL) \
- declare_constant(CodeInstaller::INLINE_INVOKE) \
- declare_constant(CodeInstaller::POLL_NEAR) \
- declare_constant(CodeInstaller::POLL_RETURN_NEAR) \
- declare_constant(CodeInstaller::POLL_FAR) \
- declare_constant(CodeInstaller::POLL_RETURN_FAR) \
- declare_constant(CodeInstaller::CARD_TABLE_SHIFT) \
- declare_constant(CodeInstaller::CARD_TABLE_ADDRESS) \
- declare_constant(CodeInstaller::HEAP_TOP_ADDRESS) \
- declare_constant(CodeInstaller::HEAP_END_ADDRESS) \
- declare_constant(CodeInstaller::NARROW_KLASS_BASE_ADDRESS) \
- declare_constant(CodeInstaller::CRC_TABLE_ADDRESS) \
- declare_constant(CodeInstaller::INVOKE_INVALID) \
- \
- declare_constant(Method::invalid_vtable_index) \
+ /**
+ * Table of integer constants.
+ * The last entry has a NULL typeName.
+ */
+ static VMIntConstantEntry localHotSpotVMIntConstants[];
-#define VM_ADDRESSES_JVMCI(declare_address, declare_preprocessor_address, declare_function) \
- declare_function(JVMCIRuntime::new_instance) \
- declare_function(JVMCIRuntime::new_array) \
- declare_function(JVMCIRuntime::new_multi_array) \
- declare_function(JVMCIRuntime::dynamic_new_array) \
- declare_function(JVMCIRuntime::dynamic_new_instance) \
- \
- declare_function(JVMCIRuntime::thread_is_interrupted) \
- declare_function(JVMCIRuntime::vm_message) \
- declare_function(JVMCIRuntime::identity_hash_code) \
- declare_function(JVMCIRuntime::exception_handler_for_pc) \
- declare_function(JVMCIRuntime::monitorenter) \
- declare_function(JVMCIRuntime::monitorexit) \
- declare_function(JVMCIRuntime::create_null_exception) \
- declare_function(JVMCIRuntime::create_out_of_bounds_exception) \
- declare_function(JVMCIRuntime::log_primitive) \
- declare_function(JVMCIRuntime::log_object) \
- declare_function(JVMCIRuntime::log_printf) \
- declare_function(JVMCIRuntime::vm_error) \
- declare_function(JVMCIRuntime::load_and_clear_exception) \
- declare_function(JVMCIRuntime::write_barrier_pre) \
- declare_function(JVMCIRuntime::write_barrier_post) \
- declare_function(JVMCIRuntime::validate_object) \
- \
- declare_function(JVMCIRuntime::test_deoptimize_call_int)
+ /**
+ * Table of long constants.
+ * The last entry has a NULL typeName.
+ */
+ static VMLongConstantEntry localHotSpotVMLongConstants[];
+
+ /**
+ * Table of addresses.
+ */
+ static VMAddressEntry localHotSpotVMAddresses[];
+};
#endif // SHARE_VM_JVMCI_VMSTRUCTS_JVMCI_HPP
diff --git a/hotspot/src/share/vm/oops/constMethod.hpp b/hotspot/src/share/vm/oops/constMethod.hpp
index b5360571cdb..5bd135ebf17 100644
--- a/hotspot/src/share/vm/oops/constMethod.hpp
+++ b/hotspot/src/share/vm/oops/constMethod.hpp
@@ -166,9 +166,9 @@ class InlineTableSizes : StackObj {
#undef INLINE_TABLE_PARAM
#undef INLINE_TABLE_DECLARE
-
class ConstMethod : public MetaspaceObj {
friend class VMStructs;
+ friend class JVMCIVMStructs;
public:
typedef enum { NORMAL, OVERPASS } MethodType;
diff --git a/hotspot/src/share/vm/oops/constantPool.hpp b/hotspot/src/share/vm/oops/constantPool.hpp
index 4bf8e777157..f56074cf3f2 100644
--- a/hotspot/src/share/vm/oops/constantPool.hpp
+++ b/hotspot/src/share/vm/oops/constantPool.hpp
@@ -74,6 +74,7 @@ class KlassSizeStats;
class ConstantPool : public Metadata {
friend class VMStructs;
+ friend class JVMCIVMStructs;
friend class BytecodeInterpreter; // Directly extracts a klass in the pool for fast instanceof/checkcast
friend class Universe; // For null constructor
private:
diff --git a/hotspot/src/share/vm/oops/instanceKlass.hpp b/hotspot/src/share/vm/oops/instanceKlass.hpp
index fc1626535d2..344ceb74eb8 100644
--- a/hotspot/src/share/vm/oops/instanceKlass.hpp
+++ b/hotspot/src/share/vm/oops/instanceKlass.hpp
@@ -109,6 +109,7 @@ struct JvmtiCachedClassFileData;
class InstanceKlass: public Klass {
friend class VMStructs;
+ friend class JVMCIVMStructs;
friend class ClassFileParser;
friend class CompileReplay;
diff --git a/hotspot/src/share/vm/oops/klass.hpp b/hotspot/src/share/vm/oops/klass.hpp
index 466b0190eac..1f05ba24aaa 100644
--- a/hotspot/src/share/vm/oops/klass.hpp
+++ b/hotspot/src/share/vm/oops/klass.hpp
@@ -60,6 +60,7 @@ class fieldDescriptor;
class Klass : public Metadata {
friend class VMStructs;
+ friend class JVMCIVMStructs;
protected:
// note: put frequently-used fields together at start of klass structure
// for better cache behavior (may not make much of a difference but sure won't hurt)
diff --git a/hotspot/src/share/vm/oops/klassVtable.hpp b/hotspot/src/share/vm/oops/klassVtable.hpp
index f5d21819173..d135b33ccd2 100644
--- a/hotspot/src/share/vm/oops/klassVtable.hpp
+++ b/hotspot/src/share/vm/oops/klassVtable.hpp
@@ -166,6 +166,7 @@ class klassVtable : public ResourceObj {
// from_interpreter_entry_point -> i2cadapter
class vtableEntry VALUE_OBJ_CLASS_SPEC {
friend class VMStructs;
+ friend class JVMCIVMStructs;
public:
// size in words
diff --git a/hotspot/src/share/vm/oops/method.hpp b/hotspot/src/share/vm/oops/method.hpp
index 662d66555a5..c3c8d3f032d 100644
--- a/hotspot/src/share/vm/oops/method.hpp
+++ b/hotspot/src/share/vm/oops/method.hpp
@@ -61,6 +61,7 @@ class KlassSizeStats;
class Method : public Metadata {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
ConstMethod* _constMethod; // Method read-only data.
MethodData* _method_data;
diff --git a/hotspot/src/share/vm/oops/methodCounters.hpp b/hotspot/src/share/vm/oops/methodCounters.hpp
index 039271b1c10..b52bff3104a 100644
--- a/hotspot/src/share/vm/oops/methodCounters.hpp
+++ b/hotspot/src/share/vm/oops/methodCounters.hpp
@@ -32,6 +32,7 @@
class MethodCounters: public MetaspaceObj {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
int _interpreter_invocation_count; // Count of times invoked (reused as prev_event_count in tiered)
u2 _interpreter_throwout_count; // Count of times method was exited via exception while interpreting
diff --git a/hotspot/src/share/vm/oops/methodData.hpp b/hotspot/src/share/vm/oops/methodData.hpp
index 14afeccea57..c8d3d8fc247 100644
--- a/hotspot/src/share/vm/oops/methodData.hpp
+++ b/hotspot/src/share/vm/oops/methodData.hpp
@@ -73,6 +73,7 @@ class ProfileData;
// Overlay for generic profiling data.
class DataLayout VALUE_OBJ_CLASS_SPEC {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
// Every data layout begins with a header. This header
@@ -536,6 +537,7 @@ public:
// A BitData holds a flag or two in its header.
class BitData : public ProfileData {
friend class VMStructs;
+ friend class JVMCIVMStructs;
protected:
enum {
// null_seen:
@@ -605,6 +607,7 @@ public:
// A CounterData corresponds to a simple counter.
class CounterData : public BitData {
friend class VMStructs;
+ friend class JVMCIVMStructs;
protected:
enum {
count_off,
@@ -670,6 +673,7 @@ public:
// the corresponding target bci.
class JumpData : public ProfileData {
friend class VMStructs;
+ friend class JVMCIVMStructs;
protected:
enum {
taken_off_set,
@@ -1177,6 +1181,7 @@ public:
// which are used to store a type profile for the receiver of the check.
class ReceiverTypeData : public CounterData {
friend class VMStructs;
+ friend class JVMCIVMStructs;
protected:
enum {
#if INCLUDE_JVMCI
@@ -1683,6 +1688,7 @@ public:
// for the taken case.
class BranchData : public JumpData {
friend class VMStructs;
+ friend class JVMCIVMStructs;
protected:
enum {
not_taken_off_set = jump_cell_count,
@@ -1760,6 +1766,7 @@ public:
// and an array start.
class ArrayData : public ProfileData {
friend class VMStructs;
+ friend class JVMCIVMStructs;
protected:
friend class DataLayout;
@@ -1838,6 +1845,7 @@ public:
// case was taken and specify the data displacment for each branch target.
class MultiBranchData : public ArrayData {
friend class VMStructs;
+ friend class JVMCIVMStructs;
protected:
enum {
default_count_off_set,
@@ -2137,6 +2145,7 @@ class CleanExtraDataClosure;
class MethodData : public Metadata {
friend class VMStructs;
+ friend class JVMCIVMStructs;
CC_INTERP_ONLY(friend class BytecodeInterpreter;)
private:
friend class ProfileData;
diff --git a/hotspot/src/share/vm/oops/objArrayKlass.hpp b/hotspot/src/share/vm/oops/objArrayKlass.hpp
index 791f4b68eea..17d2b43e4ef 100644
--- a/hotspot/src/share/vm/oops/objArrayKlass.hpp
+++ b/hotspot/src/share/vm/oops/objArrayKlass.hpp
@@ -33,6 +33,7 @@
class ObjArrayKlass : public ArrayKlass {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
Klass* _element_klass; // The klass of the elements of this array type
Klass* _bottom_klass; // The one-dimensional type (InstanceKlass or TypeArrayKlass)
diff --git a/hotspot/src/share/vm/oops/oop.hpp b/hotspot/src/share/vm/oops/oop.hpp
index b096f3f45c5..b7fa4c2de6e 100644
--- a/hotspot/src/share/vm/oops/oop.hpp
+++ b/hotspot/src/share/vm/oops/oop.hpp
@@ -58,6 +58,7 @@ class ParCompactionManager;
class oopDesc {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
volatile markOop _mark;
union _metadata {
diff --git a/hotspot/src/share/vm/opto/addnode.cpp b/hotspot/src/share/vm/opto/addnode.cpp
index a88ee2e1d22..de7356db4b9 100644
--- a/hotspot/src/share/vm/opto/addnode.cpp
+++ b/hotspot/src/share/vm/opto/addnode.cpp
@@ -344,8 +344,8 @@ Node *AddINode::Identity( PhaseTransform *phase ) {
const Type *AddINode::add_ring( const Type *t0, const Type *t1 ) const {
const TypeInt *r0 = t0->is_int(); // Handy access
const TypeInt *r1 = t1->is_int();
- int lo = r0->_lo + r1->_lo;
- int hi = r0->_hi + r1->_hi;
+ int lo = java_add(r0->_lo, r1->_lo);
+ int hi = java_add(r0->_hi, r1->_hi);
if( !(r0->is_con() && r1->is_con()) ) {
// Not both constants, compute approximate result
if( (r0->_lo & r1->_lo) < 0 && lo >= 0 ) {
@@ -461,8 +461,8 @@ Node *AddLNode::Identity( PhaseTransform *phase ) {
const Type *AddLNode::add_ring( const Type *t0, const Type *t1 ) const {
const TypeLong *r0 = t0->is_long(); // Handy access
const TypeLong *r1 = t1->is_long();
- jlong lo = r0->_lo + r1->_lo;
- jlong hi = r0->_hi + r1->_hi;
+ jlong lo = java_add(r0->_lo, r1->_lo);
+ jlong hi = java_add(r0->_hi, r1->_hi);
if( !(r0->is_con() && r1->is_con()) ) {
// Not both constants, compute approximate result
if( (r0->_lo & r1->_lo) < 0 && lo >= 0 ) {
diff --git a/hotspot/src/share/vm/opto/block.hpp b/hotspot/src/share/vm/opto/block.hpp
index ad30a167130..d84529deb88 100644
--- a/hotspot/src/share/vm/opto/block.hpp
+++ b/hotspot/src/share/vm/opto/block.hpp
@@ -419,12 +419,12 @@ class PhaseCFG : public Phase {
void global_code_motion();
// Schedule Nodes early in their basic blocks.
- bool schedule_early(VectorSet &visited, Node_List &roots);
+ bool schedule_early(VectorSet &visited, Node_Stack &roots);
// For each node, find the latest block it can be scheduled into
// and then select the cheapest block between the latest and earliest
// block to place the node.
- void schedule_late(VectorSet &visited, Node_List &stack);
+ void schedule_late(VectorSet &visited, Node_Stack &stack);
// Compute the (backwards) latency of a node from a single use
int latency_from_use(Node *n, const Node *def, Node *use);
@@ -433,7 +433,7 @@ class PhaseCFG : public Phase {
void partial_latency_of_defs(Node *n);
// Compute the instruction global latency with a backwards walk
- void compute_latencies_backwards(VectorSet &visited, Node_List &stack);
+ void compute_latencies_backwards(VectorSet &visited, Node_Stack &stack);
// Pick a block between early and late that is a cheaper alternative
// to late. Helper for schedule_late.
diff --git a/hotspot/src/share/vm/opto/c2_globals.hpp b/hotspot/src/share/vm/opto/c2_globals.hpp
index 0001104c001..6a08d42f052 100644
--- a/hotspot/src/share/vm/opto/c2_globals.hpp
+++ b/hotspot/src/share/vm/opto/c2_globals.hpp
@@ -213,6 +213,9 @@
notproduct(bool, TraceProfileTripCount, false, \
"Trace profile loop trip count information") \
\
+ product(bool, UseCountedLoopSafepoints, false, \
+ "Force counted loops to keep a safepoint") \
+ \
product(bool, UseLoopPredicate, true, \
"Generate a predicate to select fast/slow loop versions") \
\
diff --git a/hotspot/src/share/vm/opto/c2compiler.cpp b/hotspot/src/share/vm/opto/c2compiler.cpp
index c8ff9804039..7068b5cfb1a 100644
--- a/hotspot/src/share/vm/opto/c2compiler.cpp
+++ b/hotspot/src/share/vm/opto/c2compiler.cpp
@@ -432,6 +432,7 @@ bool C2Compiler::is_intrinsic_supported(const methodHandle& method, bool is_virt
case vmIntrinsics::_aescrypt_decryptBlock:
case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
+ case vmIntrinsics::_counterMode_AESCrypt:
case vmIntrinsics::_sha_implCompress:
case vmIntrinsics::_sha2_implCompress:
case vmIntrinsics::_sha5_implCompress:
@@ -441,6 +442,7 @@ bool C2Compiler::is_intrinsic_supported(const methodHandle& method, bool is_virt
case vmIntrinsics::_mulAdd:
case vmIntrinsics::_montgomeryMultiply:
case vmIntrinsics::_montgomerySquare:
+ case vmIntrinsics::_vectorizedMismatch:
case vmIntrinsics::_ghash_processBlocks:
case vmIntrinsics::_updateCRC32:
case vmIntrinsics::_updateBytesCRC32:
diff --git a/hotspot/src/share/vm/opto/callGenerator.cpp b/hotspot/src/share/vm/opto/callGenerator.cpp
index ff86ad4750d..68a193e246c 100644
--- a/hotspot/src/share/vm/opto/callGenerator.cpp
+++ b/hotspot/src/share/vm/opto/callGenerator.cpp
@@ -46,6 +46,11 @@ const TypeFunc* CallGenerator::tf() const {
return TypeFunc::make(method());
}
+bool CallGenerator::is_inlined_mh_linker(JVMState* jvms, ciMethod* callee) {
+ ciMethod* symbolic_info = jvms->method()->get_method_at_bci(jvms->bci());
+ return symbolic_info->is_method_handle_intrinsic() && !callee->is_method_handle_intrinsic();
+}
+
//-----------------------------ParseGenerator---------------------------------
// Internal class which handles all direct bytecode traversal.
class ParseGenerator : public InlineCallGenerator {
@@ -137,6 +142,13 @@ JVMState* DirectCallGenerator::generate(JVMState* jvms) {
}
CallStaticJavaNode *call = new CallStaticJavaNode(kit.C, tf(), target, method(), kit.bci());
+ if (is_inlined_mh_linker(jvms, method())) {
+ // To be able to issue a direct call and skip a call to MH.linkTo*/invokeBasic adapter,
+ // additional information about the method being invoked should be attached
+ // to the call site to make resolution logic work
+ // (see SharedRuntime::resolve_static_call_C).
+ call->set_override_symbolic_info(true);
+ }
_call_node = call; // Save the call node in case we need it later
if (!is_static) {
// Make an explicit receiver null_check as part of this call.
@@ -192,7 +204,10 @@ JVMState* VirtualCallGenerator::generate(JVMState* jvms) {
// the call instruction will have a seemingly deficient out-count.
// (The bailout says something misleading about an "infinite loop".)
if (kit.gvn().type(receiver)->higher_equal(TypePtr::NULL_PTR)) {
- kit.inc_sp(method()->arg_size()); // restore arguments
+ assert(Bytecodes::is_invoke(kit.java_bc()), "%d: %s", kit.java_bc(), Bytecodes::name(kit.java_bc()));
+ ciMethod* declared_method = kit.method()->get_method_at_bci(kit.bci());
+ int arg_size = declared_method->signature()->arg_size_for_bc(kit.java_bc());
+ kit.inc_sp(arg_size); // restore arguments
kit.uncommon_trap(Deoptimization::Reason_null_check,
Deoptimization::Action_none,
NULL, "null receiver");
@@ -226,6 +241,13 @@ JVMState* VirtualCallGenerator::generate(JVMState* jvms) {
address target = SharedRuntime::get_resolve_virtual_call_stub();
// Normal inline cache used for call
CallDynamicJavaNode *call = new CallDynamicJavaNode(tf(), target, method(), _vtable_index, kit.bci());
+ if (is_inlined_mh_linker(jvms, method())) {
+ // To be able to issue a direct call (optimized virtual or virtual)
+ // and skip a call to MH.linkTo*/invokeBasic adapter, additional information
+ // about the method being invoked should be attached to the call site to
+ // make resolution logic work (see SharedRuntime::resolve_{virtual,opt_virtual}_call_C).
+ call->set_override_symbolic_info(true);
+ }
kit.set_arguments_for_java_call(call);
kit.set_edges_for_java_call(call);
Node* ret = kit.set_results_for_java_call(call);
@@ -463,8 +485,8 @@ bool LateInlineMHCallGenerator::do_late_inline_check(JVMState* jvms) {
_attempt++;
}
- if (cg != NULL) {
- assert(!cg->is_late_inline() && cg->is_inline(), "we're doing late inlining");
+ if (cg != NULL && cg->is_inline()) {
+ assert(!cg->is_late_inline(), "we're doing late inlining");
_inline_cg = cg;
Compile::current()->dec_number_of_mh_late_inlines();
return true;
@@ -807,8 +829,7 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod*
const int vtable_index = Method::invalid_vtable_index;
CallGenerator* cg = C->call_generator(target, vtable_index, false, jvms, true, PROB_ALWAYS, NULL, true, true);
assert(cg == NULL || !cg->is_late_inline() || cg->is_mh_late_inline(), "no late inline here");
- if (cg != NULL && cg->is_inline())
- return cg;
+ return cg;
} else {
const char* msg = "receiver not constant";
if (PrintInlining) C->print_inlining(callee, jvms->depth() - 1, jvms->bci(), msg);
@@ -829,7 +850,7 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod*
const TypeOopPtr* oop_ptr = member_name->bottom_type()->is_oopptr();
ciMethod* target = oop_ptr->const_oop()->as_member_name()->get_vmtarget();
- // In lamda forms we erase signature types to avoid resolving issues
+ // In lambda forms we erase signature types to avoid resolving issues
// involving class loaders. When we optimize a method handle invoke
// to a direct call we must cast the receiver and arguments to its
// actual types.
@@ -882,10 +903,9 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod*
// provide us with a type
speculative_receiver_type = (receiver_type != NULL) ? receiver_type->speculative_type() : NULL;
}
- CallGenerator* cg = C->call_generator(target, vtable_index, call_does_dispatch, jvms, true, PROB_ALWAYS, speculative_receiver_type, true, true);
+ CallGenerator* cg = C->call_generator(target, vtable_index, call_does_dispatch, jvms, /*allow_inline=*/true, PROB_ALWAYS, speculative_receiver_type, true, true);
assert(cg == NULL || !cg->is_late_inline() || cg->is_mh_late_inline(), "no late inline here");
- if (cg != NULL && cg->is_inline())
- return cg;
+ return cg;
} else {
const char* msg = "member_name not constant";
if (PrintInlining) C->print_inlining(callee, jvms->depth() - 1, jvms->bci(), msg);
diff --git a/hotspot/src/share/vm/opto/callGenerator.hpp b/hotspot/src/share/vm/opto/callGenerator.hpp
index 238fba2ce4a..58e8fe9c614 100644
--- a/hotspot/src/share/vm/opto/callGenerator.hpp
+++ b/hotspot/src/share/vm/opto/callGenerator.hpp
@@ -49,7 +49,7 @@ class CallGenerator : public ResourceObj {
public:
// Accessors
- ciMethod* method() const { return _method; }
+ ciMethod* method() const { return _method; }
// is_inline: At least some code implementing the method is copied here.
virtual bool is_inline() const { return false; }
@@ -123,7 +123,6 @@ class CallGenerator : public ResourceObj {
// How to generate vanilla out-of-line call sites:
static CallGenerator* for_direct_call(ciMethod* m, bool separate_io_projs = false); // static, special
static CallGenerator* for_virtual_call(ciMethod* m, int vtable_index); // virtual, interface
- static CallGenerator* for_dynamic_call(ciMethod* m); // invokedynamic
static CallGenerator* for_method_handle_call( JVMState* jvms, ciMethod* caller, ciMethod* callee, bool delayed_forbidden);
static CallGenerator* for_method_handle_inline(JVMState* jvms, ciMethod* caller, ciMethod* callee, bool& input_not_const);
@@ -170,6 +169,8 @@ class CallGenerator : public ResourceObj {
C->print_inlining(callee, inline_level, bci, msg);
}
}
+
+ static bool is_inlined_mh_linker(JVMState* jvms, ciMethod* m);
};
diff --git a/hotspot/src/share/vm/opto/callnode.cpp b/hotspot/src/share/vm/opto/callnode.cpp
index c82a149d444..ffdf6a2d29b 100644
--- a/hotspot/src/share/vm/opto/callnode.cpp
+++ b/hotspot/src/share/vm/opto/callnode.cpp
@@ -959,7 +959,8 @@ bool CallNode::is_call_to_arraycopystub() const {
uint CallJavaNode::size_of() const { return sizeof(*this); }
uint CallJavaNode::cmp( const Node &n ) const {
CallJavaNode &call = (CallJavaNode&)n;
- return CallNode::cmp(call) && _method == call._method;
+ return CallNode::cmp(call) && _method == call._method &&
+ _override_symbolic_info == call._override_symbolic_info;
}
#ifndef PRODUCT
void CallJavaNode::dump_spec(outputStream *st) const {
@@ -1332,6 +1333,7 @@ AllocateNode::AllocateNode(Compile* C, const TypeFunc *atype,
init_flags(Flag_is_macro);
_is_scalar_replaceable = false;
_is_non_escaping = false;
+ _is_allocation_MemBar_redundant = false;
Node *topnode = C->top();
init_req( TypeFunc::Control , ctrl );
@@ -1346,6 +1348,23 @@ AllocateNode::AllocateNode(Compile* C, const TypeFunc *atype,
C->add_macro_node(this);
}
+void AllocateNode::compute_MemBar_redundancy(ciMethod* initializer)
+{
+ assert(initializer != NULL &&
+ initializer->is_initializer() &&
+ !initializer->is_static(),
+ "unexpected initializer method");
+ BCEscapeAnalyzer* analyzer = initializer->get_bcea();
+ if (analyzer == NULL) {
+ return;
+ }
+
+ // Allocation node is first parameter in its initializer
+ if (analyzer->is_arg_stack(0) || analyzer->is_arg_local(0)) {
+ _is_allocation_MemBar_redundant = true;
+ }
+}
+
//=============================================================================
Node* AllocateArrayNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if (remove_dead_region(phase, can_reshape)) return this;
diff --git a/hotspot/src/share/vm/opto/callnode.hpp b/hotspot/src/share/vm/opto/callnode.hpp
index 389f09cab07..cbe9d90e773 100644
--- a/hotspot/src/share/vm/opto/callnode.hpp
+++ b/hotspot/src/share/vm/opto/callnode.hpp
@@ -657,25 +657,29 @@ protected:
bool _optimized_virtual;
bool _method_handle_invoke;
- ciMethod* _method; // Method being direct called
+ bool _override_symbolic_info; // Override symbolic call site info from bytecode
+ ciMethod* _method; // Method being direct called
public:
const int _bci; // Byte Code Index of call byte code
CallJavaNode(const TypeFunc* tf , address addr, ciMethod* method, int bci)
: CallNode(tf, addr, TypePtr::BOTTOM),
_method(method), _bci(bci),
_optimized_virtual(false),
- _method_handle_invoke(false)
+ _method_handle_invoke(false),
+ _override_symbolic_info(false)
{
init_class_id(Class_CallJava);
}
virtual int Opcode() const;
- ciMethod* method() const { return _method; }
- void set_method(ciMethod *m) { _method = m; }
- void set_optimized_virtual(bool f) { _optimized_virtual = f; }
- bool is_optimized_virtual() const { return _optimized_virtual; }
- void set_method_handle_invoke(bool f) { _method_handle_invoke = f; }
- bool is_method_handle_invoke() const { return _method_handle_invoke; }
+ ciMethod* method() const { return _method; }
+ void set_method(ciMethod *m) { _method = m; }
+ void set_optimized_virtual(bool f) { _optimized_virtual = f; }
+ bool is_optimized_virtual() const { return _optimized_virtual; }
+ void set_method_handle_invoke(bool f) { _method_handle_invoke = f; }
+ bool is_method_handle_invoke() const { return _method_handle_invoke; }
+ void set_override_symbolic_info(bool f) { _override_symbolic_info = f; }
+ bool override_symbolic_info() const { return _override_symbolic_info; }
#ifndef PRODUCT
virtual void dump_spec(outputStream *st) const;
@@ -854,6 +858,8 @@ public:
// Result of Escape Analysis
bool _is_scalar_replaceable;
bool _is_non_escaping;
+ // True when MemBar for new is redundant with MemBar at initialzer exit
+ bool _is_allocation_MemBar_redundant;
virtual uint size_of() const; // Size is bigger
AllocateNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio,
@@ -919,6 +925,13 @@ public:
InitializeNode* init = NULL;
return _is_non_escaping || (((init = initialization()) != NULL) && init->does_not_escape());
}
+
+ // If object doesn't escape in <.init> method and there is memory barrier
+ // inserted at exit of its <.init>, memory barrier for new is not necessary.
+ // Inovke this method when MemBar at exit of initializer and post-dominate
+ // allocation node.
+ void compute_MemBar_redundancy(ciMethod* initializer);
+ bool is_allocation_MemBar_redundant() { return _is_allocation_MemBar_redundant; }
};
//------------------------------AllocateArray---------------------------------
diff --git a/hotspot/src/share/vm/opto/classes.hpp b/hotspot/src/share/vm/opto/classes.hpp
index 0779c3b96a8..16ccc5817b6 100644
--- a/hotspot/src/share/vm/opto/classes.hpp
+++ b/hotspot/src/share/vm/opto/classes.hpp
@@ -216,7 +216,6 @@ macro(PartialSubtypeCheck)
macro(Phi)
macro(PopCountI)
macro(PopCountL)
-macro(PowD)
macro(PrefetchAllocation)
macro(Proj)
macro(RShiftI)
diff --git a/hotspot/src/share/vm/opto/doCall.cpp b/hotspot/src/share/vm/opto/doCall.cpp
index b8737560b07..1e8c1a465dc 100644
--- a/hotspot/src/share/vm/opto/doCall.cpp
+++ b/hotspot/src/share/vm/opto/doCall.cpp
@@ -393,6 +393,100 @@ bool Parse::can_not_compile_call_site(ciMethod *dest_method, ciInstanceKlass* kl
return false;
}
+#ifdef ASSERT
+static bool check_type(ciType* t1, ciType* t2) {
+ // Either oop-oop or prim-prim pair.
+ if (t1->is_primitive_type() && t2->is_primitive_type()) {
+ return t1->size() == t2->size(); // argument sizes should match
+ } else {
+ return !t1->is_primitive_type() && !t2->is_primitive_type(); // oop-oop
+ }
+}
+
+static bool check_inlined_mh_linker_info(ciMethod* symbolic_info, ciMethod* resolved_method) {
+ assert(symbolic_info->is_method_handle_intrinsic(), "sanity");
+ assert(!resolved_method->is_method_handle_intrinsic(), "sanity");
+
+ if (!symbolic_info->is_loaded() || !resolved_method->is_loaded()) {
+ return true; // Don't compare unloaded methods.
+ }
+ // Linkers have appendix argument which is not passed to callee.
+ int has_appendix = MethodHandles::has_member_arg(symbolic_info->intrinsic_id()) ? 1 : 0;
+ if (symbolic_info->arg_size() != (resolved_method->arg_size() + has_appendix)) {
+ return false; // Total size of arguments on stack mismatch.
+ }
+ if (!check_type(symbolic_info->return_type(), resolved_method->return_type())) {
+ return false; // Return value size or type mismatch encountered.
+ }
+
+ switch (symbolic_info->intrinsic_id()) {
+ case vmIntrinsics::_linkToVirtual:
+ case vmIntrinsics::_linkToInterface:
+ case vmIntrinsics::_linkToSpecial: {
+ if (resolved_method->is_static()) return false;
+ break;
+ }
+ case vmIntrinsics::_linkToStatic: {
+ if (!resolved_method->is_static()) return false;
+ break;
+ }
+ }
+
+ ciSignature* symbolic_sig = symbolic_info->signature();
+ ciSignature* resolved_sig = resolved_method->signature();
+
+ if (symbolic_sig->count() + (symbolic_info->is_static() ? 0 : 1) !=
+ resolved_sig->count() + (resolved_method->is_static() ? 0 : 1) + has_appendix) {
+ return false; // Argument count mismatch
+ }
+
+ int sbase = 0, rbase = 0;
+ int arg_count = MIN2(symbolic_sig->count() - has_appendix, resolved_sig->count());
+ ciType* recv_type = NULL;
+ if (symbolic_info->is_static() && !resolved_method->is_static()) {
+ recv_type = symbolic_sig->type_at(0);
+ sbase = 1;
+ } else if (!symbolic_info->is_static() && resolved_method->is_static()) {
+ recv_type = resolved_sig->type_at(0);
+ rbase = 1;
+ }
+ if (recv_type != NULL && recv_type->is_primitive_type()) {
+ return false; // Receiver should be an oop.
+ }
+ for (int i = 0; i < arg_count; i++) {
+ if (!check_type(symbolic_sig->type_at(sbase + i), resolved_sig->type_at(rbase + i))) {
+ return false; // Argument size or type mismatch encountered.
+ }
+ }
+ return true;
+}
+
+static bool is_call_consistent_with_jvms(JVMState* jvms, CallGenerator* cg) {
+ ciMethod* symbolic_info = jvms->method()->get_method_at_bci(jvms->bci());
+ ciMethod* resolved_method = cg->method();
+
+ if (CallGenerator::is_inlined_mh_linker(jvms, resolved_method)) {
+ return check_inlined_mh_linker_info(symbolic_info, resolved_method);
+ } else {
+ // Method name & descriptor should stay the same.
+ return (symbolic_info->get_Method()->name() == resolved_method->get_Method()->name()) &&
+ (symbolic_info->get_Method()->signature() == resolved_method->get_Method()->signature());
+ }
+}
+
+static bool check_call_consistency(JVMState* jvms, CallGenerator* cg) {
+ if (!is_call_consistent_with_jvms(jvms, cg)) {
+ tty->print_cr("JVMS:");
+ jvms->dump();
+ tty->print_cr("Bytecode info:");
+ jvms->method()->get_method_at_bci(jvms->bci())->print(); tty->cr();
+ tty->print_cr("Resolved method:");
+ cg->method()->print(); tty->cr();
+ return false;
+ }
+ return true;
+}
+#endif // ASSERT
//------------------------------do_call----------------------------------------
// Handle your basic call. Inline if we can & want to, else just setup call.
@@ -571,6 +665,8 @@ void Parse::do_call() {
set_jvms(new_jvms);
}
+ assert(check_call_consistency(jvms, cg), "inconsistent info");
+
if (!stopped()) {
// This was some sort of virtual call, which did a null check for us.
// Now we can assert receiver-not-null, on the normal return path.
diff --git a/hotspot/src/share/vm/opto/escape.cpp b/hotspot/src/share/vm/opto/escape.cpp
index 92ed15ca3da..98bade2457e 100644
--- a/hotspot/src/share/vm/opto/escape.cpp
+++ b/hotspot/src/share/vm/opto/escape.cpp
@@ -976,6 +976,7 @@ void ConnectionGraph::process_call_arguments(CallNode *call) {
strcmp(call->as_CallLeaf()->_name, "aescrypt_decryptBlock") == 0 ||
strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_encryptAESCrypt") == 0 ||
strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_decryptAESCrypt") == 0 ||
+ strcmp(call->as_CallLeaf()->_name, "counterMode_AESCrypt") == 0 ||
strcmp(call->as_CallLeaf()->_name, "ghash_processBlocks") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha1_implCompress") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha1_implCompressMB") == 0 ||
@@ -987,7 +988,8 @@ void ConnectionGraph::process_call_arguments(CallNode *call) {
strcmp(call->as_CallLeaf()->_name, "squareToLen") == 0 ||
strcmp(call->as_CallLeaf()->_name, "mulAdd") == 0 ||
strcmp(call->as_CallLeaf()->_name, "montgomery_multiply") == 0 ||
- strcmp(call->as_CallLeaf()->_name, "montgomery_square") == 0)
+ strcmp(call->as_CallLeaf()->_name, "montgomery_square") == 0 ||
+ strcmp(call->as_CallLeaf()->_name, "vectorizedMismatch") == 0)
))) {
call->dump();
fatal("EA unexpected CallLeaf %s", call->as_CallLeaf()->_name);
diff --git a/hotspot/src/share/vm/opto/gcm.cpp b/hotspot/src/share/vm/opto/gcm.cpp
index 70c17ad8b1c..833be199daa 100644
--- a/hotspot/src/share/vm/opto/gcm.cpp
+++ b/hotspot/src/share/vm/opto/gcm.cpp
@@ -228,18 +228,19 @@ static Block* find_deepest_input(Node* n, const PhaseCFG* cfg) {
// Find the earliest Block any instruction can be placed in. Some instructions
// are pinned into Blocks. Unpinned instructions can appear in last block in
// which all their inputs occur.
-bool PhaseCFG::schedule_early(VectorSet &visited, Node_List &roots) {
+bool PhaseCFG::schedule_early(VectorSet &visited, Node_Stack &roots) {
// Allocate stack with enough space to avoid frequent realloc
- Node_Stack nstack(roots.Size() + 8);
+ Node_Stack nstack(roots.size() + 8);
// _root will be processed among C->top() inputs
- roots.push(C->top());
+ roots.push(C->top(), 0);
visited.set(C->top()->_idx);
while (roots.size() != 0) {
// Use local variables nstack_top_n & nstack_top_i to cache values
// on stack's top.
- Node* parent_node = roots.pop();
+ Node* parent_node = roots.node();
uint input_index = 0;
+ roots.pop();
while (true) {
if (input_index == 0) {
@@ -286,7 +287,7 @@ bool PhaseCFG::schedule_early(VectorSet &visited, Node_List &roots) {
break;
} else if (!is_visited) {
// Visit this guy later, using worklist
- roots.push(in);
+ roots.push(in, 0);
}
}
@@ -791,23 +792,23 @@ private:
public:
// Constructor for the iterator
- Node_Backward_Iterator(Node *root, VectorSet &visited, Node_List &stack, PhaseCFG &cfg);
+ Node_Backward_Iterator(Node *root, VectorSet &visited, Node_Stack &stack, PhaseCFG &cfg);
// Postincrement operator to iterate over the nodes
Node *next();
private:
VectorSet &_visited;
- Node_List &_stack;
+ Node_Stack &_stack;
PhaseCFG &_cfg;
};
// Constructor for the Node_Backward_Iterator
-Node_Backward_Iterator::Node_Backward_Iterator( Node *root, VectorSet &visited, Node_List &stack, PhaseCFG &cfg)
+Node_Backward_Iterator::Node_Backward_Iterator( Node *root, VectorSet &visited, Node_Stack &stack, PhaseCFG &cfg)
: _visited(visited), _stack(stack), _cfg(cfg) {
// The stack should contain exactly the root
stack.clear();
- stack.push(root);
+ stack.push(root, root->outcnt());
// Clear the visited bits
visited.Clear();
@@ -820,12 +821,14 @@ Node *Node_Backward_Iterator::next() {
if ( !_stack.size() )
return NULL;
- // '_stack' is emulating a real _stack. The 'visit-all-users' loop has been
- // made stateless, so I do not need to record the index 'i' on my _stack.
- // Instead I visit all users each time, scanning for unvisited users.
// I visit unvisited not-anti-dependence users first, then anti-dependent
- // children next.
- Node *self = _stack.pop();
+ // children next. I iterate backwards to support removal of nodes.
+ // The stack holds states consisting of 3 values:
+ // current Def node, flag which indicates 1st/2nd pass, index of current out edge
+ Node *self = (Node*)(((uintptr_t)_stack.node()) & ~1);
+ bool iterate_anti_dep = (((uintptr_t)_stack.node()) & 1);
+ uint idx = MIN2(_stack.index(), self->outcnt()); // Support removal of nodes.
+ _stack.pop();
// I cycle here when I am entering a deeper level of recursion.
// The key variable 'self' was set prior to jumping here.
@@ -841,9 +844,9 @@ Node *Node_Backward_Iterator::next() {
Node *unvisited = NULL; // Unvisited anti-dependent Node, if any
// Scan for unvisited nodes
- for (DUIterator_Fast imax, i = self->fast_outs(imax); i < imax; i++) {
+ while (idx > 0) {
// For all uses, schedule late
- Node* n = self->fast_out(i); // Use
+ Node* n = self->raw_out(--idx); // Use
// Skip already visited children
if ( _visited.test(n->_idx) )
@@ -863,19 +866,31 @@ Node *Node_Backward_Iterator::next() {
unvisited = n; // Found unvisited
// Check for possible-anti-dependent
- if( !n->needs_anti_dependence_check() )
- break; // Not visited, not anti-dep; schedule it NOW
+ // 1st pass: No such nodes, 2nd pass: Only such nodes.
+ if (n->needs_anti_dependence_check() == iterate_anti_dep) {
+ unvisited = n; // Found unvisited
+ break;
+ }
}
// Did I find an unvisited not-anti-dependent Node?
- if ( !unvisited )
+ if (!unvisited) {
+ if (!iterate_anti_dep) {
+ // 2nd pass: Iterate over nodes which needs_anti_dependence_check.
+ iterate_anti_dep = true;
+ idx = self->outcnt();
+ continue;
+ }
break; // All done with children; post-visit 'self'
+ }
// Visit the unvisited Node. Contains the obvious push to
// indicate I'm entering a deeper level of recursion. I push the
// old state onto the _stack and set a new state and loop (recurse).
- _stack.push(self);
+ _stack.push((Node*)((uintptr_t)self | (uintptr_t)iterate_anti_dep), idx);
self = unvisited;
+ iterate_anti_dep = false;
+ idx = self->outcnt();
} // End recursion loop
return self;
@@ -883,7 +898,7 @@ Node *Node_Backward_Iterator::next() {
//------------------------------ComputeLatenciesBackwards----------------------
// Compute the latency of all the instructions.
-void PhaseCFG::compute_latencies_backwards(VectorSet &visited, Node_List &stack) {
+void PhaseCFG::compute_latencies_backwards(VectorSet &visited, Node_Stack &stack) {
#ifndef PRODUCT
if (trace_opto_pipelining())
tty->print("\n#---- ComputeLatenciesBackwards ----\n");
@@ -1157,7 +1172,7 @@ Block* PhaseCFG::hoist_to_cheaper_block(Block* LCA, Block* early, Node* self) {
// dominator tree of all USES of a value. Pick the block with the least
// loop nesting depth that is lowest in the dominator tree.
extern const char must_clone[];
-void PhaseCFG::schedule_late(VectorSet &visited, Node_List &stack) {
+void PhaseCFG::schedule_late(VectorSet &visited, Node_Stack &stack) {
#ifndef PRODUCT
if (trace_opto_pipelining())
tty->print("\n#---- schedule_late ----\n");
@@ -1313,9 +1328,7 @@ void PhaseCFG::global_code_motion() {
// instructions are pinned into Blocks. Unpinned instructions can
// appear in last block in which all their inputs occur.
visited.Clear();
- Node_List stack(arena);
- // Pre-grow the list
- stack.map((C->live_nodes() >> 1) + 16, NULL);
+ Node_Stack stack(arena, (C->live_nodes() >> 2) + 16); // pre-grow
if (!schedule_early(visited, stack)) {
// Bailout without retry
C->record_method_not_compilable("early schedule failed");
diff --git a/hotspot/src/share/vm/opto/generateOptoStub.cpp b/hotspot/src/share/vm/opto/generateOptoStub.cpp
index b3bc8999daa..48166b491fc 100644
--- a/hotspot/src/share/vm/opto/generateOptoStub.cpp
+++ b/hotspot/src/share/vm/opto/generateOptoStub.cpp
@@ -72,16 +72,18 @@ void GraphKit::gen_stub(address C_function,
// Make up the parameters
uint i;
- for( i = 0; i < parm_cnt; i++ )
+ for (i = 0; i < parm_cnt; i++) {
map()->init_req(i, _gvn.transform(new ParmNode(start, i)));
- for( ; ireq(); i++ )
+ }
+ for ( ; ireq(); i++) {
map()->init_req(i, top()); // For nicer debugging
+ }
// GraphKit requires memory to be a MergeMemNode:
set_all_memory(map()->memory());
// Get base of thread-local storage area
- Node* thread = _gvn.transform( new ThreadLocalNode() );
+ Node* thread = _gvn.transform(new ThreadLocalNode());
const int NoAlias = Compile::AliasIdxBot;
@@ -113,21 +115,27 @@ void GraphKit::gen_stub(address C_function,
//-----------------------------
// Compute signature for C call. Varies from the Java signature!
+
const Type **fields = TypeTuple::fields(2*parm_cnt+2);
uint cnt = TypeFunc::Parms;
// The C routines gets the base of thread-local storage passed in as an
- // extra argument. Not all calls need it, but its cheap to add here.
+ // extra argument. Not all calls need it, but it is cheap to add here.
for (uint pcnt = cnt; pcnt < parm_cnt; pcnt++, cnt++) {
- fields[cnt] = jdomain->field_at(pcnt);
+ const Type *f = jdomain->field_at(pcnt);
+ if (CCallingConventionRequiresIntsAsLongs && f->isa_int()) {
+ fields[cnt++] = TypeLong::LONG;
+ fields[cnt] = Type::HALF; // Must add an additional half for a long.
+ } else {
+ fields[cnt] = f;
+ }
}
-
fields[cnt++] = TypeRawPtr::BOTTOM; // Thread-local storage
// Also pass in the caller's PC, if asked for.
if (return_pc) {
fields[cnt++] = TypeRawPtr::BOTTOM; // Return PC
}
+ const TypeTuple* domain = TypeTuple::make(cnt, fields);
- const TypeTuple* domain = TypeTuple::make(cnt,fields);
// The C routine we are about to call cannot return an oop; it can block on
// exit and a GC will trash the oop while it sits in C-land. Instead, we
// return the oop through TLS for runtime calls.
@@ -155,37 +163,44 @@ void GraphKit::gen_stub(address C_function,
rfields[TypeFunc::Parms+1] = jrange->field_at(TypeFunc::Parms+1);
}
}
- const TypeTuple* range = TypeTuple::make(jrange->cnt(),rfields);
+ const TypeTuple* range = TypeTuple::make(jrange->cnt(), rfields);
// Final C signature
- const TypeFunc *c_sig = TypeFunc::make(domain,range);
+ const TypeFunc *c_sig = TypeFunc::make(domain, range);
//-----------------------------
- // Make the call node
+ // Make the call node.
CallRuntimeNode *call = new CallRuntimeNode(c_sig, C_function, name, TypePtr::BOTTOM);
//-----------------------------
- // Fix-up the debug info for the call
- call->set_jvms( new (C) JVMState(0) );
+ // Fix-up the debug info for the call.
+ call->set_jvms(new (C) JVMState(0));
call->jvms()->set_bci(0);
call->jvms()->set_offsets(cnt);
- // Set fixed predefined input arguments
+ // Set fixed predefined input arguments.
cnt = 0;
- for (i = 0; i < TypeFunc::Parms; i++)
- call->init_req(cnt++, map()->in(i));
- // A little too aggressive on the parm copy; return address is not an input
- call->set_req(TypeFunc::ReturnAdr, top());
- for (; i < parm_cnt; i++) { // Regular input arguments
+ for (i = 0; i < TypeFunc::Parms; i++) {
call->init_req(cnt++, map()->in(i));
}
+ // A little too aggressive on the parm copy; return address is not an input.
+ call->set_req(TypeFunc::ReturnAdr, top());
+ for (; i < parm_cnt; i++) { // Regular input arguments.
+ const Type *f = jdomain->field_at(i);
+ if (CCallingConventionRequiresIntsAsLongs && f->isa_int()) {
+ call->init_req(cnt++, _gvn.transform(new ConvI2LNode(map()->in(i))));
+ call->init_req(cnt++, top());
+ } else {
+ call->init_req(cnt++, map()->in(i));
+ }
+ }
+ call->init_req(cnt++, thread);
+ if (return_pc) { // Return PC, if asked for.
+ call->init_req(cnt++, returnadr());
+ }
- call->init_req( cnt++, thread );
- if( return_pc ) // Return PC, if asked for
- call->init_req( cnt++, returnadr() );
_gvn.transform_no_reclaim(call);
-
//-----------------------------
// Now set up the return results
set_control( _gvn.transform( new ProjNode(call,TypeFunc::Control)) );
diff --git a/hotspot/src/share/vm/opto/library_call.cpp b/hotspot/src/share/vm/opto/library_call.cpp
index ff068a7fd55..5bcd0b06623 100644
--- a/hotspot/src/share/vm/opto/library_call.cpp
+++ b/hotspot/src/share/vm/opto/library_call.cpp
@@ -201,6 +201,7 @@ class LibraryCallKit : public GraphKit {
return generate_method_call(method_id, true, false);
}
Node * load_field_from_object(Node * fromObj, const char * fieldName, const char * fieldTypeString, bool is_exact, bool is_static, ciInstanceKlass * fromKls);
+ Node * field_address_from_object(Node * fromObj, const char * fieldName, const char * fieldTypeString, bool is_exact, bool is_static, ciInstanceKlass * fromKls);
Node* make_string_method_node(int opcode, Node* str1_start, Node* cnt1, Node* str2_start, Node* cnt2, StrIntrinsicNode::ArgEnc ae);
bool inline_string_compareTo(StrIntrinsicNode::ArgEnc ae);
@@ -230,8 +231,6 @@ class LibraryCallKit : public GraphKit {
bool inline_math_negateExactL();
bool inline_math_subtractExactI(bool is_decrement);
bool inline_math_subtractExactL(bool is_decrement);
- bool inline_pow();
- Node* finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName);
bool inline_min_max(vmIntrinsics::ID id);
bool inline_notify(vmIntrinsics::ID id);
Node* generate_min_max(vmIntrinsics::ID id, Node* x, Node* y);
@@ -285,7 +284,9 @@ class LibraryCallKit : public GraphKit {
bool inline_Class_cast();
bool inline_aescrypt_Block(vmIntrinsics::ID id);
bool inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id);
+ bool inline_counterMode_AESCrypt(vmIntrinsics::ID id);
Node* inline_cipherBlockChaining_AESCrypt_predicate(bool decrypting);
+ Node* inline_counterMode_AESCrypt_predicate();
Node* get_key_start_from_aescrypt_object(Node* aescrypt_object);
Node* get_original_key_start_from_aescrypt_object(Node* aescrypt_object);
bool inline_ghash_processBlocks();
@@ -312,9 +313,12 @@ class LibraryCallKit : public GraphKit {
bool inline_mulAdd();
bool inline_montgomeryMultiply();
bool inline_montgomerySquare();
+ bool inline_vectorizedMismatch();
bool inline_profileBoolean();
bool inline_isCompileConstant();
+
+ bool inline_deoptimize();
};
//---------------------------make_vm_intrinsic----------------------------
@@ -696,6 +700,9 @@ bool LibraryCallKit::try_to_inline(int predicate) {
case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
return inline_cipherBlockChaining_AESCrypt(intrinsic_id());
+ case vmIntrinsics::_counterMode_AESCrypt:
+ return inline_counterMode_AESCrypt(intrinsic_id());
+
case vmIntrinsics::_sha_implCompress:
case vmIntrinsics::_sha2_implCompress:
case vmIntrinsics::_sha5_implCompress:
@@ -718,6 +725,9 @@ bool LibraryCallKit::try_to_inline(int predicate) {
case vmIntrinsics::_montgomerySquare:
return inline_montgomerySquare();
+ case vmIntrinsics::_vectorizedMismatch:
+ return inline_vectorizedMismatch();
+
case vmIntrinsics::_ghash_processBlocks:
return inline_ghash_processBlocks();
@@ -750,6 +760,9 @@ bool LibraryCallKit::try_to_inline(int predicate) {
case vmIntrinsics::_hasNegatives:
return inline_hasNegatives();
+ case vmIntrinsics::_deoptimize:
+ return inline_deoptimize();
+
default:
// If you get here, it may be that someone has added a new intrinsic
// to the list in vmSymbols.hpp without implementing it here.
@@ -777,6 +790,8 @@ Node* LibraryCallKit::try_to_predicate(int predicate) {
return inline_cipherBlockChaining_AESCrypt_predicate(false);
case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
return inline_cipherBlockChaining_AESCrypt_predicate(true);
+ case vmIntrinsics::_counterMode_AESCrypt:
+ return inline_counterMode_AESCrypt_predicate();
case vmIntrinsics::_digestBase_implCompressMB:
return inline_digestBase_implCompressMB_predicate(predicate);
@@ -1709,243 +1724,6 @@ bool LibraryCallKit::inline_trig(vmIntrinsics::ID id) {
return true;
}
-Node* LibraryCallKit::finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName) {
- //-------------------
- //result=(result.isNaN())? funcAddr():result;
- // Check: If isNaN() by checking result!=result? then either trap
- // or go to runtime
- Node* cmpisnan = _gvn.transform(new CmpDNode(result, result));
- // Build the boolean node
- Node* bolisnum = _gvn.transform(new BoolNode(cmpisnan, BoolTest::eq));
-
- if (!too_many_traps(Deoptimization::Reason_intrinsic)) {
- { BuildCutout unless(this, bolisnum, PROB_STATIC_FREQUENT);
- // The pow or exp intrinsic returned a NaN, which requires a call
- // to the runtime. Recompile with the runtime call.
- uncommon_trap(Deoptimization::Reason_intrinsic,
- Deoptimization::Action_make_not_entrant);
- }
- return result;
- } else {
- // If this inlining ever returned NaN in the past, we compile a call
- // to the runtime to properly handle corner cases
-
- IfNode* iff = create_and_xform_if(control(), bolisnum, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
- Node* if_slow = _gvn.transform(new IfFalseNode(iff));
- Node* if_fast = _gvn.transform(new IfTrueNode(iff));
-
- if (!if_slow->is_top()) {
- RegionNode* result_region = new RegionNode(3);
- PhiNode* result_val = new PhiNode(result_region, Type::DOUBLE);
-
- result_region->init_req(1, if_fast);
- result_val->init_req(1, result);
-
- set_control(if_slow);
-
- const TypePtr* no_memory_effects = NULL;
- Node* rt = make_runtime_call(RC_LEAF, call_type, funcAddr, funcName,
- no_memory_effects,
- x, top(), y, y ? top() : NULL);
- Node* value = _gvn.transform(new ProjNode(rt, TypeFunc::Parms+0));
-#ifdef ASSERT
- Node* value_top = _gvn.transform(new ProjNode(rt, TypeFunc::Parms+1));
- assert(value_top == top(), "second value must be top");
-#endif
-
- result_region->init_req(2, control());
- result_val->init_req(2, value);
- set_control(_gvn.transform(result_region));
- return _gvn.transform(result_val);
- } else {
- return result;
- }
- }
-}
-
-//------------------------------inline_pow-------------------------------------
-// Inline power instructions, if possible.
-bool LibraryCallKit::inline_pow() {
- // Pseudocode for pow
- // if (y == 2) {
- // return x * x;
- // } else {
- // if (x <= 0.0) {
- // long longy = (long)y;
- // if ((double)longy == y) { // if y is long
- // if (y + 1 == y) longy = 0; // huge number: even
- // result = ((1&longy) == 0)?-DPow(abs(x), y):DPow(abs(x), y);
- // } else {
- // result = NaN;
- // }
- // } else {
- // result = DPow(x,y);
- // }
- // if (result != result)? {
- // result = uncommon_trap() or runtime_call();
- // }
- // return result;
- // }
-
- Node* x = round_double_node(argument(0));
- Node* y = round_double_node(argument(2));
-
- Node* result = NULL;
-
- Node* const_two_node = makecon(TypeD::make(2.0));
- Node* cmp_node = _gvn.transform(new CmpDNode(y, const_two_node));
- Node* bool_node = _gvn.transform(new BoolNode(cmp_node, BoolTest::eq));
- IfNode* if_node = create_and_xform_if(control(), bool_node, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN);
- Node* if_true = _gvn.transform(new IfTrueNode(if_node));
- Node* if_false = _gvn.transform(new IfFalseNode(if_node));
-
- RegionNode* region_node = new RegionNode(3);
- region_node->init_req(1, if_true);
-
- Node* phi_node = new PhiNode(region_node, Type::DOUBLE);
- // special case for x^y where y == 2, we can convert it to x * x
- phi_node->init_req(1, _gvn.transform(new MulDNode(x, x)));
-
- // set control to if_false since we will now process the false branch
- set_control(if_false);
-
- if (!too_many_traps(Deoptimization::Reason_intrinsic)) {
- // Short form: skip the fancy tests and just check for NaN result.
- result = _gvn.transform(new PowDNode(C, control(), x, y));
- } else {
- // If this inlining ever returned NaN in the past, include all
- // checks + call to the runtime.
-
- // Set the merge point for If node with condition of (x <= 0.0)
- // There are four possible paths to region node and phi node
- RegionNode *r = new RegionNode(4);
- Node *phi = new PhiNode(r, Type::DOUBLE);
-
- // Build the first if node: if (x <= 0.0)
- // Node for 0 constant
- Node *zeronode = makecon(TypeD::ZERO);
- // Check x:0
- Node *cmp = _gvn.transform(new CmpDNode(x, zeronode));
- // Check: If (x<=0) then go complex path
- Node *bol1 = _gvn.transform(new BoolNode( cmp, BoolTest::le ));
- // Branch either way
- IfNode *if1 = create_and_xform_if(control(),bol1, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN);
- // Fast path taken; set region slot 3
- Node *fast_taken = _gvn.transform(new IfFalseNode(if1));
- r->init_req(3,fast_taken); // Capture fast-control
-
- // Fast path not-taken, i.e. slow path
- Node *complex_path = _gvn.transform(new IfTrueNode(if1));
-
- // Set fast path result
- Node *fast_result = _gvn.transform(new PowDNode(C, control(), x, y));
- phi->init_req(3, fast_result);
-
- // Complex path
- // Build the second if node (if y is long)
- // Node for (long)y
- Node *longy = _gvn.transform(new ConvD2LNode(y));
- // Node for (double)((long) y)
- Node *doublelongy= _gvn.transform(new ConvL2DNode(longy));
- // Check (double)((long) y) : y
- Node *cmplongy= _gvn.transform(new CmpDNode(doublelongy, y));
- // Check if (y isn't long) then go to slow path
-
- Node *bol2 = _gvn.transform(new BoolNode( cmplongy, BoolTest::ne ));
- // Branch either way
- IfNode *if2 = create_and_xform_if(complex_path,bol2, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN);
- Node* ylong_path = _gvn.transform(new IfFalseNode(if2));
-
- Node *slow_path = _gvn.transform(new IfTrueNode(if2));
-
- // Calculate DPow(abs(x), y)*(1 & (long)y)
- // Node for constant 1
- Node *conone = longcon(1);
- // 1& (long)y
- Node *signnode= _gvn.transform(new AndLNode(conone, longy));
-
- // A huge number is always even. Detect a huge number by checking
- // if y + 1 == y and set integer to be tested for parity to 0.
- // Required for corner case:
- // (long)9.223372036854776E18 = max_jlong
- // (double)(long)9.223372036854776E18 = 9.223372036854776E18
- // max_jlong is odd but 9.223372036854776E18 is even
- Node* yplus1 = _gvn.transform(new AddDNode(y, makecon(TypeD::make(1))));
- Node *cmpyplus1= _gvn.transform(new CmpDNode(yplus1, y));
- Node *bolyplus1 = _gvn.transform(new BoolNode( cmpyplus1, BoolTest::eq ));
- Node* correctedsign = NULL;
- if (ConditionalMoveLimit != 0) {
- correctedsign = _gvn.transform(CMoveNode::make(NULL, bolyplus1, signnode, longcon(0), TypeLong::LONG));
- } else {
- IfNode *ifyplus1 = create_and_xform_if(ylong_path,bolyplus1, PROB_FAIR, COUNT_UNKNOWN);
- RegionNode *r = new RegionNode(3);
- Node *phi = new PhiNode(r, TypeLong::LONG);
- r->init_req(1, _gvn.transform(new IfFalseNode(ifyplus1)));
- r->init_req(2, _gvn.transform(new IfTrueNode(ifyplus1)));
- phi->init_req(1, signnode);
- phi->init_req(2, longcon(0));
- correctedsign = _gvn.transform(phi);
- ylong_path = _gvn.transform(r);
- record_for_igvn(r);
- }
-
- // zero node
- Node *conzero = longcon(0);
- // Check (1&(long)y)==0?
- Node *cmpeq1 = _gvn.transform(new CmpLNode(correctedsign, conzero));
- // Check if (1&(long)y)!=0?, if so the result is negative
- Node *bol3 = _gvn.transform(new BoolNode( cmpeq1, BoolTest::ne ));
- // abs(x)
- Node *absx=_gvn.transform(new AbsDNode(x));
- // abs(x)^y
- Node *absxpowy = _gvn.transform(new PowDNode(C, control(), absx, y));
- // -abs(x)^y
- Node *negabsxpowy = _gvn.transform(new NegDNode (absxpowy));
- // (1&(long)y)==1?-DPow(abs(x), y):DPow(abs(x), y)
- Node *signresult = NULL;
- if (ConditionalMoveLimit != 0) {
- signresult = _gvn.transform(CMoveNode::make(NULL, bol3, absxpowy, negabsxpowy, Type::DOUBLE));
- } else {
- IfNode *ifyeven = create_and_xform_if(ylong_path,bol3, PROB_FAIR, COUNT_UNKNOWN);
- RegionNode *r = new RegionNode(3);
- Node *phi = new PhiNode(r, Type::DOUBLE);
- r->init_req(1, _gvn.transform(new IfFalseNode(ifyeven)));
- r->init_req(2, _gvn.transform(new IfTrueNode(ifyeven)));
- phi->init_req(1, absxpowy);
- phi->init_req(2, negabsxpowy);
- signresult = _gvn.transform(phi);
- ylong_path = _gvn.transform(r);
- record_for_igvn(r);
- }
- // Set complex path fast result
- r->init_req(2, ylong_path);
- phi->init_req(2, signresult);
-
- static const jlong nan_bits = CONST64(0x7ff8000000000000);
- Node *slow_result = makecon(TypeD::make(*(double*)&nan_bits)); // return NaN
- r->init_req(1,slow_path);
- phi->init_req(1,slow_result);
-
- // Post merge
- set_control(_gvn.transform(r));
- record_for_igvn(r);
- result = _gvn.transform(phi);
- }
-
- result = finish_pow_exp(result, x, y, OptoRuntime::Math_DD_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dpow), "POW");
-
- // control from finish_pow_exp is now input to the region node
- region_node->set_req(2, control());
- // the result from finish_pow_exp is now input to the phi node
- phi_node->init_req(2, result);
- set_control(_gvn.transform(region_node));
- record_for_igvn(region_node);
- set_result(_gvn.transform(phi_node));
-
- C->set_has_split_ifs(true); // Has chance for split-if optimization
- return true;
-}
-
//------------------------------runtime_math-----------------------------
bool LibraryCallKit::runtime_math(const TypeFunc* call_type, address funcAddr, const char* funcName) {
assert(call_type == OptoRuntime::Math_DD_D_Type() || call_type == OptoRuntime::Math_D_D_Type(),
@@ -1996,8 +1774,10 @@ bool LibraryCallKit::inline_math_native(vmIntrinsics::ID id) {
return StubRoutines::dexp() != NULL ?
runtime_math(OptoRuntime::Math_D_D_Type(), StubRoutines::dexp(), "dexp") :
runtime_math(OptoRuntime::Math_D_D_Type(), FN_PTR(SharedRuntime::dexp), "EXP");
- case vmIntrinsics::_dpow: return Matcher::has_match_rule(Op_PowD) ? inline_pow() :
- runtime_math(OptoRuntime::Math_DD_D_Type(), FN_PTR(SharedRuntime::dpow), "POW");
+ case vmIntrinsics::_dpow:
+ return StubRoutines::dpow() != NULL ?
+ runtime_math(OptoRuntime::Math_DD_D_Type(), StubRoutines::dpow(), "dpow") :
+ runtime_math(OptoRuntime::Math_DD_D_Type(), FN_PTR(SharedRuntime::dpow), "POW");
#undef FN_PTR
// These intrinsics are not yet correctly implemented
@@ -5576,6 +5356,50 @@ bool LibraryCallKit::inline_montgomerySquare() {
return true;
}
+//-------------inline_vectorizedMismatch------------------------------
+bool LibraryCallKit::inline_vectorizedMismatch() {
+ assert(UseVectorizedMismatchIntrinsic, "not implementated on this platform");
+
+ address stubAddr = StubRoutines::vectorizedMismatch();
+ if (stubAddr == NULL) {
+ return false; // Intrinsic's stub is not implemented on this platform
+ }
+ const char* stubName = "vectorizedMismatch";
+ int size_l = callee()->signature()->size();
+ assert(callee()->signature()->size() == 8, "vectorizedMismatch has 6 parameters");
+
+ Node* obja = argument(0);
+ Node* aoffset = argument(1);
+ Node* objb = argument(3);
+ Node* boffset = argument(4);
+ Node* length = argument(6);
+ Node* scale = argument(7);
+
+ const Type* a_type = obja->Value(&_gvn);
+ const Type* b_type = objb->Value(&_gvn);
+ const TypeAryPtr* top_a = a_type->isa_aryptr();
+ const TypeAryPtr* top_b = b_type->isa_aryptr();
+ if (top_a == NULL || top_a->klass() == NULL ||
+ top_b == NULL || top_b->klass() == NULL) {
+ // failed array check
+ return false;
+ }
+
+ Node* call;
+ jvms()->set_should_reexecute(true);
+
+ Node* obja_adr = make_unsafe_address(obja, aoffset);
+ Node* objb_adr = make_unsafe_address(objb, boffset);
+
+ call = make_runtime_call(RC_LEAF,
+ OptoRuntime::vectorizedMismatch_Type(),
+ stubAddr, stubName, TypePtr::BOTTOM,
+ obja_adr, objb_adr, length, scale);
+
+ Node* result = _gvn.transform(new ProjNode(call, TypeFunc::Parms));
+ set_result(result);
+ return true;
+}
/**
* Calculate CRC32 for byte.
@@ -5962,6 +5786,39 @@ Node * LibraryCallKit::load_field_from_object(Node * fromObj, const char * field
return loadedField;
}
+Node * LibraryCallKit::field_address_from_object(Node * fromObj, const char * fieldName, const char * fieldTypeString,
+ bool is_exact = true, bool is_static = false,
+ ciInstanceKlass * fromKls = NULL) {
+ if (fromKls == NULL) {
+ const TypeInstPtr* tinst = _gvn.type(fromObj)->isa_instptr();
+ assert(tinst != NULL, "obj is null");
+ assert(tinst->klass()->is_loaded(), "obj is not loaded");
+ assert(!is_exact || tinst->klass_is_exact(), "klass not exact");
+ fromKls = tinst->klass()->as_instance_klass();
+ }
+ else {
+ assert(is_static, "only for static field access");
+ }
+ ciField* field = fromKls->get_field_by_name(ciSymbol::make(fieldName),
+ ciSymbol::make(fieldTypeString),
+ is_static);
+
+ assert(field != NULL, "undefined field");
+ assert(!field->is_volatile(), "not defined for volatile fields");
+
+ if (is_static) {
+ const TypeInstPtr* tip = TypeInstPtr::make(fromKls->java_mirror());
+ fromObj = makecon(tip);
+ }
+
+ // Next code copied from Parse::do_get_xxx():
+
+ // Compute address and memory type.
+ int offset = field->offset_in_bytes();
+ Node *adr = basic_plus_adr(fromObj, fromObj, offset);
+
+ return adr;
+}
//------------------------------inline_aescrypt_Block-----------------------
bool LibraryCallKit::inline_aescrypt_Block(vmIntrinsics::ID id) {
@@ -6128,6 +5985,90 @@ bool LibraryCallKit::inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id) {
return true;
}
+//------------------------------inline_counterMode_AESCrypt-----------------------
+bool LibraryCallKit::inline_counterMode_AESCrypt(vmIntrinsics::ID id) {
+ assert(UseAES, "need AES instruction support");
+ if (!UseAESCTRIntrinsics) return false;
+
+ address stubAddr = NULL;
+ const char *stubName = NULL;
+ if (id == vmIntrinsics::_counterMode_AESCrypt) {
+ stubAddr = StubRoutines::counterMode_AESCrypt();
+ stubName = "counterMode_AESCrypt";
+ }
+ if (stubAddr == NULL) return false;
+
+ Node* counterMode_object = argument(0);
+ Node* src = argument(1);
+ Node* src_offset = argument(2);
+ Node* len = argument(3);
+ Node* dest = argument(4);
+ Node* dest_offset = argument(5);
+
+ // (1) src and dest are arrays.
+ const Type* src_type = src->Value(&_gvn);
+ const Type* dest_type = dest->Value(&_gvn);
+ const TypeAryPtr* top_src = src_type->isa_aryptr();
+ const TypeAryPtr* top_dest = dest_type->isa_aryptr();
+ assert(top_src != NULL && top_src->klass() != NULL &&
+ top_dest != NULL && top_dest->klass() != NULL, "args are strange");
+
+ // checks are the responsibility of the caller
+ Node* src_start = src;
+ Node* dest_start = dest;
+ if (src_offset != NULL || dest_offset != NULL) {
+ assert(src_offset != NULL && dest_offset != NULL, "");
+ src_start = array_element_address(src, src_offset, T_BYTE);
+ dest_start = array_element_address(dest, dest_offset, T_BYTE);
+ }
+
+ // if we are in this set of code, we "know" the embeddedCipher is an AESCrypt object
+ // (because of the predicated logic executed earlier).
+ // so we cast it here safely.
+ // this requires a newer class file that has this array as littleEndian ints, otherwise we revert to java
+ Node* embeddedCipherObj = load_field_from_object(counterMode_object, "embeddedCipher", "Lcom/sun/crypto/provider/SymmetricCipher;", /*is_exact*/ false);
+ if (embeddedCipherObj == NULL) return false;
+ // cast it to what we know it will be at runtime
+ const TypeInstPtr* tinst = _gvn.type(counterMode_object)->isa_instptr();
+ assert(tinst != NULL, "CTR obj is null");
+ assert(tinst->klass()->is_loaded(), "CTR obj is not loaded");
+ ciKlass* klass_AESCrypt = tinst->klass()->as_instance_klass()->find_klass(ciSymbol::make("com/sun/crypto/provider/AESCrypt"));
+ assert(klass_AESCrypt->is_loaded(), "predicate checks that this class is loaded");
+ ciInstanceKlass* instklass_AESCrypt = klass_AESCrypt->as_instance_klass();
+ const TypeKlassPtr* aklass = TypeKlassPtr::make(instklass_AESCrypt);
+ const TypeOopPtr* xtype = aklass->as_instance_type();
+ Node* aescrypt_object = new CheckCastPPNode(control(), embeddedCipherObj, xtype);
+ aescrypt_object = _gvn.transform(aescrypt_object);
+ // we need to get the start of the aescrypt_object's expanded key array
+ Node* k_start = get_key_start_from_aescrypt_object(aescrypt_object);
+ if (k_start == NULL) return false;
+ // similarly, get the start address of the r vector
+ Node* obj_counter = load_field_from_object(counterMode_object, "counter", "[B", /*is_exact*/ false);
+ if (obj_counter == NULL) return false;
+ Node* cnt_start = array_element_address(obj_counter, intcon(0), T_BYTE);
+
+ Node* saved_encCounter = load_field_from_object(counterMode_object, "encryptedCounter", "[B", /*is_exact*/ false);
+ if (saved_encCounter == NULL) return false;
+ Node* saved_encCounter_start = array_element_address(saved_encCounter, intcon(0), T_BYTE);
+ Node* used = field_address_from_object(counterMode_object, "used", "I", /*is_exact*/ false);
+
+ Node* ctrCrypt;
+ if (Matcher::pass_original_key_for_aes()) {
+ // no SPARC version for AES/CTR intrinsics now.
+ return false;
+ }
+ // Call the stub, passing src_start, dest_start, k_start, r_start and src_len
+ ctrCrypt = make_runtime_call(RC_LEAF|RC_NO_FP,
+ OptoRuntime::counterMode_aescrypt_Type(),
+ stubAddr, stubName, TypePtr::BOTTOM,
+ src_start, dest_start, k_start, cnt_start, len, saved_encCounter_start, used);
+
+ // return cipher length (int)
+ Node* retvalue = _gvn.transform(new ProjNode(ctrCrypt, TypeFunc::Parms));
+ set_result(retvalue);
+ return true;
+}
+
//------------------------------get_key_start_from_aescrypt_object-----------------------
Node * LibraryCallKit::get_key_start_from_aescrypt_object(Node *aescrypt_object) {
Node* objAESCryptKey = load_field_from_object(aescrypt_object, "K", "[I", /*is_exact*/ false);
@@ -6209,6 +6150,48 @@ Node* LibraryCallKit::inline_cipherBlockChaining_AESCrypt_predicate(bool decrypt
return _gvn.transform(region);
}
+//----------------------------inline_counterMode_AESCrypt_predicate----------------------------
+// Return node representing slow path of predicate check.
+// the pseudo code we want to emulate with this predicate is:
+// for encryption:
+// if (embeddedCipherObj instanceof AESCrypt) do_intrinsic, else do_javapath
+// for decryption:
+// if ((embeddedCipherObj instanceof AESCrypt) && (cipher!=plain)) do_intrinsic, else do_javapath
+// note cipher==plain is more conservative than the original java code but that's OK
+//
+
+Node* LibraryCallKit::inline_counterMode_AESCrypt_predicate() {
+ // The receiver was checked for NULL already.
+ Node* objCTR = argument(0);
+
+ // Load embeddedCipher field of CipherBlockChaining object.
+ Node* embeddedCipherObj = load_field_from_object(objCTR, "embeddedCipher", "Lcom/sun/crypto/provider/SymmetricCipher;", /*is_exact*/ false);
+
+ // get AESCrypt klass for instanceOf check
+ // AESCrypt might not be loaded yet if some other SymmetricCipher got us to this compile point
+ // will have same classloader as CipherBlockChaining object
+ const TypeInstPtr* tinst = _gvn.type(objCTR)->isa_instptr();
+ assert(tinst != NULL, "CTRobj is null");
+ assert(tinst->klass()->is_loaded(), "CTRobj is not loaded");
+
+ // we want to do an instanceof comparison against the AESCrypt class
+ ciKlass* klass_AESCrypt = tinst->klass()->as_instance_klass()->find_klass(ciSymbol::make("com/sun/crypto/provider/AESCrypt"));
+ if (!klass_AESCrypt->is_loaded()) {
+ // if AESCrypt is not even loaded, we never take the intrinsic fast path
+ Node* ctrl = control();
+ set_control(top()); // no regular fast path
+ return ctrl;
+ }
+
+ ciInstanceKlass* instklass_AESCrypt = klass_AESCrypt->as_instance_klass();
+ Node* instof = gen_instanceof(embeddedCipherObj, makecon(TypeKlassPtr::make(instklass_AESCrypt)));
+ Node* cmp_instof = _gvn.transform(new CmpINode(instof, intcon(1)));
+ Node* bool_instof = _gvn.transform(new BoolNode(cmp_instof, BoolTest::ne));
+ Node* instof_false = generate_guard(bool_instof, NULL, PROB_MIN);
+
+ return instof_false; // even if it is NULL
+}
+
//------------------------------inline_ghash_processBlocks
bool LibraryCallKit::inline_ghash_processBlocks() {
address stubAddr;
@@ -6574,3 +6557,12 @@ bool LibraryCallKit::inline_isCompileConstant() {
set_result(n->is_Con() ? intcon(1) : intcon(0));
return true;
}
+
+bool LibraryCallKit::inline_deoptimize() {
+ assert(WhiteBoxAPI, "");
+ PreserveReexecuteState preexecs(this);
+ jvms()->set_should_reexecute(false);
+ uncommon_trap(Deoptimization::Reason_intrinsic,
+ Deoptimization::Action_none);
+ return true;
+}
diff --git a/hotspot/src/share/vm/opto/loopTransform.cpp b/hotspot/src/share/vm/opto/loopTransform.cpp
index 41ebaffc838..cbff6c2b879 100644
--- a/hotspot/src/share/vm/opto/loopTransform.cpp
+++ b/hotspot/src/share/vm/opto/loopTransform.cpp
@@ -1399,8 +1399,8 @@ void PhaseIdealLoop::do_unroll( IdealLoopTree *loop, Node_List &old_new, bool ad
limit = new Opaque2Node( C, limit );
register_new_node( limit, opaq_ctrl );
}
- if (stride_con > 0 && ((limit_type->_lo - stride_con) < limit_type->_lo) ||
- stride_con < 0 && ((limit_type->_hi - stride_con) > limit_type->_hi)) {
+ if (stride_con > 0 && (java_subtract(limit_type->_lo, stride_con) < limit_type->_lo) ||
+ stride_con < 0 && (java_subtract(limit_type->_hi, stride_con) > limit_type->_hi)) {
// No underflow.
new_limit = new SubINode(limit, stride);
} else {
@@ -1911,6 +1911,12 @@ bool PhaseIdealLoop::is_scaled_iv_plus_offset(Node* exp, Node* iv, int* p_scale,
}
return true;
}
+ if (is_scaled_iv(exp->in(2), iv, p_scale)) {
+ if (p_offset != NULL) {
+ *p_offset = exp->in(1);
+ }
+ return true;
+ }
if (exp->in(2)->is_Con()) {
Node* offset2 = NULL;
if (depth < 2 &&
diff --git a/hotspot/src/share/vm/opto/loopnode.cpp b/hotspot/src/share/vm/opto/loopnode.cpp
index 953364397ab..3faa0c2d319 100644
--- a/hotspot/src/share/vm/opto/loopnode.cpp
+++ b/hotspot/src/share/vm/opto/loopnode.cpp
@@ -690,14 +690,16 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
} // LoopLimitCheck
- // Check for SafePoint on backedge and remove
- Node *sfpt = x->in(LoopNode::LoopBackControl);
- if (sfpt->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt)) {
- lazy_replace( sfpt, iftrue );
- if (loop->_safepts != NULL) {
- loop->_safepts->yank(sfpt);
+ if (!UseCountedLoopSafepoints) {
+ // Check for SafePoint on backedge and remove
+ Node *sfpt = x->in(LoopNode::LoopBackControl);
+ if (sfpt->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt)) {
+ lazy_replace( sfpt, iftrue );
+ if (loop->_safepts != NULL) {
+ loop->_safepts->yank(sfpt);
+ }
+ loop->_tail = iftrue;
}
- loop->_tail = iftrue;
}
// Build a canonical trip test.
@@ -786,12 +788,14 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
lazy_replace( x, l );
set_idom(l, init_control, dom_depth(x));
- // Check for immediately preceding SafePoint and remove
- Node *sfpt2 = le->in(0);
- if (sfpt2->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt2)) {
- lazy_replace( sfpt2, sfpt2->in(TypeFunc::Control));
- if (loop->_safepts != NULL) {
- loop->_safepts->yank(sfpt2);
+ if (!UseCountedLoopSafepoints) {
+ // Check for immediately preceding SafePoint and remove
+ Node *sfpt2 = le->in(0);
+ if (sfpt2->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt2)) {
+ lazy_replace( sfpt2, sfpt2->in(TypeFunc::Control));
+ if (loop->_safepts != NULL) {
+ loop->_safepts->yank(sfpt2);
+ }
}
}
@@ -1813,6 +1817,37 @@ void PhaseIdealLoop::replace_parallel_iv(IdealLoopTree *loop) {
}
}
+void IdealLoopTree::remove_safepoints(PhaseIdealLoop* phase, bool keep_one) {
+ Node* keep = NULL;
+ if (keep_one) {
+ // Look for a safepoint on the idom-path.
+ for (Node* i = tail(); i != _head; i = phase->idom(i)) {
+ if (i->Opcode() == Op_SafePoint && phase->get_loop(i) == this) {
+ keep = i;
+ break; // Found one
+ }
+ }
+ }
+
+ // Don't remove any safepoints if it is requested to keep a single safepoint and
+ // no safepoint was found on idom-path. It is not safe to remove any safepoint
+ // in this case since there's no safepoint dominating all paths in the loop body.
+ bool prune = !keep_one || keep != NULL;
+
+ // Delete other safepoints in this loop.
+ Node_List* sfpts = _safepts;
+ if (prune && sfpts != NULL) {
+ assert(keep == NULL || keep->Opcode() == Op_SafePoint, "not safepoint");
+ for (uint i = 0; i < sfpts->size(); i++) {
+ Node* n = sfpts->at(i);
+ assert(phase->get_loop(n) == this, "");
+ if (n != keep && phase->is_deleteable_safept(n)) {
+ phase->lazy_replace(n, n->in(TypeFunc::Control));
+ }
+ }
+ }
+}
+
//------------------------------counted_loop-----------------------------------
// Convert to counted loops where possible
void IdealLoopTree::counted_loop( PhaseIdealLoop *phase ) {
@@ -1824,42 +1859,23 @@ void IdealLoopTree::counted_loop( PhaseIdealLoop *phase ) {
if (_head->is_CountedLoop() ||
phase->is_counted_loop(_head, this)) {
- _has_sfpt = 1; // Indicate we do not need a safepoint here
- // Look for safepoints to remove.
- Node_List* sfpts = _safepts;
- if (sfpts != NULL) {
- for (uint i = 0; i < sfpts->size(); i++) {
- Node* n = sfpts->at(i);
- assert(phase->get_loop(n) == this, "");
- if (phase->is_deleteable_safept(n)) {
- phase->lazy_replace(n, n->in(TypeFunc::Control));
- }
- }
+ if (!UseCountedLoopSafepoints) {
+ // Indicate we do not need a safepoint here
+ _has_sfpt = 1;
}
+ // Remove safepoints
+ bool keep_one_sfpt = !(_has_call || _has_sfpt);
+ remove_safepoints(phase, keep_one_sfpt);
+
// Look for induction variables
phase->replace_parallel_iv(this);
} else if (_parent != NULL && !_irreducible) {
- // Not a counted loop.
- // Look for a safepoint on the idom-path.
- Node* sfpt = tail();
- for (; sfpt != _head; sfpt = phase->idom(sfpt)) {
- if (sfpt->Opcode() == Op_SafePoint && phase->get_loop(sfpt) == this)
- break; // Found one
- }
- // Delete other safepoints in this loop.
- Node_List* sfpts = _safepts;
- if (sfpts != NULL && sfpt != _head && sfpt->Opcode() == Op_SafePoint) {
- for (uint i = 0; i < sfpts->size(); i++) {
- Node* n = sfpts->at(i);
- assert(phase->get_loop(n) == this, "");
- if (n != sfpt && phase->is_deleteable_safept(n)) {
- phase->lazy_replace(n, n->in(TypeFunc::Control));
- }
- }
- }
+ // Not a counted loop. Keep one safepoint.
+ bool keep_one_sfpt = true;
+ remove_safepoints(phase, keep_one_sfpt);
}
// Recursively
@@ -1913,6 +1929,15 @@ void IdealLoopTree::dump_head( ) const {
if (cl->is_main_loop()) tty->print(" main");
if (cl->is_post_loop()) tty->print(" post");
}
+ if (_has_call) tty->print(" has_call");
+ if (_has_sfpt) tty->print(" has_sfpt");
+ if (_rce_candidate) tty->print(" rce");
+ if (_safepts != NULL && _safepts->size() > 0) {
+ tty->print(" sfpts={"); _safepts->dump_simple(); tty->print(" }");
+ }
+ if (_required_safept != NULL && _required_safept->size() > 0) {
+ tty->print(" req={"); _required_safept->dump_simple(); tty->print(" }");
+ }
tty->cr();
}
@@ -2310,6 +2335,11 @@ void PhaseIdealLoop::build_and_optimize(bool do_split_ifs, bool skip_loop_opts)
#endif
if (skip_loop_opts) {
+ // restore major progress flag
+ for (int i = 0; i < old_progress; i++) {
+ C->set_major_progress();
+ }
+
// Cleanup any modified bits
_igvn.optimize();
diff --git a/hotspot/src/share/vm/opto/loopnode.hpp b/hotspot/src/share/vm/opto/loopnode.hpp
index fd736bbf426..59cfc690c7e 100644
--- a/hotspot/src/share/vm/opto/loopnode.hpp
+++ b/hotspot/src/share/vm/opto/loopnode.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 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
@@ -429,6 +429,9 @@ public:
// encountered.
void allpaths_check_safepts(VectorSet &visited, Node_List &stack);
+ // Remove safepoints from loop. Optionally keeping one.
+ void remove_safepoints(PhaseIdealLoop* phase, bool keep_one);
+
// Convert to counted loops where possible
void counted_loop( PhaseIdealLoop *phase );
diff --git a/hotspot/src/share/vm/opto/machnode.cpp b/hotspot/src/share/vm/opto/machnode.cpp
index c780d3f5340..c4e6953ab9f 100644
--- a/hotspot/src/share/vm/opto/machnode.cpp
+++ b/hotspot/src/share/vm/opto/machnode.cpp
@@ -707,7 +707,8 @@ const RegMask &MachCallNode::in_RegMask(uint idx) const {
uint MachCallJavaNode::size_of() const { return sizeof(*this); }
uint MachCallJavaNode::cmp( const Node &n ) const {
MachCallJavaNode &call = (MachCallJavaNode&)n;
- return MachCallNode::cmp(call) && _method->equals(call._method);
+ return MachCallNode::cmp(call) && _method->equals(call._method) &&
+ _override_symbolic_info == call._override_symbolic_info;
}
#ifndef PRODUCT
void MachCallJavaNode::dump_spec(outputStream *st) const {
diff --git a/hotspot/src/share/vm/opto/machnode.hpp b/hotspot/src/share/vm/opto/machnode.hpp
index ca2ad70c264..25cbdc648e7 100644
--- a/hotspot/src/share/vm/opto/machnode.hpp
+++ b/hotspot/src/share/vm/opto/machnode.hpp
@@ -885,16 +885,28 @@ protected:
virtual uint cmp( const Node &n ) const;
virtual uint size_of() const; // Size is bigger
public:
- ciMethod* _method; // Method being direct called
- int _bci; // Byte Code index of call byte code
- bool _optimized_virtual; // Tells if node is a static call or an optimized virtual
- bool _method_handle_invoke; // Tells if the call has to preserve SP
- MachCallJavaNode() : MachCallNode() {
+ ciMethod* _method; // Method being direct called
+ bool _override_symbolic_info; // Override symbolic call site info from bytecode
+ int _bci; // Byte Code index of call byte code
+ bool _optimized_virtual; // Tells if node is a static call or an optimized virtual
+ bool _method_handle_invoke; // Tells if the call has to preserve SP
+ MachCallJavaNode() : MachCallNode(), _override_symbolic_info(false) {
init_class_id(Class_MachCallJava);
}
virtual const RegMask &in_RegMask(uint) const;
+ int resolved_method_index(CodeBuffer &cbuf) const {
+ if (_override_symbolic_info) {
+ // Attach corresponding Method* to the call site, so VM can use it during resolution
+ // instead of querying symbolic info from bytecode.
+ assert(_method != NULL, "method should be set");
+ assert(_method->constant_encoding()->is_method(), "should point to a Method");
+ return cbuf.oop_recorder()->find_index(_method->constant_encoding());
+ }
+ return 0; // Use symbolic info from bytecode (resolved_method == NULL).
+ }
+
#ifndef PRODUCT
virtual void dump_spec(outputStream *st) const;
#endif
diff --git a/hotspot/src/share/vm/opto/macro.cpp b/hotspot/src/share/vm/opto/macro.cpp
index 4551560a6e4..93c93b58206 100644
--- a/hotspot/src/share/vm/opto/macro.cpp
+++ b/hotspot/src/share/vm/opto/macro.cpp
@@ -1522,11 +1522,20 @@ void PhaseMacroExpand::expand_allocate_common(
// If initialization is performed by an array copy, any required
// MemBarStoreStore was already added. If the object does not
- // escape no need for a MemBarStoreStore. Otherwise we need a
- // MemBarStoreStore so that stores that initialize this object
- // can't be reordered with a subsequent store that makes this
- // object accessible by other threads.
+ // escape no need for a MemBarStoreStore. If the object does not
+ // escape in its initializer and memory barrier (MemBarStoreStore or
+ // stronger) is already added at exit of initializer, also no need
+ // for a MemBarStoreStore. Otherwise we need a MemBarStoreStore
+ // so that stores that initialize this object can't be reordered
+ // with a subsequent store that makes this object accessible by
+ // other threads.
+ // Other threads include java threads and JVM internal threads
+ // (for example concurrent GC threads). Current concurrent GC
+ // implementation: CMS and G1 will not scan newly created object,
+ // so it's safe to skip storestore barrier when allocation does
+ // not escape.
if (!alloc->does_not_escape_thread() &&
+ !alloc->is_allocation_MemBar_redundant() &&
(init == NULL || !init->is_complete_with_arraycopy())) {
if (init == NULL || init->req() < InitializeNode::RawStores) {
// No InitializeNode or no stores captured by zeroing
diff --git a/hotspot/src/share/vm/opto/matcher.cpp b/hotspot/src/share/vm/opto/matcher.cpp
index acf3f32ece0..bb18a3da6d8 100644
--- a/hotspot/src/share/vm/opto/matcher.cpp
+++ b/hotspot/src/share/vm/opto/matcher.cpp
@@ -1201,6 +1201,7 @@ MachNode *Matcher::match_sfpt( SafePointNode *sfpt ) {
mcall_java->_optimized_virtual = call_java->is_optimized_virtual();
is_method_handle_invoke = call_java->is_method_handle_invoke();
mcall_java->_method_handle_invoke = is_method_handle_invoke;
+ mcall_java->_override_symbolic_info = call_java->override_symbolic_info();
if (is_method_handle_invoke) {
C->set_has_method_handle_invokes(true);
}
diff --git a/hotspot/src/share/vm/opto/mulnode.cpp b/hotspot/src/share/vm/opto/mulnode.cpp
index d4730e978e9..4e796ce72d3 100644
--- a/hotspot/src/share/vm/opto/mulnode.cpp
+++ b/hotspot/src/share/vm/opto/mulnode.cpp
@@ -245,13 +245,13 @@ const Type *MulINode::mul_ring(const Type *t0, const Type *t1) const {
double d = (double)hi1;
// Compute all endpoints & check for overflow
- int32_t A = lo0*lo1;
+ int32_t A = java_multiply(lo0, lo1);
if( (double)A != a*c ) return TypeInt::INT; // Overflow?
- int32_t B = lo0*hi1;
+ int32_t B = java_multiply(lo0, hi1);
if( (double)B != a*d ) return TypeInt::INT; // Overflow?
- int32_t C = hi0*lo1;
+ int32_t C = java_multiply(hi0, lo1);
if( (double)C != b*c ) return TypeInt::INT; // Overflow?
- int32_t D = hi0*hi1;
+ int32_t D = java_multiply(hi0, hi1);
if( (double)D != b*d ) return TypeInt::INT; // Overflow?
if( A < B ) { lo0 = A; hi0 = B; } // Sort range endpoints
@@ -341,13 +341,13 @@ const Type *MulLNode::mul_ring(const Type *t0, const Type *t1) const {
double d = (double)hi1;
// Compute all endpoints & check for overflow
- jlong A = lo0*lo1;
+ jlong A = java_multiply(lo0, lo1);
if( (double)A != a*c ) return TypeLong::LONG; // Overflow?
- jlong B = lo0*hi1;
+ jlong B = java_multiply(lo0, hi1);
if( (double)B != a*d ) return TypeLong::LONG; // Overflow?
- jlong C = hi0*lo1;
+ jlong C = java_multiply(hi0, lo1);
if( (double)C != b*c ) return TypeLong::LONG; // Overflow?
- jlong D = hi0*hi1;
+ jlong D = java_multiply(hi0, hi1);
if( (double)D != b*d ) return TypeLong::LONG; // Overflow?
if( A < B ) { lo0 = A; hi0 = B; } // Sort range endpoints
@@ -574,7 +574,8 @@ Node *AndLNode::Identity( PhaseTransform *phase ) {
// Masking off high bits which are always zero is useless.
const TypeLong* t1 = phase->type( in(1) )->isa_long();
if (t1 != NULL && t1->_lo >= 0) {
- jlong t1_support = ((jlong)1 << (1 + log2_long(t1->_hi))) - 1;
+ int bit_count = log2_long(t1->_hi) + 1;
+ jlong t1_support = jlong(max_julong >> (BitsPerJavaLong - bit_count));
if ((t1_support & con) == t1_support)
return usr;
}
@@ -802,7 +803,7 @@ Node *LShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Check for ((x & ((CONST64(1)<<(64-c0))-1)) << c0) which ANDs off high bits
// before shifting them away.
- const jlong bits_mask = ((jlong)CONST64(1) << (jlong)(BitsPerJavaLong - con)) - CONST64(1);
+ const jlong bits_mask = jlong(max_julong >> con);
if( add1_op == Op_AndL &&
phase->type(add1->in(2)) == TypeLong::make( bits_mask ) )
return new LShiftLNode( add1->in(1), in(2) );
@@ -1254,7 +1255,7 @@ Node *URShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if ( con == 0 ) return NULL; // let Identity() handle a 0 shift count
// note: mask computation below does not work for 0 shift count
// We'll be wanting the right-shift amount as a mask of that many bits
- const jlong mask = (((jlong)CONST64(1) << (jlong)(BitsPerJavaLong - con)) -1);
+ const jlong mask = jlong(max_julong >> con);
// Check for ((x << z) + Y) >>> z. Replace with x + con>>>z
// The idiom for rounding to a power of 2 is "(Q+(2^z-1)) >>> z".
diff --git a/hotspot/src/share/vm/opto/node.cpp b/hotspot/src/share/vm/opto/node.cpp
index dc91ef3e471..ac093690bc5 100644
--- a/hotspot/src/share/vm/opto/node.cpp
+++ b/hotspot/src/share/vm/opto/node.cpp
@@ -2365,6 +2365,17 @@ void Node_List::dump() const {
#endif
}
+void Node_List::dump_simple() const {
+#ifndef PRODUCT
+ for( uint i = 0; i < _cnt; i++ )
+ if( _nodes[i] ) {
+ tty->print(" %d", _nodes[i]->_idx);
+ } else {
+ tty->print(" NULL");
+ }
+#endif
+}
+
//=============================================================================
//------------------------------remove-----------------------------------------
void Unique_Node_List::remove( Node *n ) {
diff --git a/hotspot/src/share/vm/opto/node.hpp b/hotspot/src/share/vm/opto/node.hpp
index 0d29b85b45a..d737f537868 100644
--- a/hotspot/src/share/vm/opto/node.hpp
+++ b/hotspot/src/share/vm/opto/node.hpp
@@ -1442,6 +1442,7 @@ public:
void clear() { _cnt = 0; Node_Array::clear(); } // retain storage
uint size() const { return _cnt; }
void dump() const;
+ void dump_simple() const;
};
//------------------------------Unique_Node_List-------------------------------
diff --git a/hotspot/src/share/vm/opto/parse1.cpp b/hotspot/src/share/vm/opto/parse1.cpp
index 77154c5da07..e051b5e1e5c 100644
--- a/hotspot/src/share/vm/opto/parse1.cpp
+++ b/hotspot/src/share/vm/opto/parse1.cpp
@@ -962,6 +962,14 @@ void Parse::do_exits() {
PPC64_ONLY(wrote_volatile() ||)
(AlwaysSafeConstructors && wrote_fields()))) {
_exits.insert_mem_bar(Op_MemBarRelease, alloc_with_final());
+
+ // If Memory barrier is created for final fields write
+ // and allocation node does not escape the initialize method,
+ // then barrier introduced by allocation node can be removed.
+ if (DoEscapeAnalysis && alloc_with_final()) {
+ AllocateNode *alloc = AllocateNode::Ideal_allocation(alloc_with_final(), &_gvn);
+ alloc->compute_MemBar_redundancy(method());
+ }
if (PrintOpto && (Verbose || WizardMode)) {
method()->print_name();
tty->print_cr(" writes finals and needs a memory barrier");
diff --git a/hotspot/src/share/vm/opto/runtime.cpp b/hotspot/src/share/vm/opto/runtime.cpp
index 7e249dd5b30..e6639491063 100644
--- a/hotspot/src/share/vm/opto/runtime.cpp
+++ b/hotspot/src/share/vm/opto/runtime.cpp
@@ -949,6 +949,35 @@ const TypeFunc* OptoRuntime::cipherBlockChaining_aescrypt_Type() {
return TypeFunc::make(domain, range);
}
+//for counterMode calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
+const TypeFunc* OptoRuntime::counterMode_aescrypt_Type() {
+ // create input type (domain)
+ int num_args = 7;
+ if (Matcher::pass_original_key_for_aes()) {
+ num_args = 8;
+ }
+ int argcnt = num_args;
+ const Type** fields = TypeTuple::fields(argcnt);
+ int argp = TypeFunc::Parms;
+ fields[argp++] = TypePtr::NOTNULL; // src
+ fields[argp++] = TypePtr::NOTNULL; // dest
+ fields[argp++] = TypePtr::NOTNULL; // k array
+ fields[argp++] = TypePtr::NOTNULL; // counter array
+ fields[argp++] = TypeInt::INT; // src len
+ fields[argp++] = TypePtr::NOTNULL; // saved_encCounter
+ fields[argp++] = TypePtr::NOTNULL; // saved used addr
+ if (Matcher::pass_original_key_for_aes()) {
+ fields[argp++] = TypePtr::NOTNULL; // original k array
+ }
+ assert(argp == TypeFunc::Parms + argcnt, "correct decoding");
+ const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + argcnt, fields);
+ // returning cipher len (int)
+ fields = TypeTuple::fields(1);
+ fields[TypeFunc::Parms + 0] = TypeInt::INT;
+ const TypeTuple* range = TypeTuple::make(TypeFunc::Parms + 1, fields);
+ return TypeFunc::make(domain, range);
+}
+
/*
* void implCompress(byte[] buf, int ofs)
*/
@@ -1104,6 +1133,26 @@ const TypeFunc* OptoRuntime::montgomerySquare_Type() {
return TypeFunc::make(domain, range);
}
+const TypeFunc* OptoRuntime::vectorizedMismatch_Type() {
+ // create input type (domain)
+ int num_args = 4;
+ int argcnt = num_args;
+ const Type** fields = TypeTuple::fields(argcnt);
+ int argp = TypeFunc::Parms;
+ fields[argp++] = TypePtr::NOTNULL; // obja
+ fields[argp++] = TypePtr::NOTNULL; // objb
+ fields[argp++] = TypeInt::INT; // length, number of elements
+ fields[argp++] = TypeInt::INT; // log2scale, element size
+ assert(argp == TypeFunc::Parms + argcnt, "correct decoding");
+ const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + argcnt, fields);
+
+ //return mismatch index (int)
+ fields = TypeTuple::fields(1);
+ fields[TypeFunc::Parms + 0] = TypeInt::INT;
+ const TypeTuple* range = TypeTuple::make(TypeFunc::Parms + 1, fields);
+ return TypeFunc::make(domain, range);
+}
+
// GHASH block processing
const TypeFunc* OptoRuntime::ghash_processBlocks_Type() {
int argcnt = 4;
diff --git a/hotspot/src/share/vm/opto/runtime.hpp b/hotspot/src/share/vm/opto/runtime.hpp
index 8e38f3f3a15..91c72b2d38d 100644
--- a/hotspot/src/share/vm/opto/runtime.hpp
+++ b/hotspot/src/share/vm/opto/runtime.hpp
@@ -287,6 +287,7 @@ private:
static const TypeFunc* aescrypt_block_Type();
static const TypeFunc* cipherBlockChaining_aescrypt_Type();
+ static const TypeFunc* counterMode_aescrypt_Type();
static const TypeFunc* sha_implCompress_Type();
static const TypeFunc* digestBase_implCompressMB_Type();
@@ -299,6 +300,8 @@ private:
static const TypeFunc* mulAdd_Type();
+ static const TypeFunc* vectorizedMismatch_Type();
+
static const TypeFunc* ghash_processBlocks_Type();
static const TypeFunc* updateBytesCRC32_Type();
diff --git a/hotspot/src/share/vm/opto/subnode.cpp b/hotspot/src/share/vm/opto/subnode.cpp
index 4eb9dc9e2af..6e27f53c0a4 100644
--- a/hotspot/src/share/vm/opto/subnode.cpp
+++ b/hotspot/src/share/vm/opto/subnode.cpp
@@ -252,8 +252,8 @@ Node *SubINode::Ideal(PhaseGVN *phase, bool can_reshape){
const Type *SubINode::sub( const Type *t1, const Type *t2 ) const {
const TypeInt *r0 = t1->is_int(); // Handy access
const TypeInt *r1 = t2->is_int();
- int32_t lo = r0->_lo - r1->_hi;
- int32_t hi = r0->_hi - r1->_lo;
+ int32_t lo = java_subtract(r0->_lo, r1->_hi);
+ int32_t hi = java_subtract(r0->_hi, r1->_lo);
// We next check for 32-bit overflow.
// If that happens, we just assume all integers are possible.
@@ -361,8 +361,8 @@ Node *SubLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
const Type *SubLNode::sub( const Type *t1, const Type *t2 ) const {
const TypeLong *r0 = t1->is_long(); // Handy access
const TypeLong *r1 = t2->is_long();
- jlong lo = r0->_lo - r1->_hi;
- jlong hi = r0->_hi - r1->_lo;
+ jlong lo = java_subtract(r0->_lo, r1->_hi);
+ jlong hi = java_subtract(r0->_hi, r1->_lo);
// We next check for 32-bit overflow.
// If that happens, we just assume all integers are possible.
@@ -1519,17 +1519,3 @@ const Type *Log10DNode::Value( PhaseTransform *phase ) const {
return TypeD::make( StubRoutines::intrinsic_log10( d ) );
}
-//=============================================================================
-//------------------------------Value------------------------------------------
-// Compute pow
-const Type *PowDNode::Value( PhaseTransform *phase ) const {
- const Type *t1 = phase->type( in(1) );
- if( t1 == Type::TOP ) return Type::TOP;
- if( t1->base() != Type::DoubleCon ) return Type::DOUBLE;
- const Type *t2 = phase->type( in(2) );
- if( t2 == Type::TOP ) return Type::TOP;
- if( t2->base() != Type::DoubleCon ) return Type::DOUBLE;
- double d1 = t1->getd();
- double d2 = t2->getd();
- return TypeD::make( StubRoutines::intrinsic_pow( d1, d2 ) );
-}
diff --git a/hotspot/src/share/vm/opto/subnode.hpp b/hotspot/src/share/vm/opto/subnode.hpp
index caeaae93a42..3ee7b4763b1 100644
--- a/hotspot/src/share/vm/opto/subnode.hpp
+++ b/hotspot/src/share/vm/opto/subnode.hpp
@@ -491,20 +491,6 @@ public:
virtual const Type *Value( PhaseTransform *phase ) const;
};
-//------------------------------PowDNode---------------------------------------
-// Raise a double to a double power
-class PowDNode : public Node {
-public:
- PowDNode(Compile* C, Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {
- init_flags(Flag_is_expensive);
- C->add_expensive_node(this);
- }
- virtual int Opcode() const;
- const Type *bottom_type() const { return Type::DOUBLE; }
- virtual uint ideal_reg() const { return Op_RegD; }
- virtual const Type *Value( PhaseTransform *phase ) const;
-};
-
//-------------------------------ReverseBytesINode--------------------------------
// reverse bytes of an integer
class ReverseBytesINode : public Node {
diff --git a/hotspot/src/share/vm/opto/type.cpp b/hotspot/src/share/vm/opto/type.cpp
index ec4c898afb2..42b290bd29e 100644
--- a/hotspot/src/share/vm/opto/type.cpp
+++ b/hotspot/src/share/vm/opto/type.cpp
@@ -1370,8 +1370,8 @@ const Type *TypeInt::narrow( const Type *old ) const {
// The new type narrows the old type, so look for a "death march".
// See comments on PhaseTransform::saturate.
- juint nrange = _hi - _lo;
- juint orange = ohi - olo;
+ juint nrange = (juint)_hi - _lo;
+ juint orange = (juint)ohi - olo;
if (nrange < max_juint - 1 && nrange > (orange >> 1) + (SMALLINT*2)) {
// Use the new type only if the range shrinks a lot.
// We do not want the optimizer computing 2^31 point by point.
@@ -1404,7 +1404,7 @@ bool TypeInt::eq( const Type *t ) const {
//------------------------------hash-------------------------------------------
// Type-specific hashing function.
int TypeInt::hash(void) const {
- return _lo+_hi+_widen+(int)Type::Int;
+ return java_add(java_add(_lo, _hi), java_add(_widen, (int)Type::Int));
}
//------------------------------is_finite--------------------------------------
@@ -1585,7 +1585,7 @@ const Type *TypeLong::widen( const Type *old, const Type* limit ) const {
// If neither endpoint is extremal yet, push out the endpoint
// which is closer to its respective limit.
if (_lo >= 0 || // easy common case
- (julong)(_lo - min) >= (julong)(max - _hi)) {
+ ((julong)_lo - min) >= ((julong)max - _hi)) {
// Try to widen to an unsigned range type of 32/63 bits:
if (max >= max_juint && _hi < max_juint)
return make(_lo, max_juint, WidenMax);
@@ -2404,7 +2404,7 @@ bool TypePtr::eq( const Type *t ) const {
//------------------------------hash-------------------------------------------
// Type-specific hashing function.
int TypePtr::hash(void) const {
- return _ptr + _offset + hash_speculative() + _inline_depth;
+ return java_add(java_add(_ptr, _offset), java_add( hash_speculative(), _inline_depth));
;
}
@@ -3214,10 +3214,8 @@ bool TypeOopPtr::eq( const Type *t ) const {
// Type-specific hashing function.
int TypeOopPtr::hash(void) const {
return
- (const_oop() ? const_oop()->hash() : 0) +
- _klass_is_exact +
- _instance_id +
- TypePtr::hash();
+ java_add(java_add(const_oop() ? const_oop()->hash() : 0, _klass_is_exact),
+ java_add(_instance_id, TypePtr::hash()));
}
//------------------------------dump2------------------------------------------
@@ -3824,7 +3822,7 @@ bool TypeInstPtr::eq( const Type *t ) const {
//------------------------------hash-------------------------------------------
// Type-specific hashing function.
int TypeInstPtr::hash(void) const {
- int hash = klass()->hash() + TypeOopPtr::hash();
+ int hash = java_add(klass()->hash(), TypeOopPtr::hash());
return hash;
}
@@ -4742,7 +4740,7 @@ bool TypeKlassPtr::eq( const Type *t ) const {
//------------------------------hash-------------------------------------------
// Type-specific hashing function.
int TypeKlassPtr::hash(void) const {
- return klass()->hash() + TypePtr::hash();
+ return java_add(klass()->hash(), TypePtr::hash());
}
//------------------------------singleton--------------------------------------
diff --git a/hotspot/src/share/vm/prims/methodHandles.cpp b/hotspot/src/share/vm/prims/methodHandles.cpp
index 99e8a785f10..4f21e410c24 100644
--- a/hotspot/src/share/vm/prims/methodHandles.cpp
+++ b/hotspot/src/share/vm/prims/methodHandles.cpp
@@ -358,6 +358,19 @@ Symbol* MethodHandles::signature_polymorphic_intrinsic_name(vmIntrinsics::ID iid
return 0;
}
+Bytecodes::Code MethodHandles::signature_polymorphic_intrinsic_bytecode(vmIntrinsics::ID id) {
+ switch(id) {
+ case vmIntrinsics::_linkToVirtual: return Bytecodes::_invokevirtual;
+ case vmIntrinsics::_linkToInterface: return Bytecodes::_invokeinterface;
+ case vmIntrinsics::_linkToStatic: return Bytecodes::_invokestatic;
+ case vmIntrinsics::_linkToSpecial: return Bytecodes::_invokespecial;
+ case vmIntrinsics::_invokeBasic: return Bytecodes::_invokehandle;
+ default:
+ fatal("unexpected id: (%d) %s", (uint)id, vmIntrinsics::name_at(id));
+ return Bytecodes::_illegal;
+ }
+}
+
int MethodHandles::signature_polymorphic_intrinsic_ref_kind(vmIntrinsics::ID iid) {
switch (iid) {
case vmIntrinsics::_invokeBasic: return 0;
diff --git a/hotspot/src/share/vm/prims/methodHandles.hpp b/hotspot/src/share/vm/prims/methodHandles.hpp
index ad3a6aefcc8..2a23c5a05a6 100644
--- a/hotspot/src/share/vm/prims/methodHandles.hpp
+++ b/hotspot/src/share/vm/prims/methodHandles.hpp
@@ -97,6 +97,10 @@ class MethodHandles: AllStatic {
iid <= vmIntrinsics::LAST_MH_SIG_POLY);
}
+ static bool is_signature_polymorphic_method(Method* m) {
+ return is_signature_polymorphic(m->intrinsic_id());
+ }
+
static bool is_signature_polymorphic_intrinsic(vmIntrinsics::ID iid) {
assert(is_signature_polymorphic(iid), "");
// Most sig-poly methods are intrinsics which do not require an
@@ -137,6 +141,8 @@ class MethodHandles: AllStatic {
return signature_polymorphic_name_id(klass, name) != vmIntrinsics::_none;
}
+ static Bytecodes::Code signature_polymorphic_intrinsic_bytecode(vmIntrinsics::ID id);
+
static int get_named_constant(int which, Handle name_box, TRAPS);
public:
diff --git a/hotspot/src/share/vm/prims/nativeLookup.cpp b/hotspot/src/share/vm/prims/nativeLookup.cpp
index fecef0a5055..5f693b46684 100644
--- a/hotspot/src/share/vm/prims/nativeLookup.cpp
+++ b/hotspot/src/share/vm/prims/nativeLookup.cpp
@@ -107,7 +107,8 @@ char* NativeLookup::long_jni_name(const methodHandle& method) {
}
extern "C" {
- void JNICALL JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls);
+ void JNICALL JVM_RegisterJDKInternalMiscUnsafeMethods(JNIEnv *env, jclass unsafecls);
+ void JNICALL JVM_RegisterSunMiscUnsafeMethods(JNIEnv *env, jclass unsafecls);
void JNICALL JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass unsafecls);
void JNICALL JVM_RegisterPerfMethods(JNIEnv *env, jclass perfclass);
void JNICALL JVM_RegisterWhiteBoxMethods(JNIEnv *env, jclass wbclass);
@@ -121,8 +122,8 @@ extern "C" {
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
static JNINativeMethod lookup_special_native_methods[] = {
- { CC"Java_jdk_internal_misc_Unsafe_registerNatives", NULL, FN_PTR(JVM_RegisterUnsafeMethods) },
- { CC"Java_sun_misc_Unsafe_registerNatives", NULL, FN_PTR(JVM_RegisterUnsafeMethods) },
+ { CC"Java_jdk_internal_misc_Unsafe_registerNatives", NULL, FN_PTR(JVM_RegisterJDKInternalMiscUnsafeMethods) },
+ { CC"Java_sun_misc_Unsafe_registerNatives", NULL, FN_PTR(JVM_RegisterSunMiscUnsafeMethods) },
{ CC"Java_java_lang_invoke_MethodHandleNatives_registerNatives", NULL, FN_PTR(JVM_RegisterMethodHandleMethods) },
{ CC"Java_sun_misc_Perf_registerNatives", NULL, FN_PTR(JVM_RegisterPerfMethods) },
{ CC"Java_sun_hotspot_WhiteBox_registerNatives", NULL, FN_PTR(JVM_RegisterWhiteBoxMethods) },
diff --git a/hotspot/src/share/vm/prims/unsafe.cpp b/hotspot/src/share/vm/prims/unsafe.cpp
index 324d10a109b..c3d980d1751 100644
--- a/hotspot/src/share/vm/prims/unsafe.cpp
+++ b/hotspot/src/share/vm/prims/unsafe.cpp
@@ -1236,8 +1236,76 @@ UNSAFE_END
{CC "put" #Byte, CC "(" ADR#B ")V", FN_PTR(Unsafe_SetNative##Byte)}
+static JNINativeMethod sun_misc_Unsafe_methods[] = {
+ {CC "getObject", CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)},
+ {CC "putObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)},
+ {CC "getObjectVolatile",CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObjectVolatile)},
+ {CC "putObjectVolatile",CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObjectVolatile)},
-static JNINativeMethod methods[] = {
+ {CC "getUncompressedObject", CC "(" ADR ")" OBJ, FN_PTR(Unsafe_GetUncompressedObject)},
+ {CC "getJavaMirror", CC "(" ADR ")" CLS, FN_PTR(Unsafe_GetJavaMirror)},
+ {CC "getKlassPointer", CC "(" OBJ ")" ADR, FN_PTR(Unsafe_GetKlassPointer)},
+
+ DECLARE_GETPUTOOP(Boolean, Z),
+ DECLARE_GETPUTOOP(Byte, B),
+ DECLARE_GETPUTOOP(Short, S),
+ DECLARE_GETPUTOOP(Char, C),
+ DECLARE_GETPUTOOP(Int, I),
+ DECLARE_GETPUTOOP(Long, J),
+ DECLARE_GETPUTOOP(Float, F),
+ DECLARE_GETPUTOOP(Double, D),
+
+ DECLARE_GETPUTNATIVE(Byte, B),
+ DECLARE_GETPUTNATIVE(Short, S),
+ DECLARE_GETPUTNATIVE(Char, C),
+ DECLARE_GETPUTNATIVE(Int, I),
+ DECLARE_GETPUTNATIVE(Long, J),
+ DECLARE_GETPUTNATIVE(Float, F),
+ DECLARE_GETPUTNATIVE(Double, D),
+
+ {CC "getAddress", CC "(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)},
+ {CC "putAddress", CC "(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)},
+
+ {CC "allocateMemory", CC "(J)" ADR, FN_PTR(Unsafe_AllocateMemory)},
+ {CC "reallocateMemory", CC "(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)},
+ {CC "freeMemory", CC "(" ADR ")V", FN_PTR(Unsafe_FreeMemory)},
+
+ {CC "objectFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)},
+ {CC "staticFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)},
+ {CC "staticFieldBase", CC "(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
+ {CC "ensureClassInitialized",CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)},
+ {CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
+ {CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
+ {CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
+ {CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
+
+ {CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
+ {CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
+ {CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)},
+ {CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
+ {CC "compareAndSwapInt", CC "(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
+ {CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
+ {CC "putOrderedObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetOrderedObject)},
+ {CC "putOrderedInt", CC "(" OBJ "JI)V", FN_PTR(Unsafe_SetOrderedInt)},
+ {CC "putOrderedLong", CC "(" OBJ "JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
+ {CC "park", CC "(ZJ)V", FN_PTR(Unsafe_Park)},
+ {CC "unpark", CC "(" OBJ ")V", FN_PTR(Unsafe_Unpark)},
+
+ {CC "getLoadAverage", CC "([DI)I", FN_PTR(Unsafe_Loadavg)},
+
+ {CC "copyMemory", CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory)},
+ {CC "setMemory", CC "(" OBJ "JJB)V", FN_PTR(Unsafe_SetMemory)},
+
+ {CC "defineAnonymousClass", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass)},
+
+ {CC "shouldBeInitialized",CC "(" CLS ")Z", FN_PTR(Unsafe_ShouldBeInitialized)},
+
+ {CC "loadFence", CC "()V", FN_PTR(Unsafe_LoadFence)},
+ {CC "storeFence", CC "()V", FN_PTR(Unsafe_StoreFence)},
+ {CC "fullFence", CC "()V", FN_PTR(Unsafe_FullFence)},
+};
+
+static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
{CC "getObject", CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)},
{CC "putObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)},
{CC "getObjectVolatile",CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObjectVolatile)},
@@ -1325,17 +1393,27 @@ static JNINativeMethod methods[] = {
#undef DECLARE_GETPUTNATIVE
-// This one function is exported, used by NativeLookup.
+// These two functions are exported, used by NativeLookup.
// The Unsafe_xxx functions above are called only from the interpreter.
// The optimizer looks at names and signatures to recognize
// individual functions.
-JVM_ENTRY(void, JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafeclass))
- UnsafeWrapper("JVM_RegisterUnsafeMethods");
+JVM_ENTRY(void, JVM_RegisterSunMiscUnsafeMethods(JNIEnv *env, jclass unsafeclass))
+ UnsafeWrapper("JVM_RegisterSunMiscUnsafeMethods");
{
ThreadToNativeFromVM ttnfv(thread);
- int ok = env->RegisterNatives(unsafeclass, methods, sizeof(methods)/sizeof(JNINativeMethod));
- guarantee(ok == 0, "register unsafe natives");
+ int ok = env->RegisterNatives(unsafeclass, sun_misc_Unsafe_methods, sizeof(sun_misc_Unsafe_methods)/sizeof(JNINativeMethod));
+ guarantee(ok == 0, "register sun.misc.Unsafe natives");
+ }
+JVM_END
+
+JVM_ENTRY(void, JVM_RegisterJDKInternalMiscUnsafeMethods(JNIEnv *env, jclass unsafeclass))
+ UnsafeWrapper("JVM_RegisterJDKInternalMiscUnsafeMethods");
+ {
+ ThreadToNativeFromVM ttnfv(thread);
+
+ int ok = env->RegisterNatives(unsafeclass, jdk_internal_misc_Unsafe_methods, sizeof(jdk_internal_misc_Unsafe_methods)/sizeof(JNINativeMethod));
+ guarantee(ok == 0, "register jdk.internal.misc.Unsafe natives");
}
JVM_END
diff --git a/hotspot/src/share/vm/prims/whitebox.cpp b/hotspot/src/share/vm/prims/whitebox.cpp
index 80a8f454728..39e8a4bde15 100644
--- a/hotspot/src/share/vm/prims/whitebox.cpp
+++ b/hotspot/src/share/vm/prims/whitebox.cpp
@@ -1017,9 +1017,9 @@ WB_ENTRY(void, WB_ReadReservedMemory(JNIEnv* env, jobject o))
WB_END
WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
- const char* cpu_features = VM_Version::cpu_features();
+ const char* features = VM_Version::features_string();
ThreadToNativeFromVM ttn(thread);
- jstring features_string = env->NewStringUTF(cpu_features);
+ jstring features_string = env->NewStringUTF(features);
CHECK_JNI_EXCEPTION_(env, NULL);
@@ -1302,6 +1302,11 @@ WB_ENTRY(jlong, WB_GetConstantPool(JNIEnv* env, jobject wb, jclass klass))
return (jlong) ikh->constants();
WB_END
+WB_ENTRY(void, WB_ClearInlineCaches(JNIEnv* env, jobject wb))
+ VM_ClearICs clear_ics;
+ VMThread::execute(&clear_ics);
+WB_END
+
template
static bool GetMethodOption(JavaThread* thread, JNIEnv* env, jobject method, jstring name, T* value) {
assert(value != NULL, "sanity");
@@ -1629,6 +1634,7 @@ static JNINativeMethod methods[] = {
(void*)&WB_GetMethodStringOption},
{CC"isShared", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsShared },
{CC"areSharedStringsIgnored", CC"()Z", (void*)&WB_AreSharedStringsIgnored },
+ {CC"clearInlineCaches", CC"()V", (void*)&WB_ClearInlineCaches },
};
#undef CC
diff --git a/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp b/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp
index cd73fa78559..5d9a3096787 100644
--- a/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp
+++ b/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp
@@ -133,7 +133,8 @@ bool AdvancedThresholdPolicy::is_old(Method* method) {
}
double AdvancedThresholdPolicy::weight(Method* method) {
- return (method->rate() + 1) * ((method->invocation_count() + 1) * (method->backedge_count() + 1));
+ return (double)(method->rate() + 1) *
+ (method->invocation_count() + 1) * (method->backedge_count() + 1);
}
// Apply heuristics and return true if x should be compiled before y
diff --git a/hotspot/src/share/vm/runtime/arguments.cpp b/hotspot/src/share/vm/runtime/arguments.cpp
index 7fc37d0865c..279ebf4f7dc 100644
--- a/hotspot/src/share/vm/runtime/arguments.cpp
+++ b/hotspot/src/share/vm/runtime/arguments.cpp
@@ -3378,12 +3378,6 @@ jint Arguments::finalize_vm_init_args(SysClassPath* scp_p, bool scp_assembly_req
const char* fileSep = os::file_separator();
sprintf(path, "%s%slib%sendorsed", Arguments::get_java_home(), fileSep, fileSep);
-#if INCLUDE_JVMCI
- if (EnableJVMCI) {
- JVMCIRuntime::save_options(_system_properties);
- }
-#endif // INCLUDE_JVMCI
-
if (CheckEndorsedAndExtDirs) {
int nonEmptyDirs = 0;
// check endorsed directory
diff --git a/hotspot/src/share/vm/runtime/basicLock.hpp b/hotspot/src/share/vm/runtime/basicLock.hpp
index 309e07c0bd0..cc4e37eed52 100644
--- a/hotspot/src/share/vm/runtime/basicLock.hpp
+++ b/hotspot/src/share/vm/runtime/basicLock.hpp
@@ -31,6 +31,7 @@
class BasicLock VALUE_OBJ_CLASS_SPEC {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
volatile markOop _displaced_header;
public:
diff --git a/hotspot/src/share/vm/runtime/deoptimization.hpp b/hotspot/src/share/vm/runtime/deoptimization.hpp
index 7e63ab6bd38..82bb20af4e9 100644
--- a/hotspot/src/share/vm/runtime/deoptimization.hpp
+++ b/hotspot/src/share/vm/runtime/deoptimization.hpp
@@ -168,6 +168,7 @@ JVMCI_ONLY(public:)
// This is only a CheapObj to ease debugging after a deopt failure
class UnrollBlock : public CHeapObj {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
int _size_of_deoptimized_frame; // Size, in bytes, of current deoptimized frame
int _caller_adjustment; // Adjustment, in bytes, to caller's SP by initial interpreted frame
diff --git a/hotspot/src/share/vm/runtime/globals.hpp b/hotspot/src/share/vm/runtime/globals.hpp
index 9a444cb7c1d..093578b168c 100644
--- a/hotspot/src/share/vm/runtime/globals.hpp
+++ b/hotspot/src/share/vm/runtime/globals.hpp
@@ -835,6 +835,9 @@ public:
product(bool, UseAESIntrinsics, false, \
"Use intrinsics for AES versions of crypto") \
\
+ product(bool, UseAESCTRIntrinsics, false, \
+ "Use intrinsics for the paralleled version of AES/CTR crypto") \
+ \
product(bool, UseSHA1Intrinsics, false, \
"Use intrinsics for SHA-1 crypto hash function. " \
"Requires that UseSHA is enabled.") \
@@ -856,6 +859,9 @@ public:
product(bool, UseAdler32Intrinsics, false, \
"use intrinsics for java.util.zip.Adler32") \
\
+ product(bool, UseVectorizedMismatchIntrinsic, false, \
+ "Enables intrinsification of ArraysSupport.vectorizedMismatch()") \
+ \
diagnostic(ccstrlist, DisableIntrinsic, "", \
"do not expand intrinsics whose (internal) names appear here") \
\
@@ -4168,8 +4174,11 @@ public:
diagnostic(bool, CompilerDirectivesIgnoreCompileCommands, false, \
"Disable backwards compatibility for compile commands.") \
\
- diagnostic(bool, PrintCompilerDirectives, false, \
- "Print compiler directives on installation.")
+ diagnostic(bool, CompilerDirectivesPrint, false, \
+ "Print compiler directives on installation.") \
+ diagnostic(int, CompilerDirectivesLimit, 50, \
+ "Limit on number of compiler directives.")
+
/*
* Macros for factoring of globals
diff --git a/hotspot/src/share/vm/runtime/java.cpp b/hotspot/src/share/vm/runtime/java.cpp
index b65c2c2e1aa..aa57bbc4601 100644
--- a/hotspot/src/share/vm/runtime/java.cpp
+++ b/hotspot/src/share/vm/runtime/java.cpp
@@ -398,7 +398,7 @@ void print_statistics() {
// Note: before_exit() can be executed only once, if more than one threads
// are trying to shutdown the VM at the same time, only one thread
// can run before_exit() and all other threads must wait.
-void before_exit(JavaThread * thread) {
+void before_exit(JavaThread* thread) {
#define BEFORE_EXIT_NOT_RUN 0
#define BEFORE_EXIT_RUNNING 1
#define BEFORE_EXIT_DONE 2
@@ -426,7 +426,15 @@ void before_exit(JavaThread * thread) {
}
#if INCLUDE_JVMCI
- JVMCIRuntime::shutdown();
+ // We are not using CATCH here because we want the exit to continue normally.
+ Thread* THREAD = thread;
+ JVMCIRuntime::shutdown(THREAD);
+ if (HAS_PENDING_EXCEPTION) {
+ Handle exception(THREAD, PENDING_EXCEPTION);
+ CLEAR_PENDING_EXCEPTION;
+ ttyLocker ttyl;
+ java_lang_Throwable::print_stack_trace(exception, tty);
+ }
#endif
// Hang forever on exit if we're reporting an error.
@@ -612,9 +620,7 @@ void vm_exit_during_initialization(Handle exception) {
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
}
- java_lang_Throwable::print(exception, tty);
- tty->cr();
- java_lang_Throwable::print_stack_trace(exception(), tty);
+ java_lang_Throwable::print_stack_trace(exception, tty);
tty->cr();
vm_notify_during_shutdown(NULL, NULL);
diff --git a/hotspot/src/share/vm/runtime/javaFrameAnchor.hpp b/hotspot/src/share/vm/runtime/javaFrameAnchor.hpp
index 72c1fec5135..777698c3825 100644
--- a/hotspot/src/share/vm/runtime/javaFrameAnchor.hpp
+++ b/hotspot/src/share/vm/runtime/javaFrameAnchor.hpp
@@ -47,6 +47,7 @@ friend class StubGenerator;
friend class JavaThread;
friend class frame;
friend class VMStructs;
+friend class JVMCIVMStructs;
friend class BytecodeInterpreter;
friend class JavaCallWrapper;
diff --git a/hotspot/src/share/vm/runtime/os.cpp b/hotspot/src/share/vm/runtime/os.cpp
index c0019941ae2..699914032ff 100644
--- a/hotspot/src/share/vm/runtime/os.cpp
+++ b/hotspot/src/share/vm/runtime/os.cpp
@@ -827,7 +827,7 @@ void os::print_cpu_info(outputStream* st, char* buf, size_t buflen) {
st->print("total %d", os::processor_count());
// It's not safe to query number of active processors after crash
// st->print("(active %d)", os::active_processor_count());
- st->print(" %s", VM_Version::cpu_features());
+ st->print(" %s", VM_Version::features_string());
st->cr();
pd_print_cpu_info(st, buf, buflen);
}
diff --git a/hotspot/src/share/vm/runtime/os.hpp b/hotspot/src/share/vm/runtime/os.hpp
index 3dda79cf0ce..70888fdf31e 100644
--- a/hotspot/src/share/vm/runtime/os.hpp
+++ b/hotspot/src/share/vm/runtime/os.hpp
@@ -102,6 +102,7 @@ class MallocTracker;
class os: AllStatic {
friend class VMStructs;
+ friend class JVMCIVMStructs;
friend class MallocTracker;
public:
enum { page_sizes_max = 9 }; // Size of _page_sizes array (8 plus a sentinel)
diff --git a/hotspot/src/share/vm/runtime/osThread.hpp b/hotspot/src/share/vm/runtime/osThread.hpp
index 02f3c0203fd..29912bd5187 100644
--- a/hotspot/src/share/vm/runtime/osThread.hpp
+++ b/hotspot/src/share/vm/runtime/osThread.hpp
@@ -60,6 +60,7 @@ enum ThreadState {
class OSThread: public CHeapObj {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
OSThreadStartFunc _start_proc; // Thread start routine
void* _start_parm; // Thread start routine parameter
diff --git a/hotspot/src/share/vm/runtime/sharedRuntime.cpp b/hotspot/src/share/vm/runtime/sharedRuntime.cpp
index 12a657ea589..f2497b54fbb 100644
--- a/hotspot/src/share/vm/runtime/sharedRuntime.cpp
+++ b/hotspot/src/share/vm/runtime/sharedRuntime.cpp
@@ -1091,6 +1091,18 @@ Handle SharedRuntime::find_callee_info(JavaThread* thread, Bytecodes::Code& bc,
return find_callee_info_helper(thread, vfst, bc, callinfo, THREAD);
}
+methodHandle SharedRuntime::extract_attached_method(vframeStream& vfst) {
+ nmethod* caller_nm = vfst.nm();
+
+ nmethodLocker caller_lock(caller_nm);
+
+ address pc = vfst.frame_pc();
+ { // Get call instruction under lock because another thread may be busy patching it.
+ MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag);
+ return caller_nm->attached_method_before_pc(pc);
+ }
+ return NULL;
+}
// Finds receiver, CallInfo (i.e. receiver method), and calling bytecode
// for a call current in progress, i.e., arguments has been pushed on stack
@@ -1108,15 +1120,37 @@ Handle SharedRuntime::find_callee_info_helper(JavaThread* thread,
methodHandle caller(THREAD, vfst.method());
int bci = vfst.bci();
- // Find bytecode
Bytecode_invoke bytecode(caller, bci);
- bc = bytecode.invoke_code();
int bytecode_index = bytecode.index();
+ methodHandle attached_method = extract_attached_method(vfst);
+ if (attached_method.not_null()) {
+ methodHandle callee = bytecode.static_target(CHECK_NH);
+ vmIntrinsics::ID id = callee->intrinsic_id();
+ // When VM replaces MH.invokeBasic/linkTo* call with a direct/virtual call,
+ // it attaches statically resolved method to the call site.
+ if (MethodHandles::is_signature_polymorphic(id) &&
+ MethodHandles::is_signature_polymorphic_intrinsic(id)) {
+ bc = MethodHandles::signature_polymorphic_intrinsic_bytecode(id);
+
+ // Need to adjust invokehandle since inlining through signature-polymorphic
+ // method happened.
+ if (bc == Bytecodes::_invokehandle &&
+ !MethodHandles::is_signature_polymorphic_method(attached_method())) {
+ bc = attached_method->is_static() ? Bytecodes::_invokestatic
+ : Bytecodes::_invokevirtual;
+ }
+ }
+ } else {
+ bc = bytecode.invoke_code();
+ }
+
+ bool has_receiver = bc != Bytecodes::_invokestatic &&
+ bc != Bytecodes::_invokedynamic &&
+ bc != Bytecodes::_invokehandle;
+
// Find receiver for non-static call
- if (bc != Bytecodes::_invokestatic &&
- bc != Bytecodes::_invokedynamic &&
- bc != Bytecodes::_invokehandle) {
+ if (has_receiver) {
// This register map must be update since we need to find the receiver for
// compiled frames. The receiver might be in a register.
RegisterMap reg_map2(thread);
@@ -1124,10 +1158,13 @@ Handle SharedRuntime::find_callee_info_helper(JavaThread* thread,
// Caller-frame is a compiled frame
frame callerFrame = stubFrame.sender(®_map2);
- methodHandle callee = bytecode.static_target(CHECK_(nullHandle));
- if (callee.is_null()) {
- THROW_(vmSymbols::java_lang_NoSuchMethodException(), nullHandle);
+ if (attached_method.is_null()) {
+ methodHandle callee = bytecode.static_target(CHECK_NH);
+ if (callee.is_null()) {
+ THROW_(vmSymbols::java_lang_NoSuchMethodException(), nullHandle);
+ }
}
+
// Retrieve from a compiled argument list
receiver = Handle(THREAD, callerFrame.retrieve_receiver(®_map2));
@@ -1136,26 +1173,35 @@ Handle SharedRuntime::find_callee_info_helper(JavaThread* thread,
}
}
- // Resolve method. This is parameterized by bytecode.
- constantPoolHandle constants(THREAD, caller->constants());
assert(receiver.is_null() || receiver->is_oop(), "wrong receiver");
- LinkResolver::resolve_invoke(callinfo, receiver, constants, bytecode_index, bc, CHECK_(nullHandle));
+
+ // Resolve method
+ if (attached_method.not_null()) {
+ // Parameterized by attached method.
+ LinkResolver::resolve_invoke(callinfo, receiver, attached_method, bc, CHECK_NH);
+ } else {
+ // Parameterized by bytecode.
+ constantPoolHandle constants(THREAD, caller->constants());
+ LinkResolver::resolve_invoke(callinfo, receiver, constants, bytecode_index, bc, CHECK_NH);
+ }
#ifdef ASSERT
// Check that the receiver klass is of the right subtype and that it is initialized for virtual calls
- if (bc != Bytecodes::_invokestatic && bc != Bytecodes::_invokedynamic && bc != Bytecodes::_invokehandle) {
+ if (has_receiver) {
assert(receiver.not_null(), "should have thrown exception");
KlassHandle receiver_klass(THREAD, receiver->klass());
- Klass* rk = constants->klass_ref_at(bytecode_index, CHECK_(nullHandle));
- // klass is already loaded
+ Klass* rk = NULL;
+ if (attached_method.not_null()) {
+ // In case there's resolved method attached, use its holder during the check.
+ rk = attached_method->method_holder();
+ } else {
+ // Klass is already loaded.
+ constantPoolHandle constants(THREAD, caller->constants());
+ rk = constants->klass_ref_at(bytecode_index, CHECK_NH);
+ }
KlassHandle static_receiver_klass(THREAD, rk);
- // Method handle invokes might have been optimized to a direct call
- // so don't check for the receiver class.
- // FIXME this weakens the assert too much
methodHandle callee = callinfo.selected_method();
- assert(receiver_klass->is_subtype_of(static_receiver_klass()) ||
- callee->is_method_handle_intrinsic() ||
- callee->is_compiled_lambda_form(),
+ assert(receiver_klass->is_subtype_of(static_receiver_klass()),
"actual receiver must be subclass of static receiver klass");
if (receiver_klass->is_instance_klass()) {
if (InstanceKlass::cast(receiver_klass())->is_not_initialized()) {
@@ -1691,7 +1737,6 @@ methodHandle SharedRuntime::reresolve_call_site(JavaThread *thread, TRAPS) {
inline_cache->set_to_clean();
}
}
-
}
methodHandle callee_method = find_callee_method(thread, CHECK_(methodHandle()));
diff --git a/hotspot/src/share/vm/runtime/sharedRuntime.hpp b/hotspot/src/share/vm/runtime/sharedRuntime.hpp
index b46a5037896..7e30c73e705 100644
--- a/hotspot/src/share/vm/runtime/sharedRuntime.hpp
+++ b/hotspot/src/share/vm/runtime/sharedRuntime.hpp
@@ -353,6 +353,8 @@ class SharedRuntime: AllStatic {
Bytecodes::Code& bc,
CallInfo& callinfo, TRAPS);
+ static methodHandle extract_attached_method(vframeStream& vfst);
+
static address clean_virtual_call_entry();
static address clean_opt_virtual_call_entry();
static address clean_static_call_entry();
diff --git a/hotspot/src/share/vm/runtime/stubRoutines.cpp b/hotspot/src/share/vm/runtime/stubRoutines.cpp
index 7bce6760d07..2682be50945 100644
--- a/hotspot/src/share/vm/runtime/stubRoutines.cpp
+++ b/hotspot/src/share/vm/runtime/stubRoutines.cpp
@@ -127,6 +127,7 @@ address StubRoutines::_aescrypt_encryptBlock = NULL;
address StubRoutines::_aescrypt_decryptBlock = NULL;
address StubRoutines::_cipherBlockChaining_encryptAESCrypt = NULL;
address StubRoutines::_cipherBlockChaining_decryptAESCrypt = NULL;
+address StubRoutines::_counterMode_AESCrypt = NULL;
address StubRoutines::_ghash_processBlocks = NULL;
address StubRoutines::_sha1_implCompress = NULL;
@@ -149,11 +150,13 @@ address StubRoutines::_mulAdd = NULL;
address StubRoutines::_montgomeryMultiply = NULL;
address StubRoutines::_montgomerySquare = NULL;
+address StubRoutines::_vectorizedMismatch = NULL;
+
address StubRoutines::_dexp = NULL;
address StubRoutines::_dlog = NULL;
+address StubRoutines::_dpow = NULL;
double (* StubRoutines::_intrinsic_log10 )(double) = NULL;
-double (* StubRoutines::_intrinsic_pow )(double, double) = NULL;
double (* StubRoutines::_intrinsic_sin )(double) = NULL;
double (* StubRoutines::_intrinsic_cos )(double) = NULL;
double (* StubRoutines::_intrinsic_tan )(double) = NULL;
diff --git a/hotspot/src/share/vm/runtime/stubRoutines.hpp b/hotspot/src/share/vm/runtime/stubRoutines.hpp
index edc3acb3ac1..a3f905aed11 100644
--- a/hotspot/src/share/vm/runtime/stubRoutines.hpp
+++ b/hotspot/src/share/vm/runtime/stubRoutines.hpp
@@ -186,6 +186,7 @@ class StubRoutines: AllStatic {
static address _aescrypt_decryptBlock;
static address _cipherBlockChaining_encryptAESCrypt;
static address _cipherBlockChaining_decryptAESCrypt;
+ static address _counterMode_AESCrypt;
static address _ghash_processBlocks;
static address _sha1_implCompress;
@@ -208,8 +209,11 @@ class StubRoutines: AllStatic {
static address _montgomeryMultiply;
static address _montgomerySquare;
+ static address _vectorizedMismatch;
+
static address _dexp;
static address _dlog;
+ static address _dpow;
// These are versions of the java.lang.Math methods which perform
// the same operations as the intrinsic version. They are used for
@@ -356,6 +360,7 @@ class StubRoutines: AllStatic {
static address aescrypt_decryptBlock() { return _aescrypt_decryptBlock; }
static address cipherBlockChaining_encryptAESCrypt() { return _cipherBlockChaining_encryptAESCrypt; }
static address cipherBlockChaining_decryptAESCrypt() { return _cipherBlockChaining_decryptAESCrypt; }
+ static address counterMode_AESCrypt() { return _counterMode_AESCrypt; }
static address ghash_processBlocks() { return _ghash_processBlocks; }
static address sha1_implCompress() { return _sha1_implCompress; }
@@ -378,8 +383,11 @@ class StubRoutines: AllStatic {
static address montgomeryMultiply() { return _montgomeryMultiply; }
static address montgomerySquare() { return _montgomerySquare; }
+ static address vectorizedMismatch() { return _vectorizedMismatch; }
+
static address dexp() { return _dexp; }
static address dlog() { return _dlog; }
+ static address dpow() { return _dpow; }
static address select_fill_function(BasicType t, bool aligned, const char* &name);
diff --git a/hotspot/src/share/vm/runtime/thread.cpp b/hotspot/src/share/vm/runtime/thread.cpp
index 94b363d774b..b762e2874a3 100644
--- a/hotspot/src/share/vm/runtime/thread.cpp
+++ b/hotspot/src/share/vm/runtime/thread.cpp
@@ -3661,13 +3661,12 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
if (jvmciCompiler != NULL) {
JVMCIRuntime::save_compiler(jvmciCompiler);
}
- JVMCIRuntime::maybe_print_flags(CHECK_JNI_ERR);
}
#endif // INCLUDE_JVMCI
// initialize compiler(s)
#if defined(COMPILER1) || defined(COMPILER2) || defined(SHARK) || INCLUDE_JVMCI
- CompileBroker::compilation_init();
+ CompileBroker::compilation_init(CHECK_JNI_ERR);
#endif
// Pre-initialize some JSR292 core classes to avoid deadlock during class loading.
diff --git a/hotspot/src/share/vm/runtime/thread.hpp b/hotspot/src/share/vm/runtime/thread.hpp
index 6904cd5c36c..804fbbd0a50 100644
--- a/hotspot/src/share/vm/runtime/thread.hpp
+++ b/hotspot/src/share/vm/runtime/thread.hpp
@@ -101,6 +101,7 @@ class WorkerThread;
class Thread: public ThreadShadow {
friend class VMStructs;
+ friend class JVMCIVMStructs;
private:
#ifndef USE_LIBRARY_BASED_TLS_ONLY
@@ -783,6 +784,7 @@ typedef void (*ThreadFunction)(JavaThread*, TRAPS);
class JavaThread: public Thread {
friend class VMStructs;
+ friend class JVMCIVMStructs;
friend class WhiteBox;
private:
JavaThread* _next; // The next thread in the Threads list
diff --git a/hotspot/src/share/vm/runtime/vmStructs.cpp b/hotspot/src/share/vm/runtime/vmStructs.cpp
index 5be0aaaba95..e20dbbbb00a 100644
--- a/hotspot/src/share/vm/runtime/vmStructs.cpp
+++ b/hotspot/src/share/vm/runtime/vmStructs.cpp
@@ -850,6 +850,7 @@ typedef CompactHashtable SymbolCompactHashTable;
static_field(StubRoutines, _aescrypt_decryptBlock, address) \
static_field(StubRoutines, _cipherBlockChaining_encryptAESCrypt, address) \
static_field(StubRoutines, _cipherBlockChaining_decryptAESCrypt, address) \
+ static_field(StubRoutines, _counterMode_AESCrypt, address) \
static_field(StubRoutines, _ghash_processBlocks, address) \
static_field(StubRoutines, _updateBytesCRC32, address) \
static_field(StubRoutines, _crc_table_adr, address) \
@@ -860,6 +861,8 @@ typedef CompactHashtable SymbolCompactHashTable;
static_field(StubRoutines, _mulAdd, address) \
static_field(StubRoutines, _dexp, address) \
static_field(StubRoutines, _dlog, address) \
+ static_field(StubRoutines, _dpow, address) \
+ static_field(StubRoutines, _vectorizedMismatch, address) \
static_field(StubRoutines, _jbyte_arraycopy, address) \
static_field(StubRoutines, _jshort_arraycopy, address) \
static_field(StubRoutines, _jint_arraycopy, address) \
@@ -1308,6 +1311,8 @@ typedef CompactHashtable SymbolCompactHashTable;
\
static_field(Abstract_VM_Version, _s_vm_release, const char*) \
static_field(Abstract_VM_Version, _s_internal_vm_info_string, const char*) \
+ static_field(Abstract_VM_Version, _features, uint64_t) \
+ static_field(Abstract_VM_Version, _features_string, const char*) \
static_field(Abstract_VM_Version, _vm_major_version, int) \
static_field(Abstract_VM_Version, _vm_minor_version, int) \
static_field(Abstract_VM_Version, _vm_security_version, int) \
@@ -2057,7 +2062,6 @@ typedef CompactHashtable SymbolCompactHashTable;
declare_c2_type(AtanDNode, Node) \
declare_c2_type(SqrtDNode, Node) \
declare_c2_type(Log10DNode, Node) \
- declare_c2_type(PowDNode, Node) \
declare_c2_type(ReverseBytesINode, Node) \
declare_c2_type(ReverseBytesLNode, Node) \
declare_c2_type(ReductionNode, Node) \
@@ -2843,104 +2847,6 @@ typedef CompactHashtable SymbolCompactHashTable;
//--------------------------------------------------------------------------------
-// VM_ADDRESSES
-//
-
-#define VM_ADDRESSES(declare_address, declare_preprocessor_address, declare_function) \
- \
- declare_function(SharedRuntime::register_finalizer) \
- declare_function(SharedRuntime::exception_handler_for_return_address) \
- declare_function(SharedRuntime::OSR_migration_end) \
- declare_function(SharedRuntime::dsin) \
- declare_function(SharedRuntime::dcos) \
- declare_function(SharedRuntime::dtan) \
- declare_function(SharedRuntime::dexp) \
- declare_function(SharedRuntime::dlog) \
- declare_function(SharedRuntime::dlog10) \
- declare_function(SharedRuntime::dpow) \
- \
- declare_function(os::dll_load) \
- declare_function(os::dll_lookup) \
- declare_function(os::javaTimeMillis) \
- declare_function(os::javaTimeNanos) \
- \
- declare_function(Deoptimization::fetch_unroll_info) \
- COMPILER2_PRESENT(declare_function(Deoptimization::uncommon_trap)) \
- declare_function(Deoptimization::unpack_frames)
-
-//--------------------------------------------------------------------------------
-// Macros operating on the above lists
-//--------------------------------------------------------------------------------
-
-// This utility macro quotes the passed string
-#define QUOTE(x) #x
-
-//--------------------------------------------------------------------------------
-// VMStructEntry macros
-//
-
-// This macro generates a VMStructEntry line for a nonstatic field
-#define GENERATE_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
- { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 0, offset_of(typeName, fieldName), NULL },
-
-// This macro generates a VMStructEntry line for a static field
-#define GENERATE_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
- { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 1, 0, &typeName::fieldName },
-
-// This macro generates a VMStructEntry line for a static pointer volatile field,
-// e.g.: "static ObjectMonitor * volatile gBlockList;"
-#define GENERATE_STATIC_PTR_VOLATILE_VM_STRUCT_ENTRY(typeName, fieldName, type) \
- { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 1, 0, (void *)&typeName::fieldName },
-
-// This macro generates a VMStructEntry line for an unchecked
-// nonstatic field, in which the size of the type is also specified.
-// The type string is given as NULL, indicating an "opaque" type.
-#define GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, size) \
- { QUOTE(typeName), QUOTE(fieldName), NULL, 0, offset_of(typeName, fieldName), NULL },
-
-// This macro generates a VMStructEntry line for an unchecked
-// static field, in which the size of the type is also specified.
-// The type string is given as NULL, indicating an "opaque" type.
-#define GENERATE_UNCHECKED_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, size) \
- { QUOTE(typeName), QUOTE(fieldName), NULL, 1, 0, (void*) &typeName::fieldName },
-
-// This macro generates the sentinel value indicating the end of the list
-#define GENERATE_VM_STRUCT_LAST_ENTRY() \
- { NULL, NULL, NULL, 0, 0, NULL }
-
-// This macro checks the type of a VMStructEntry by comparing pointer types
-#define CHECK_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
- {typeName *dummyObj = NULL; type* dummy = &dummyObj->fieldName; \
- assert(offset_of(typeName, fieldName) < sizeof(typeName), "Illegal nonstatic struct entry, field offset too large"); }
-
-// This macro checks the type of a volatile VMStructEntry by comparing pointer types
-#define CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
- {typedef type dummyvtype; typeName *dummyObj = NULL; volatile dummyvtype* dummy = &dummyObj->fieldName; }
-
-// This macro checks the type of a static VMStructEntry by comparing pointer types
-#define CHECK_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
- {type* dummy = &typeName::fieldName; }
-
-// This macro checks the type of a static pointer volatile VMStructEntry by comparing pointer types,
-// e.g.: "static ObjectMonitor * volatile gBlockList;"
-#define CHECK_STATIC_PTR_VOLATILE_VM_STRUCT_ENTRY(typeName, fieldName, type) \
- {type volatile * dummy = &typeName::fieldName; }
-
-// This macro ensures the type of a field and its containing type are
-// present in the type table. The assertion string is shorter than
-// preferable because (incredibly) of a bug in Solstice NFS client
-// which seems to prevent very long lines from compiling. This assertion
-// means that an entry in VMStructs::localHotSpotVMStructs[] was not
-// found in VMStructs::localHotSpotVMTypes[].
-#define ENSURE_FIELD_TYPE_PRESENT(typeName, fieldName, type) \
- { assert(findType(QUOTE(typeName)) != 0, "type \"" QUOTE(typeName) "\" not found in type table"); \
- assert(findType(QUOTE(type)) != 0, "type \"" QUOTE(type) "\" not found in type table"); }
-
-// This is a no-op macro for unchecked fields
-#define CHECK_NO_OP(a, b, c)
-
-//
-// Build-specific macros:
//
// Generate and check a nonstatic field in non-product builds
@@ -2996,35 +2902,7 @@ typedef CompactHashtable SymbolCompactHashTable;
#endif /* COMPILER2 */
//--------------------------------------------------------------------------------
-// VMTypeEntry macros
-//
-
-#define GENERATE_VM_TYPE_ENTRY(type, superclass) \
- { QUOTE(type), QUOTE(superclass), 0, 0, 0, sizeof(type) },
-
-#define GENERATE_TOPLEVEL_VM_TYPE_ENTRY(type) \
- { QUOTE(type), NULL, 0, 0, 0, sizeof(type) },
-
-#define GENERATE_OOP_VM_TYPE_ENTRY(type) \
- { QUOTE(type), NULL, 1, 0, 0, sizeof(type) },
-
-#define GENERATE_INTEGER_VM_TYPE_ENTRY(type) \
- { QUOTE(type), NULL, 0, 1, 0, sizeof(type) },
-
-#define GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY(type) \
- { QUOTE(type), NULL, 0, 1, 1, sizeof(type) },
-
-#define GENERATE_VM_TYPE_LAST_ENTRY() \
- { NULL, NULL, 0, 0, 0, 0 }
-
-#define CHECK_VM_TYPE_ENTRY(type, superclass) \
- { type* dummyObj = NULL; superclass* dummySuperObj = dummyObj; }
-
-#define CHECK_VM_TYPE_NO_OP(a)
-#define CHECK_SINGLE_ARG_VM_TYPE_NO_OP(a)
-
-//
-// Build-specific macros:
+// VMTypeEntry build-specific macros
//
#ifdef COMPILER1
@@ -3049,23 +2927,9 @@ typedef CompactHashtable SymbolCompactHashTable;
//--------------------------------------------------------------------------------
-// VMIntConstantEntry macros
+// VMIntConstantEntry build-specific macros
//
-#define GENERATE_VM_INT_CONSTANT_ENTRY(name) \
- { QUOTE(name), (int32_t) name },
-
-#define GENERATE_VM_INT_CONSTANT_WITH_VALUE_ENTRY(name, value) \
- { (name), (int32_t)(value) },
-
-#define GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value) \
- { name, (int32_t) value },
-
-// This macro generates the sentinel value indicating the end of the list
-#define GENERATE_VM_INT_CONSTANT_LAST_ENTRY() \
- { NULL, 0 }
-
-
// Generate an int constant for a C1 build
#ifdef COMPILER1
# define GENERATE_C1_VM_INT_CONSTANT_ENTRY(name) GENERATE_VM_INT_CONSTANT_ENTRY(name)
@@ -3082,20 +2946,11 @@ typedef CompactHashtable SymbolCompactHashTable;
# define GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value)
#endif /* COMPILER1 */
+
//--------------------------------------------------------------------------------
-// VMLongConstantEntry macros
+// VMLongConstantEntry build-specific macros
//
-#define GENERATE_VM_LONG_CONSTANT_ENTRY(name) \
- { QUOTE(name), name },
-
-#define GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value) \
- { name, value },
-
-// This macro generates the sentinel value indicating the end of the list
-#define GENERATE_VM_LONG_CONSTANT_LAST_ENTRY() \
- { NULL, 0 }
-
// Generate a long constant for a C1 build
#ifdef COMPILER1
# define GENERATE_C1_VM_LONG_CONSTANT_ENTRY(name) GENERATE_VM_LONG_CONSTANT_ENTRY(name)
@@ -3112,22 +2967,6 @@ typedef CompactHashtable SymbolCompactHashTable;
# define GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value)
#endif /* COMPILER1 */
-//--------------------------------------------------------------------------------
-// VMAddressEntry macros
-//
-
-#define GENERATE_VM_ADDRESS_ENTRY(name) \
- { QUOTE(name), (void*) (name) },
-
-#define GENERATE_PREPROCESSOR_VM_ADDRESS_ENTRY(name, value) \
- { name, (void*) (value) },
-
-#define GENERATE_VM_FUNCTION_ENTRY(name) \
- { QUOTE(name), CAST_FROM_FN_PTR(void*, &(name)) },
-
-// This macro generates the sentinel value indicating the end of the list
-#define GENERATE_VM_ADDRESS_LAST_ENTRY() \
- { NULL, NULL }
//
// Instantiation of VMStructEntries, VMTypeEntries and VMIntConstantEntries
@@ -3148,11 +2987,6 @@ VMStructEntry VMStructs::localHotSpotVMStructs[] = {
GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY,
GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY)
-#if INCLUDE_JVMCI
- VM_STRUCTS_JVMCI(GENERATE_NONSTATIC_VM_STRUCT_ENTRY,
- GENERATE_STATIC_VM_STRUCT_ENTRY)
-#endif
-
#if INCLUDE_ALL_GCS
VM_STRUCTS_PARALLELGC(GENERATE_NONSTATIC_VM_STRUCT_ENTRY,
GENERATE_STATIC_VM_STRUCT_ENTRY)
@@ -3214,11 +3048,6 @@ VMTypeEntry VMStructs::localHotSpotVMTypes[] = {
GENERATE_C2_VM_TYPE_ENTRY,
GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY)
-#if INCLUDE_JVMCI
- VM_TYPES_JVMCI(GENERATE_VM_TYPE_ENTRY,
- GENERATE_TOPLEVEL_VM_TYPE_ENTRY)
-#endif
-
#if INCLUDE_ALL_GCS
VM_TYPES_PARALLELGC(GENERATE_VM_TYPE_ENTRY,
GENERATE_TOPLEVEL_VM_TYPE_ENTRY)
@@ -3278,12 +3107,6 @@ VMIntConstantEntry VMStructs::localHotSpotVMIntConstants[] = {
GENERATE_C2_VM_INT_CONSTANT_ENTRY,
GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY)
-#if INCLUDE_JVMCI
- VM_INT_CONSTANTS_JVMCI(GENERATE_VM_INT_CONSTANT_ENTRY,
- GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY)
-
-#endif
-
#if INCLUDE_ALL_GCS
VM_INT_CONSTANTS_CMS(GENERATE_VM_INT_CONSTANT_ENTRY)
@@ -3347,25 +3170,6 @@ VMLongConstantEntry VMStructs::localHotSpotVMLongConstants[] = {
GENERATE_VM_LONG_CONSTANT_LAST_ENTRY()
};
-VMAddressEntry VMStructs::localHotSpotVMAddresses[] = {
-
- VM_ADDRESSES(GENERATE_VM_ADDRESS_ENTRY,
- GENERATE_PREPROCESSOR_VM_ADDRESS_ENTRY,
- GENERATE_VM_FUNCTION_ENTRY)
-
- VM_ADDRESSES_OS(GENERATE_VM_ADDRESS_ENTRY,
- GENERATE_PREPROCESSOR_VM_ADDRESS_ENTRY,
- GENERATE_VM_FUNCTION_ENTRY)
-
-#if INCLUDE_JVMCI
- VM_ADDRESSES_JVMCI(GENERATE_VM_ADDRESS_ENTRY,
- GENERATE_PREPROCESSOR_VM_ADDRESS_ENTRY,
- GENERATE_VM_FUNCTION_ENTRY)
-#endif
-
- GENERATE_VM_ADDRESS_LAST_ENTRY()
-};
-
// This is used both to check the types of referenced fields and, in
// debug builds, to ensure that all of the field types are present.
void
@@ -3574,11 +3378,6 @@ JNIEXPORT VMLongConstantEntry* gHotSpotVMLongConstants = VMStructs::localHotSpot
JNIEXPORT uint64_t gHotSpotVMLongConstantEntryNameOffset = offset_of(VMLongConstantEntry, name);
JNIEXPORT uint64_t gHotSpotVMLongConstantEntryValueOffset = offset_of(VMLongConstantEntry, value);
JNIEXPORT uint64_t gHotSpotVMLongConstantEntryArrayStride = STRIDE(gHotSpotVMLongConstants);
-
-JNIEXPORT VMAddressEntry* gHotSpotVMAddresses = VMStructs::localHotSpotVMAddresses;
-JNIEXPORT uint64_t gHotSpotVMAddressEntryNameOffset = offset_of(VMAddressEntry, name);
-JNIEXPORT uint64_t gHotSpotVMAddressEntryValueOffset = offset_of(VMAddressEntry, value);
-JNIEXPORT uint64_t gHotSpotVMAddressEntryArrayStride = STRIDE(gHotSpotVMAddresses);
}
#ifdef ASSERT
@@ -3686,11 +3485,6 @@ void VMStructs::test() {
&long_last_entry,
sizeof(VMLongConstantEntry)) == 0, "Incorrect last entry in localHotSpotVMLongConstants");
- static VMAddressEntry address_last_entry = GENERATE_VM_ADDRESS_LAST_ENTRY();
- assert(memcmp(&localHotSpotVMAddresses[sizeof(localHotSpotVMAddresses) / sizeof(VMAddressEntry) - 1],
- &address_last_entry,
- sizeof(VMAddressEntry)) == 0, "Incorrect last entry in localHotSpotVMAddresses");
-
// Check for duplicate entries in type array
for (int i = 0; localHotSpotVMTypes[i].typeName != NULL; i++) {
diff --git a/hotspot/src/share/vm/runtime/vmStructs.hpp b/hotspot/src/share/vm/runtime/vmStructs.hpp
index 369ff9e9426..4f9f31dcd3e 100644
--- a/hotspot/src/share/vm/runtime/vmStructs.hpp
+++ b/hotspot/src/share/vm/runtime/vmStructs.hpp
@@ -143,4 +143,151 @@ private:
static int findType(const char* typeName);
};
+// This utility macro quotes the passed string
+#define QUOTE(x) #x
+
+//--------------------------------------------------------------------------------
+// VMStructEntry macros
+//
+
+// This macro generates a VMStructEntry line for a nonstatic field
+#define GENERATE_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
+ { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 0, offset_of(typeName, fieldName), NULL },
+
+// This macro generates a VMStructEntry line for a static field
+#define GENERATE_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
+ { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 1, 0, &typeName::fieldName },
+
+// This macro generates a VMStructEntry line for a static pointer volatile field,
+// e.g.: "static ObjectMonitor * volatile gBlockList;"
+#define GENERATE_STATIC_PTR_VOLATILE_VM_STRUCT_ENTRY(typeName, fieldName, type) \
+ { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 1, 0, (void *)&typeName::fieldName },
+
+// This macro generates a VMStructEntry line for an unchecked
+// nonstatic field, in which the size of the type is also specified.
+// The type string is given as NULL, indicating an "opaque" type.
+#define GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, size) \
+ { QUOTE(typeName), QUOTE(fieldName), NULL, 0, offset_of(typeName, fieldName), NULL },
+
+// This macro generates a VMStructEntry line for an unchecked
+// static field, in which the size of the type is also specified.
+// The type string is given as NULL, indicating an "opaque" type.
+#define GENERATE_UNCHECKED_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, size) \
+ { QUOTE(typeName), QUOTE(fieldName), NULL, 1, 0, (void*) &typeName::fieldName },
+
+// This macro generates the sentinel value indicating the end of the list
+#define GENERATE_VM_STRUCT_LAST_ENTRY() \
+ { NULL, NULL, NULL, 0, 0, NULL }
+
+// This macro checks the type of a VMStructEntry by comparing pointer types
+#define CHECK_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
+ {typeName *dummyObj = NULL; type* dummy = &dummyObj->fieldName; \
+ assert(offset_of(typeName, fieldName) < sizeof(typeName), "Illegal nonstatic struct entry, field offset too large"); }
+
+// This macro checks the type of a volatile VMStructEntry by comparing pointer types
+#define CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
+ {typedef type dummyvtype; typeName *dummyObj = NULL; volatile dummyvtype* dummy = &dummyObj->fieldName; }
+
+// This macro checks the type of a static VMStructEntry by comparing pointer types
+#define CHECK_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
+ {type* dummy = &typeName::fieldName; }
+
+// This macro checks the type of a static pointer volatile VMStructEntry by comparing pointer types,
+// e.g.: "static ObjectMonitor * volatile gBlockList;"
+#define CHECK_STATIC_PTR_VOLATILE_VM_STRUCT_ENTRY(typeName, fieldName, type) \
+ {type volatile * dummy = &typeName::fieldName; }
+
+// This macro ensures the type of a field and its containing type are
+// present in the type table. The assertion string is shorter than
+// preferable because (incredibly) of a bug in Solstice NFS client
+// which seems to prevent very long lines from compiling. This assertion
+// means that an entry in VMStructs::localHotSpotVMStructs[] was not
+// found in VMStructs::localHotSpotVMTypes[].
+#define ENSURE_FIELD_TYPE_PRESENT(typeName, fieldName, type) \
+ { assert(findType(QUOTE(typeName)) != 0, "type \"" QUOTE(typeName) "\" not found in type table"); \
+ assert(findType(QUOTE(type)) != 0, "type \"" QUOTE(type) "\" not found in type table"); }
+
+// This is a no-op macro for unchecked fields
+#define CHECK_NO_OP(a, b, c)
+
+
+//--------------------------------------------------------------------------------
+// VMTypeEntry macros
+//
+
+#define GENERATE_VM_TYPE_ENTRY(type, superclass) \
+ { QUOTE(type), QUOTE(superclass), 0, 0, 0, sizeof(type) },
+
+#define GENERATE_TOPLEVEL_VM_TYPE_ENTRY(type) \
+ { QUOTE(type), NULL, 0, 0, 0, sizeof(type) },
+
+#define GENERATE_OOP_VM_TYPE_ENTRY(type) \
+ { QUOTE(type), NULL, 1, 0, 0, sizeof(type) },
+
+#define GENERATE_INTEGER_VM_TYPE_ENTRY(type) \
+ { QUOTE(type), NULL, 0, 1, 0, sizeof(type) },
+
+#define GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY(type) \
+ { QUOTE(type), NULL, 0, 1, 1, sizeof(type) },
+
+#define GENERATE_VM_TYPE_LAST_ENTRY() \
+ { NULL, NULL, 0, 0, 0, 0 }
+
+#define CHECK_VM_TYPE_ENTRY(type, superclass) \
+ { type* dummyObj = NULL; superclass* dummySuperObj = dummyObj; }
+
+#define CHECK_VM_TYPE_NO_OP(a)
+#define CHECK_SINGLE_ARG_VM_TYPE_NO_OP(a)
+
+
+//--------------------------------------------------------------------------------
+// VMIntConstantEntry macros
+//
+
+#define GENERATE_VM_INT_CONSTANT_ENTRY(name) \
+ { QUOTE(name), (int32_t) name },
+
+#define GENERATE_VM_INT_CONSTANT_WITH_VALUE_ENTRY(name, value) \
+ { (name), (int32_t)(value) },
+
+#define GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value) \
+ { name, (int32_t) value },
+
+// This macro generates the sentinel value indicating the end of the list
+#define GENERATE_VM_INT_CONSTANT_LAST_ENTRY() \
+ { NULL, 0 }
+
+
+//--------------------------------------------------------------------------------
+// VMLongConstantEntry macros
+//
+
+#define GENERATE_VM_LONG_CONSTANT_ENTRY(name) \
+ { QUOTE(name), name },
+
+#define GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value) \
+ { name, value },
+
+// This macro generates the sentinel value indicating the end of the list
+#define GENERATE_VM_LONG_CONSTANT_LAST_ENTRY() \
+ { NULL, 0 }
+
+
+//--------------------------------------------------------------------------------
+// VMAddressEntry macros
+//
+
+#define GENERATE_VM_ADDRESS_ENTRY(name) \
+ { QUOTE(name), (void*) (name) },
+
+#define GENERATE_PREPROCESSOR_VM_ADDRESS_ENTRY(name, value) \
+ { name, (void*) (value) },
+
+#define GENERATE_VM_FUNCTION_ENTRY(name) \
+ { QUOTE(name), CAST_FROM_FN_PTR(void*, &(name)) },
+
+// This macro generates the sentinel value indicating the end of the list
+#define GENERATE_VM_ADDRESS_LAST_ENTRY() \
+ { NULL, NULL }
+
#endif // SHARE_VM_RUNTIME_VMSTRUCTS_HPP
diff --git a/hotspot/src/share/vm/runtime/vm_operations.hpp b/hotspot/src/share/vm/runtime/vm_operations.hpp
index 14f837ec1a1..061c8b4c205 100644
--- a/hotspot/src/share/vm/runtime/vm_operations.hpp
+++ b/hotspot/src/share/vm/runtime/vm_operations.hpp
@@ -30,6 +30,7 @@
#include "oops/oop.hpp"
#include "runtime/thread.hpp"
#include "utilities/top.hpp"
+#include "code/codeCache.hpp"
// The following classes are used for operations
// initiated by a Java thread but that must
@@ -44,6 +45,7 @@
template(ThreadDump) \
template(PrintThreads) \
template(FindDeadlocks) \
+ template(ClearICs) \
template(ForceSafepoint) \
template(ForceAsyncSafepoint) \
template(Deoptimize) \
@@ -230,6 +232,13 @@ class VM_ThreadStop: public VM_Operation {
}
};
+class VM_ClearICs: public VM_Operation {
+ public:
+ VM_ClearICs() {}
+ void doit() { CodeCache::clear_inline_caches(); }
+ VMOp_Type type() const { return VMOp_ClearICs; }
+};
+
// dummy vm op, evaluated just to force a safepoint
class VM_ForceSafepoint: public VM_Operation {
public:
diff --git a/hotspot/src/share/vm/runtime/vm_version.cpp b/hotspot/src/share/vm/runtime/vm_version.cpp
index 03c38e18736..e36fce25870 100644
--- a/hotspot/src/share/vm/runtime/vm_version.cpp
+++ b/hotspot/src/share/vm/runtime/vm_version.cpp
@@ -31,6 +31,10 @@
const char* Abstract_VM_Version::_s_vm_release = Abstract_VM_Version::vm_release();
const char* Abstract_VM_Version::_s_internal_vm_info_string = Abstract_VM_Version::internal_vm_info_string();
+
+uint64_t Abstract_VM_Version::_features = 0;
+const char* Abstract_VM_Version::_features_string = "";
+
bool Abstract_VM_Version::_supports_cx8 = false;
bool Abstract_VM_Version::_supports_atomic_getset4 = false;
bool Abstract_VM_Version::_supports_atomic_getset8 = false;
diff --git a/hotspot/src/share/vm/runtime/vm_version.hpp b/hotspot/src/share/vm/runtime/vm_version.hpp
index 4e12c00bba5..ee4b4ec0d64 100644
--- a/hotspot/src/share/vm/runtime/vm_version.hpp
+++ b/hotspot/src/share/vm/runtime/vm_version.hpp
@@ -31,10 +31,17 @@
// VM_Version provides information about the VM.
class Abstract_VM_Version: AllStatic {
- protected:
friend class VMStructs;
+ friend class JVMCIVMStructs;
+
+ protected:
static const char* _s_vm_release;
static const char* _s_internal_vm_info_string;
+
+ // CPU feature flags.
+ static uint64_t _features;
+ static const char* _features_string;
+
// These are set by machine-dependent initializations
static bool _supports_cx8;
static bool _supports_atomic_getset4;
@@ -100,6 +107,14 @@ class Abstract_VM_Version: AllStatic {
static const char* jre_release_version();
static const char* jdk_debug_level();
+ static uint64_t features() {
+ return _features;
+ }
+
+ static const char* features_string() {
+ return _features_string;
+ }
+
// does HW support an 8-byte compare-exchange operation?
static bool supports_cx8() {
#ifdef SUPPORTS_NATIVE_CX8
diff --git a/hotspot/src/share/vm/utilities/array.hpp b/hotspot/src/share/vm/utilities/array.hpp
index 8df72304ef0..f759fe1c03f 100644
--- a/hotspot/src/share/vm/utilities/array.hpp
+++ b/hotspot/src/share/vm/utilities/array.hpp
@@ -304,6 +304,7 @@ template
class Array: public MetaspaceObj {
friend class MetadataFactory;
friend class VMStructs;
+ friend class JVMCIVMStructs;
friend class MethodHandleCompiler; // special case
friend class WhiteBox;
protected:
diff --git a/hotspot/src/share/vm/utilities/exceptions.hpp b/hotspot/src/share/vm/utilities/exceptions.hpp
index 02d9110ef74..5983f5e32f9 100644
--- a/hotspot/src/share/vm/utilities/exceptions.hpp
+++ b/hotspot/src/share/vm/utilities/exceptions.hpp
@@ -59,6 +59,7 @@ class JavaCallArguments;
class ThreadShadow: public CHeapObj {
friend class VMStructs;
+ friend class JVMCIVMStructs;
protected:
oop _pending_exception; // Thread has gc actions.
diff --git a/hotspot/src/share/vm/utilities/globalDefinitions.hpp b/hotspot/src/share/vm/utilities/globalDefinitions.hpp
index 103edfa0ca4..53431e8a6b3 100644
--- a/hotspot/src/share/vm/utilities/globalDefinitions.hpp
+++ b/hotspot/src/share/vm/utilities/globalDefinitions.hpp
@@ -1418,6 +1418,32 @@ template static void swap(T& a, T& b) {
#define ARRAY_SIZE(array) (sizeof(array)/sizeof((array)[0]))
+//----------------------------------------------------------------------------------------------------
+// Sum and product which can never overflow: they wrap, just like the
+// Java operations. Note that we don't intend these to be used for
+// general-purpose arithmetic: their purpose is to emulate Java
+// operations.
+
+// The goal of this code to avoid undefined or implementation-defined
+// behaviour. The use of an lvalue to reference cast is explicitly
+// permitted by Lvalues and rvalues [basic.lval]. [Section 3.10 Para
+// 15 in C++03]
+#define JAVA_INTEGER_OP(OP, NAME, TYPE, UNSIGNED_TYPE) \
+inline TYPE NAME (TYPE in1, TYPE in2) { \
+ UNSIGNED_TYPE ures = static_cast(in1); \
+ ures OP ## = static_cast(in2); \
+ return reinterpret_cast(ures); \
+}
+
+JAVA_INTEGER_OP(+, java_add, jint, juint)
+JAVA_INTEGER_OP(-, java_subtract, jint, juint)
+JAVA_INTEGER_OP(*, java_multiply, jint, juint)
+JAVA_INTEGER_OP(+, java_add, jlong, julong)
+JAVA_INTEGER_OP(-, java_subtract, jlong, julong)
+JAVA_INTEGER_OP(*, java_multiply, jlong, julong)
+
+#undef JAVA_INTEGER_OP
+
// Dereference vptr
// All C++ compilers that we know of have the vtbl pointer in the first
// word. If there are exceptions, this function needs to be made compiler
diff --git a/hotspot/src/share/vm/utilities/json.cpp b/hotspot/src/share/vm/utilities/json.cpp
index e7df3d0de70..2064bb81e7a 100644
--- a/hotspot/src/share/vm/utilities/json.cpp
+++ b/hotspot/src/share/vm/utilities/json.cpp
@@ -750,7 +750,6 @@ bool JSONTest::test() {
JSONTest::test("{ key : 1 }", true);
JSONTest::test("{ key : 1, }", true);
- JSONTest::test("{ key : 1.2 }", true);
JSONTest::test("{ key : true }", true);
JSONTest::test("{ key : true, }", true);
JSONTest::test("{ key : false }", true);
diff --git a/hotspot/test/TEST.groups b/hotspot/test/TEST.groups
index 0ab5b18b6e1..c0b6324416a 100644
--- a/hotspot/test/TEST.groups
+++ b/hotspot/test/TEST.groups
@@ -279,6 +279,7 @@ hotspot_compiler_2 = \
compiler/inlining/ \
compiler/integerArithmetic/ \
compiler/interpreter/ \
+ compiler/jvmci/ \
-compiler/codegen/7184394 \
-compiler/codecache/stress
diff --git a/hotspot/test/compiler/arraycopy/TestArrayCopyOverflowArguments.java b/hotspot/test/compiler/arraycopy/TestArrayCopyOverflowArguments.java
new file mode 100644
index 00000000000..1bfaa35e578
--- /dev/null
+++ b/hotspot/test/compiler/arraycopy/TestArrayCopyOverflowArguments.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2015 SAP SE. 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
+ * @summary Test that overflowed integers passed to arraycopy don't do any harm. This might
+ * be the case on platforms where C-code expects that ints passed to a call
+ * are properly sign extended to 64 bit (e.g., PPC64, s390x). This can fail
+ * if slow_arraycopy_C() is commpiled by the C compiler without any imlicit
+ * casts (as spill stores to the stack that are done with 4-byte instruction).
+ * @run main/othervm -XX:-BackgroundCompilation -XX:-UseOnStackReplacement TestArrayCopyOverflowArguments
+ *
+ */
+
+public class TestArrayCopyOverflowArguments {
+
+ // Without volatile the overflowing computation was moved up and then
+ // spilled to the stack. The 32-bit spill store caused proper rounding.
+ static volatile int mod = Integer.MAX_VALUE;
+
+ public static int[] m1(Object src) {
+ if (src == null) return null;
+ int[] dest = new int[10];
+ try {
+ // PPC C calling conventions require that ints are properly expanded
+ // to longs when passed to a function.
+ int pos = 8 + mod + mod; // = 0x1_0000_0006.
+ int start = 2 + mod + mod; // = 0x1_0000_0000.
+ int len = 12 + mod + mod; // = 0x1_0000_0010.
+ // This is supposed to call SharedRuntime::slow_arraycopy_C().
+ System.arraycopy(src, pos, dest, 0, 10);
+ } catch (ArrayStoreException npe) {
+ }
+ return dest;
+ }
+
+ static public void main(String[] args) throws Exception {
+ int[] src = new int[20];
+
+ for (int i = 0; i < 20; ++i) {
+ src[i] = i * (i-1);
+ }
+
+ for (int i = 0; i < 20000; i++) {
+ m1(src);
+ }
+ }
+}
+
diff --git a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionDescriptors.java b/hotspot/test/compiler/calls/common/CallInterface.java
similarity index 69%
rename from hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionDescriptors.java
rename to hotspot/test/compiler/calls/common/CallInterface.java
index a2aef68e95e..84b7b075150 100644
--- a/hotspot/src/jdk.vm.ci/share/classes/jdk.vm.ci.options/src/jdk/vm/ci/options/OptionDescriptors.java
+++ b/hotspot/test/compiler/calls/common/CallInterface.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * 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
@@ -20,15 +20,16 @@
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
-package jdk.vm.ci.options;
+
+package compiler.calls.common;
/**
- * An interface to a set of {@link OptionDescriptor}s.
+ * A test interface used for InvokeInterface
*/
-public interface OptionDescriptors extends Iterable {
- /**
- * Gets the {@link OptionDescriptor} matching a given option name or {@code null} if this option
- * descriptor set doesn't contain a matching option.
- */
- OptionDescriptor get(String value);
+public interface CallInterface {
+ public boolean callee(int param1, long param2, float param3, double param4,
+ String param5);
+
+ public boolean calleeNative(int param1, long param2, float param3,
+ double param4, String param5);
}
diff --git a/hotspot/test/compiler/calls/common/CallsBase.java b/hotspot/test/compiler/calls/common/CallsBase.java
new file mode 100644
index 00000000000..f6a9ad93f23
--- /dev/null
+++ b/hotspot/test/compiler/calls/common/CallsBase.java
@@ -0,0 +1,217 @@
+/*
+ * 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.calls.common;
+
+import compiler.testlibrary.CompilerUtils;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import jdk.test.lib.Asserts;
+import sun.hotspot.WhiteBox;
+
+/**
+ * A common class for Invoke* classes
+ */
+public abstract class CallsBase {
+ public static final String CALL_ERR_MSG = "Call insuccessfull";
+ protected final Method calleeMethod;
+ protected final Method callerMethod;
+ protected final WhiteBox wb = WhiteBox.getWhiteBox();
+ protected int compileCallee = -1;
+ protected int compileCaller = -1;
+ protected boolean nativeCallee = false;
+ protected boolean nativeCaller = false;
+ protected boolean calleeVisited = false;
+ protected boolean checkCallerCompilationLevel;
+ protected boolean checkCalleeCompilationLevel;
+ protected int expectedCallerCompilationLevel;
+ protected int expectedCalleeCompilationLevel;
+
+ protected CallsBase() {
+ try {
+ callerMethod = getClass().getDeclaredMethod("caller");
+ calleeMethod = getClass().getDeclaredMethod("callee",
+ getCalleeParametersTypes());
+ wb.testSetDontInlineMethod(callerMethod, /* dontinline= */ true);
+ wb.testSetDontInlineMethod(calleeMethod, /* dontinline= */ true);
+ } catch (NoSuchMethodException e) {
+ throw new Error("TEST BUG: can't find test method", e);
+ }
+ }
+
+ /**
+ * Provides callee parameters types to search method
+ * @return array of types
+ */
+ protected Class[] getCalleeParametersTypes() {
+ return new Class[] {int.class, long.class, float.class,
+ double.class, String.class};
+ }
+
+ /**
+ * Loads native library(libCallsNative.so)
+ */
+ protected static void loadNativeLibrary() {
+ System.loadLibrary("CallsNative");
+ }
+
+ /**
+ * Checks if requested compilation levels are inside of current vm capabilities
+ * @return true if vm is capable of requested compilation levels
+ */
+ protected final boolean compilationLevelsSupported() {
+ int[] compLevels = CompilerUtils.getAvailableCompilationLevels();
+ boolean callerCompLevelSupported = compileCaller > 0
+ && Arrays.stream(compLevels)
+ .filter(elem -> elem == compileCaller)
+ .findAny()
+ .isPresent();
+ boolean calleeCompLevelSupported = compileCallee > 0
+ && Arrays.stream(compLevels)
+ .filter(elem -> elem == compileCallee)
+ .findAny()
+ .isPresent();
+ return callerCompLevelSupported && calleeCompLevelSupported;
+ }
+
+ /**
+ * Parse test arguments
+ * @param args test arguments
+ */
+ protected final void parseArgs(String args[]) {
+ for (int i = 0; i < args.length; i++) {
+ switch (args[i]) {
+ case "-nativeCallee":
+ nativeCallee = true;
+ break;
+ case "-nativeCaller":
+ nativeCaller = true;
+ break;
+ case "-compileCallee":
+ compileCallee = Integer.parseInt(args[++i]);
+ break;
+ case "-compileCaller":
+ compileCaller = Integer.parseInt(args[++i]);
+ break;
+ case "-checkCallerCompileLevel":
+ checkCallerCompilationLevel = true;
+ expectedCallerCompilationLevel = Integer.parseInt(args[++i]);
+ break;
+ case "-checkCalleeCompileLevel":
+ checkCalleeCompilationLevel = true;
+ expectedCalleeCompilationLevel = Integer.parseInt(args[++i]);
+ break;
+ default:
+ throw new Error("Can't parse test parameter:" + args[i]);
+ }
+ }
+ }
+
+ /**
+ * Run basic logic of a test by doing compile
+ * action(if needed). An arguments can be -compileCallee
+ * $calleeCompilationLevel and/or -compileCaller $callerCompilationLevel
+ * and/or -nativeCaller and/or -nativeCallee to indicate that native methods
+ * for caller/callee should be used
+ * @param args test args
+ */
+ protected final void runTest(String args[]) {
+ parseArgs(args);
+ if (compilationLevelsSupported()) {
+ if (nativeCaller || nativeCallee) {
+ CallsBase.loadNativeLibrary();
+ }
+ Object lock = getLockObject();
+ Asserts.assertNotNull(lock, "Lock object is null");
+ /* a following lock is needed in case several instances of this
+ test are launched in same vm */
+ synchronized (lock) {
+ if (compileCaller > 0 || compileCallee > 0) {
+ caller(); // call once to have everything loaded
+ calleeVisited = false; // reset state
+ }
+ // compile with requested level if needed
+ if (compileCallee > 0) {
+ compileMethod(calleeMethod, compileCallee);
+ }
+ if (checkCalleeCompilationLevel) {
+ Asserts.assertEQ(expectedCalleeCompilationLevel,
+ wb.getMethodCompilationLevel(calleeMethod),
+ "Unexpected callee compilation level");
+ }
+ if (compileCaller > 0) {
+ compileMethod(callerMethod, compileCaller);
+ }
+ if (checkCallerCompilationLevel) {
+ Asserts.assertEQ(expectedCallerCompilationLevel,
+ wb.getMethodCompilationLevel(callerMethod),
+ "Unexpected caller compilation level");
+ }
+ // do calling work
+ if (nativeCaller) {
+ callerNative();
+ } else {
+ caller();
+ }
+ }
+ } else {
+ System.out.println("WARNING: Requested compilation levels are "
+ + "out of current vm capabilities. Skipping.");
+ }
+ }
+
+ /**
+ * A method to compile another method, searching it by name in current class
+ * @param method a method to compile
+ * @param compLevel a compilation level
+ */
+ protected final void compileMethod(Method method, int compLevel) {
+ wb.deoptimizeMethod(method);
+ Asserts.assertTrue(wb.isMethodCompilable(method, compLevel));
+ wb.enqueueMethodForCompilation(method, compLevel);
+ }
+
+ /*
+ * @return Object to lock on during execution
+ */
+
+ protected abstract Object getLockObject();
+
+ protected abstract void caller();
+
+ protected abstract void callerNative();
+
+ /**
+ * A method checking values. Should be used to verify if all parameters are
+ * passed as expected. Parameter N should have a value indicating number "N"
+ * in respective type representation.
+ */
+ public static void checkValues(int param1, long param2, float param3,
+ double param4, String param5) {
+ Asserts.assertEQ(param1, 1);
+ Asserts.assertEQ(param2, 2L);
+ Asserts.assertEQ(param3, 3.0f);
+ Asserts.assertEQ(param4, 4.0d);
+ Asserts.assertEQ(param5, "5");
+ }
+}
diff --git a/hotspot/test/compiler/calls/common/InvokeDynamic.java b/hotspot/test/compiler/calls/common/InvokeDynamic.java
new file mode 100644
index 00000000000..018a2992e80
--- /dev/null
+++ b/hotspot/test/compiler/calls/common/InvokeDynamic.java
@@ -0,0 +1,99 @@
+/*
+ * 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.calls.common;
+
+import java.lang.invoke.CallSite;
+import java.lang.invoke.ConstantCallSite;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+
+/**
+ * A test class checking InvokeDynamic instruction.
+ * This is not quite "ready-to-use" class, since javac can't generate indy
+ * directly(only as part of lambda init) so, this class bytecode should be
+ * patched with method "caller" which uses indy. Other methods can be written in
+ * java for easier support and readability.
+ */
+
+public class InvokeDynamic extends CallsBase {
+ private static final Object LOCK = new Object();
+
+ public static void main(String args[]) {
+ new InvokeDynamic().runTest(args);
+ }
+
+ /**
+ * Caller method to call "callee" method. Must be overwritten with InvokeDynamicPatcher
+ */
+ @Override
+ public void caller() {
+ }
+
+ /**
+ * A bootstrap method for invokedynamic
+ * @param lookup a lookup object
+ * @param methodName methodName
+ * @param type method type
+ * @return CallSite for method
+ */
+ public static CallSite bootstrapMethod(MethodHandles.Lookup lookup,
+ String methodName, MethodType type) throws IllegalAccessException,
+ NoSuchMethodException {
+ MethodType mtype = MethodType.methodType(boolean.class,
+ new Class[]{int.class, long.class, float.class,
+ double.class, String.class});
+ return new ConstantCallSite(lookup.findVirtual(lookup.lookupClass(),
+ methodName, mtype));
+ }
+
+ /**
+ * A callee method, assumed to be called by "caller"
+ */
+ public boolean callee(int param1, long param2, float param3, double param4,
+ String param5) {
+ calleeVisited = true;
+ CallsBase.checkValues(param1, param2, param3, param4, param5);
+ return true;
+ }
+
+ /**
+ * A native callee method, assumed to be called by "caller"
+ */
+ public native boolean calleeNative(int param1, long param2, float param3,
+ double param4, String param5);
+
+ /**
+ * Returns object to lock execution on
+ * @return lock object
+ */
+ @Override
+ protected Object getLockObject() {
+ return LOCK;
+ }
+
+ @Override
+ protected void callerNative() {
+ throw new Error("No native call for invokedynamic");
+ }
+}
diff --git a/hotspot/test/compiler/calls/common/InvokeDynamicPatcher.java b/hotspot/test/compiler/calls/common/InvokeDynamicPatcher.java
new file mode 100644
index 00000000000..644f0a21b6e
--- /dev/null
+++ b/hotspot/test/compiler/calls/common/InvokeDynamicPatcher.java
@@ -0,0 +1,171 @@
+/*
+ * 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.calls.common;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.lang.invoke.CallSite;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import jdk.internal.org.objectweb.asm.ClassReader;
+import jdk.internal.org.objectweb.asm.ClassVisitor;
+import jdk.internal.org.objectweb.asm.ClassWriter;
+import jdk.internal.org.objectweb.asm.Handle;
+import jdk.internal.org.objectweb.asm.Label;
+import jdk.internal.org.objectweb.asm.MethodVisitor;
+import jdk.internal.org.objectweb.asm.Opcodes;
+
+/**
+ * A class which patch InvokeDynamic class bytecode with invokydynamic
+ instruction, rewriting "caller" method to call "callee" method using
+ invokedynamic
+ */
+public class InvokeDynamicPatcher extends ClassVisitor {
+
+ private static final String CLASS = InvokeDynamic.class.getName()
+ .replace('.', '/');
+ private static final String CALLER_METHOD_NAME = "caller";
+ private static final String CALLEE_METHOD_NAME = "callee";
+ private static final String NATIVE_CALLEE_METHOD_NAME = "calleeNative";
+ private static final String BOOTSTRAP_METHOD_NAME = "bootstrapMethod";
+ private static final String CALL_NATIVE_FIELD = "nativeCallee";
+ private static final String CALL_NATIVE_FIELD_DESC = "Z";
+ private static final String CALLEE_METHOD_DESC
+ = "(L" + CLASS + ";IJFDLjava/lang/String;)Z";
+ private static final String ASSERTTRUE_METHOD_DESC
+ = "(ZLjava/lang/String;)V";
+ private static final String ASSERTS_CLASS = "jdk/test/lib/Asserts";
+ private static final String ASSERTTRUE_METHOD_NAME = "assertTrue";
+
+ public static void main(String args[]) {
+ ClassReader cr;
+ Path filePath;
+ try {
+ filePath = Paths.get(InvokeDynamic.class.getProtectionDomain().getCodeSource()
+ .getLocation().toURI()).resolve(CLASS + ".class");
+ } catch (URISyntaxException ex) {
+ throw new Error("TESTBUG: Can't get code source" + ex, ex);
+ }
+ try (FileInputStream fis = new FileInputStream(filePath.toFile())) {
+ cr = new ClassReader(fis);
+ } catch (IOException e) {
+ throw new Error("Error reading file", e);
+ }
+ ClassWriter cw = new ClassWriter(cr,
+ ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+ cr.accept(new InvokeDynamicPatcher(Opcodes.ASM5, cw), 0);
+ try {
+ Files.write(filePath, cw.toByteArray(),
+ StandardOpenOption.WRITE);
+ } catch (IOException e) {
+ throw new Error(e);
+ }
+ }
+
+ public InvokeDynamicPatcher(int api, ClassWriter cw) {
+ super(api, cw);
+ }
+
+ @Override
+ public MethodVisitor visitMethod(final int access, final String name,
+ final String desc, final String signature,
+ final String[] exceptions) {
+ /* a code generate looks like
+ * 0: aload_0
+ * 1: ldc #125 // int 1
+ * 3: ldc2_w #126 // long 2l
+ * 6: ldc #128 // float 3.0f
+ * 8: ldc2_w #129 // double 4.0d
+ * 11: ldc #132 // String 5
+ * 13: aload_0
+ * 14: getfield #135 // Field nativeCallee:Z
+ * 17: ifeq 28
+ * 20: invokedynamic #181, 0 // InvokeDynamic #1:calleeNative:(Lcompiler/calls/common/InvokeDynamic;IJFDLjava/lang/String;)Z
+ * 25: goto 33
+ * 28: invokedynamic #183, 0 // InvokeDynamic #1:callee:(Lcompiler/calls/common/InvokeDynamic;IJFDLjava/lang/String;)Z
+ * 33: ldc #185 // String Call insuccessfull
+ * 35: invokestatic #191 // Method jdk/test/lib/Asserts.assertTrue:(ZLjava/lang/String;)V
+ * 38: return
+ *
+ * or, using java-like pseudo-code
+ * if (this.nativeCallee == false) {
+ * invokedynamic-call-return-value = invokedynamic-of-callee
+ * } else {
+ * invokedynamic-call-return-value = invokedynamic-of-nativeCallee
+ * }
+ * Asserts.assertTrue(invokedynamic-call-return-value, error-message);
+ * return;
+ */
+ if (name.equals(CALLER_METHOD_NAME)) {
+ MethodVisitor mv = cv.visitMethod(access, name, desc,
+ signature, exceptions);
+ Label nonNativeLabel = new Label();
+ Label checkLabel = new Label();
+ MethodType mtype = MethodType.methodType(CallSite.class,
+ MethodHandles.Lookup.class, String.class, MethodType.class);
+ Handle bootstrap = new Handle(Opcodes.H_INVOKESTATIC, CLASS,
+ BOOTSTRAP_METHOD_NAME, mtype.toMethodDescriptorString());
+ mv.visitCode();
+ // push callee parameters onto stack
+ mv.visitVarInsn(Opcodes.ALOAD, 0);//push "this"
+ mv.visitLdcInsn(1);
+ mv.visitLdcInsn(2L);
+ mv.visitLdcInsn(3.0f);
+ mv.visitLdcInsn(4.0d);
+ mv.visitLdcInsn("5");
+ // params loaded. let's decide what method to call
+ mv.visitVarInsn(Opcodes.ALOAD, 0); // push "this"
+ // get nativeCallee field
+ mv.visitFieldInsn(Opcodes.GETFIELD, CLASS, CALL_NATIVE_FIELD,
+ CALL_NATIVE_FIELD_DESC);
+ // if nativeCallee == false goto nonNativeLabel
+ mv.visitJumpInsn(Opcodes.IFEQ, nonNativeLabel);
+ // invokedynamic nativeCalleeMethod using bootstrap method
+ mv.visitInvokeDynamicInsn(NATIVE_CALLEE_METHOD_NAME,
+ CALLEE_METHOD_DESC, bootstrap);
+ // goto checkLabel
+ mv.visitJumpInsn(Opcodes.GOTO, checkLabel);
+ // label: nonNativeLabel
+ mv.visitLabel(nonNativeLabel);
+ // invokedynamic calleeMethod using bootstrap method
+ mv.visitInvokeDynamicInsn(CALLEE_METHOD_NAME, CALLEE_METHOD_DESC,
+ bootstrap);
+ mv.visitLabel(checkLabel);
+ mv.visitLdcInsn(CallsBase.CALL_ERR_MSG);
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, ASSERTS_CLASS,
+ ASSERTTRUE_METHOD_NAME, ASSERTTRUE_METHOD_DESC, false);
+ // label: return
+ mv.visitInsn(Opcodes.RETURN);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+ return null;
+ }
+ return super.visitMethod(access, name, desc, signature, exceptions);
+ }
+}
diff --git a/hotspot/test/compiler/calls/common/InvokeInterface.java b/hotspot/test/compiler/calls/common/InvokeInterface.java
new file mode 100644
index 00000000000..7ae77d5c4ee
--- /dev/null
+++ b/hotspot/test/compiler/calls/common/InvokeInterface.java
@@ -0,0 +1,84 @@
+/*
+ * 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.calls.common;
+
+import jdk.test.lib.Asserts;
+
+/**
+ * A test class checking InvokeInterface instruction
+ */
+public class InvokeInterface extends CallsBase implements CallInterface {
+ private static final Object LOCK = new Object();
+
+ public static void main(String args[]) {
+ new InvokeInterface().runTest(args);
+ }
+
+ /**
+ * A caller method, assumed to called "callee"/"calleeNative"
+ */
+ @Override
+ public void caller() {
+ // cast to CallInterface to force invokeinterface usage
+ if (nativeCallee) {
+ Asserts.assertTrue(((CallInterface) this)
+ .calleeNative(1, 2L, 3.0f, 4.0d, "5"), CALL_ERR_MSG);
+ } else {
+ Asserts.assertTrue(((CallInterface) this)
+ .callee(1, 2L, 3.0f, 4.0d, "5"), CALL_ERR_MSG);
+ }
+ }
+
+ /**
+ * A callee method, assumed to be called by "caller"/"callerNative"
+ */
+ @Override
+ public boolean callee(int param1, long param2, float param3, double param4,
+ String param5) {
+ calleeVisited = true;
+ CallsBase.checkValues(param1, param2, param3, param4, param5);
+ return true;
+ }
+
+ /**
+ * A native callee method, assumed to be called by "caller"/"callerNative"
+ */
+ @Override
+ public native boolean calleeNative(int param1, long param2, float param3,
+ double param4, String param5);
+
+ /**
+ * Returns object to lock execution on
+ * @return lock object
+ */
+ @Override
+ protected Object getLockObject() {
+ return LOCK;
+ }
+
+ @Override
+ protected void callerNative() {
+ throw new Error("No native call for invokeinterface");
+ }
+}
diff --git a/hotspot/test/compiler/calls/common/InvokeSpecial.java b/hotspot/test/compiler/calls/common/InvokeSpecial.java
new file mode 100644
index 00000000000..1eb34873a83
--- /dev/null
+++ b/hotspot/test/compiler/calls/common/InvokeSpecial.java
@@ -0,0 +1,80 @@
+/*
+ * 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.calls.common;
+
+import jdk.test.lib.Asserts;
+
+/**
+ * A test class checking InvokeSpecial instruction
+ */
+public class InvokeSpecial extends CallsBase {
+ private static final Object LOCK = new Object();
+
+ public static void main(String args[]) {
+ new InvokeSpecial().runTest(args);
+ }
+
+ /**
+ * A native caller method, assumed to called "callee"/"calleeNative"
+ */
+ @Override
+ public native void callerNative();
+
+ /**
+ * A caller method, assumed to called "callee"/"calleeNative"
+ */
+ @Override
+ public void caller() {
+ if (nativeCallee) {
+ Asserts.assertTrue(calleeNative(1, 2L, 3.0f, 4.0d, "5"), CALL_ERR_MSG);
+ } else {
+ Asserts.assertTrue(callee(1, 2L, 3.0f, 4.0d, "5"), CALL_ERR_MSG);
+ }
+ }
+
+ /**
+ * A callee method, assumed to be called by "caller"/"callerNative"
+ */
+ private boolean callee(int param1, long param2, float param3, double param4,
+ String param5) {
+ calleeVisited = true;
+ CallsBase.checkValues(param1, param2, param3, param4, param5);
+ return true;
+ }
+
+ /**
+ * A native callee method, assumed to be called by "caller"/"callerNative"
+ */
+ public native boolean calleeNative(int param1, long param2, float param3,
+ double param4, String param5);
+
+ /**
+ * Returns object to lock execution on
+ * @return lock object
+ */
+ @Override
+ protected Object getLockObject() {
+ return LOCK;
+ }
+}
diff --git a/hotspot/test/compiler/calls/common/InvokeStatic.java b/hotspot/test/compiler/calls/common/InvokeStatic.java
new file mode 100644
index 00000000000..18abcae7327
--- /dev/null
+++ b/hotspot/test/compiler/calls/common/InvokeStatic.java
@@ -0,0 +1,91 @@
+/*
+ * 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.calls.common;
+
+import jdk.test.lib.Asserts;
+
+/**
+ * A test class checking InvokeStatic instruction
+ */
+public class InvokeStatic extends CallsBase {
+ private static final Object LOCK = new Object();
+
+ public static void main(String args[]) {
+ new InvokeStatic().runTest(args);
+ }
+
+ /**
+ * A native caller method, assumed to called "callee"/"calleeNative"
+ */
+ @Override
+ public native void callerNative();
+
+ /**
+ * A caller method, assumed to called "callee"/"calleeNative"
+ */
+ @Override
+ public void caller() {
+ if (nativeCallee) {
+ Asserts.assertTrue(calleeNative(this, 1, 2L, 3.0f, 4.0d, "5"),
+ CALL_ERR_MSG);
+ } else {
+ Asserts.assertTrue(callee(this, 1, 2L, 3.0f, 4.0d, "5"),
+ CALL_ERR_MSG);
+ }
+ }
+
+ /**
+ * A callee method, assumed to be called by "caller"/"callerNative"
+ */
+ public static boolean callee(InvokeStatic instance, int param1,
+ long param2, float param3, double param4, String param5) {
+ instance.calleeVisited = true;
+ CallsBase.checkValues(param1, param2, param3, param4, param5);
+ return true;
+ }
+
+ /**
+ * A native callee method, assumed to be called by "caller"/"callerNative"
+ */
+ public static native boolean calleeNative(InvokeStatic instance,
+ int param1, long param2, float param3, double param4, String param5);
+
+ /**
+ * Returns object to lock execution on
+ * @return lock object
+ */
+ @Override
+ protected Object getLockObject() {
+ return LOCK;
+ }
+
+ /**
+ * Provides callee parameters types to search method
+ * @return array of types
+ */
+ protected Class[] getCalleeParametersTypes() {
+ return new Class[]{InvokeStatic.class, int.class, long.class,
+ float.class, double.class, String.class};
+ }
+}
diff --git a/hotspot/test/compiler/calls/common/InvokeVirtual.java b/hotspot/test/compiler/calls/common/InvokeVirtual.java
new file mode 100644
index 00000000000..6443fd63bc3
--- /dev/null
+++ b/hotspot/test/compiler/calls/common/InvokeVirtual.java
@@ -0,0 +1,81 @@
+/*
+ * 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.calls.common;
+
+import jdk.test.lib.Asserts;
+
+/**
+ * A test class checking InvokeVirtual instruction
+ */
+
+public class InvokeVirtual extends CallsBase {
+ private static final Object LOCK = new Object();
+
+ public static void main(String args[]) {
+ new InvokeVirtual().runTest(args);
+ }
+
+ /**
+ * A native caller method, assumed to called "callee"/"calleeNative"
+ */
+ @Override
+ public native void callerNative();
+
+ /**
+ * A caller method, assumed to called "callee"/"calleeNative"
+ */
+ @Override
+ public void caller() {
+ if (nativeCallee) {
+ Asserts.assertTrue(calleeNative(1, 2L, 3.0f, 4.0d, "5"), CALL_ERR_MSG);
+ } else {
+ Asserts.assertTrue(callee(1, 2L, 3.0f, 4.0d, "5"), CALL_ERR_MSG);
+ }
+ }
+
+ /**
+ * A callee method, assumed to be called by "caller"/"callerNative"
+ */
+ public boolean callee(int param1, long param2, float param3, double param4,
+ String param5) {
+ calleeVisited = true;
+ CallsBase.checkValues(param1, param2, param3, param4, param5);
+ return true;
+ }
+
+ /**
+ * A native callee method, assumed to be called by "caller"/"callerNative"
+ */
+ public native boolean calleeNative(int param1, long param2, float param3,
+ double param4, String param5);
+
+ /**
+ * Returns object to lock execution on
+ * @return lock object
+ */
+ @Override
+ protected Object getLockObject() {
+ return LOCK;
+ }
+}
diff --git a/hotspot/test/compiler/calls/common/libCallsNative.c b/hotspot/test/compiler/calls/common/libCallsNative.c
new file mode 100644
index 00000000000..aacaacc3de1
--- /dev/null
+++ b/hotspot/test/compiler/calls/common/libCallsNative.c
@@ -0,0 +1,148 @@
+/*
+ * 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.
+ */
+
+#include
+
+#include "jni.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define METHOD_SIGNATURE "(IJFDLjava/lang/String;)Z"
+#define STATIC_CALLEE_SIGNATURE "(Lcompiler/calls/common/InvokeStatic;IJFDLjava/lang/String;)Z"
+#define BASE_CLASS "compiler/calls/common/CallsBase"
+
+#define CHECK_EXCEPTIONS if ((*env)->ExceptionCheck(env)) return
+#define CHECK_EXCEPTIONS_FALSE if ((*env)->ExceptionCheck(env)) return JNI_FALSE
+
+#define IS_STATIC 1
+#define NOT_STATIC 0
+
+jboolean doCalleeWork(JNIEnv *env, jobject self, jint param1, jlong param2,
+ jfloat param3, jdouble param4, jstring param5) {
+ jclass cls = (*env)->GetObjectClass(env, self);
+ jfieldID calleeVisitedID = (*env)->GetFieldID(env, cls, "calleeVisited", "Z");
+ jclass CheckCallsBaseClass;
+ jmethodID checkValuesID;
+ CHECK_EXCEPTIONS_FALSE;
+ (*env)->SetBooleanField(env, self, calleeVisitedID, JNI_TRUE);
+ CHECK_EXCEPTIONS_FALSE;
+ CheckCallsBaseClass = (*env)->FindClass(env, BASE_CLASS);
+ CHECK_EXCEPTIONS_FALSE;
+ checkValuesID = (*env)->GetStaticMethodID(env, CheckCallsBaseClass,
+ "checkValues", "(IJFDLjava/lang/String;)V");
+ CHECK_EXCEPTIONS_FALSE;
+ (*env)->CallStaticVoidMethod(env, CheckCallsBaseClass, checkValuesID,
+ param1, param2, param3, param4, param5);
+ return JNI_TRUE;
+}
+
+JNIEXPORT jboolean JNICALL Java_compiler_calls_common_InvokeDynamic_calleeNative(JNIEnv *env, jobject obj,
+ jint param1, jlong param2, jfloat param3, jdouble param4, jstring param5) {
+ return doCalleeWork(env, obj, param1, param2, param3, param4, param5);
+}
+
+JNIEXPORT jboolean JNICALL Java_compiler_calls_common_InvokeInterface_calleeNative(JNIEnv *env, jobject obj,
+ jint param1, jlong param2, jfloat param3, jdouble param4, jstring param5) {
+ return doCalleeWork(env, obj, param1, param2, param3, param4, param5);
+}
+
+JNIEXPORT jboolean JNICALL Java_compiler_calls_common_InvokeSpecial_calleeNative(JNIEnv *env, jobject obj,
+ jint param1, jlong param2, jfloat param3, jdouble param4, jstring param5) {
+ return doCalleeWork(env, obj, param1, param2, param3, param4, param5);
+}
+
+JNIEXPORT jboolean JNICALL Java_compiler_calls_common_InvokeVirtual_calleeNative(JNIEnv *env, jobject obj,
+ jint param1, jlong param2, jfloat param3, jdouble param4, jstring param5) {
+ return doCalleeWork(env, obj, param1, param2, param3, param4, param5);
+}
+
+JNIEXPORT jboolean JNICALL Java_compiler_calls_common_InvokeStatic_calleeNative(JNIEnv *env, jclass obj,
+ jobject self, jint param1, jlong param2, jfloat param3, jdouble param4, jstring param5) {
+ return doCalleeWork(env, self, param1, param2, param3, param4, param5);
+}
+
+void doCallerWork(JNIEnv *env, jobject obj, int isStatic) {
+ jclass cls = (*env)->GetObjectClass(env, obj);
+ jmethodID calleeMethodID = 0;
+ jfieldID errorMessageID;
+ jfieldID nativeCalleeID;
+ jobject errorMessage;
+ jmethodID assertTrue;
+ jboolean callNative;
+ jclass assertsClass;
+ jclass baseClass;
+ jboolean result;
+ char* methodName;
+ CHECK_EXCEPTIONS;
+ nativeCalleeID = (*env)->GetFieldID(env, cls, "nativeCallee", "Z");
+ CHECK_EXCEPTIONS;
+ callNative = (*env)->GetBooleanField(env, obj, nativeCalleeID);
+ CHECK_EXCEPTIONS;
+ methodName = (callNative == JNI_TRUE) ? "calleeNative" : "callee";
+ if (isStatic) {
+ calleeMethodID = (*env)->GetStaticMethodID(env, cls, methodName,
+ STATIC_CALLEE_SIGNATURE);
+ } else {
+ calleeMethodID = (*env)->GetMethodID(env, cls, methodName, METHOD_SIGNATURE);
+ }
+ CHECK_EXCEPTIONS;
+ if (isStatic) {
+ result = (*env)->CallStaticBooleanMethod(env, cls, calleeMethodID, obj,
+ (jint) 1, (jlong) 2L, (jfloat) 3.0f, (jdouble) 4.0, (*env)->NewStringUTF(env, "5"));
+ } else {
+ result = (*env)->CallBooleanMethod(env, obj, calleeMethodID,
+ (jint) 1, (jlong) 2L, (jfloat) 3.0f, (jdouble) 4.0, (*env)->NewStringUTF(env, "5"));
+ }
+ CHECK_EXCEPTIONS;
+ baseClass = (*env)->FindClass(env, BASE_CLASS);
+ CHECK_EXCEPTIONS;
+ errorMessageID = (*env)->GetStaticFieldID(env, baseClass,
+ "CALL_ERR_MSG", "Ljava/lang/String;");
+ CHECK_EXCEPTIONS;
+ errorMessage = (*env)->GetStaticObjectField(env, baseClass, errorMessageID);
+ CHECK_EXCEPTIONS;
+ assertsClass = (*env)->FindClass(env, "jdk/test/lib/Asserts");
+ CHECK_EXCEPTIONS;
+ assertTrue = (*env)->GetStaticMethodID(env, assertsClass,
+ "assertTrue", "(ZLjava/lang/String;)V");
+ (*env)->CallStaticVoidMethod(env, assertsClass, assertTrue, result,
+ errorMessage);
+}
+
+JNIEXPORT void JNICALL Java_compiler_calls_common_InvokeSpecial_callerNative(JNIEnv *env, jobject obj) {
+ doCallerWork(env, obj, NOT_STATIC);
+}
+
+JNIEXPORT void JNICALL Java_compiler_calls_common_InvokeVirtual_callerNative(JNIEnv *env, jobject obj) {
+ doCallerWork(env, obj, NOT_STATIC);
+}
+
+JNIEXPORT void JNICALL Java_compiler_calls_common_InvokeStatic_callerNative(JNIEnv *env, jobject obj) {
+ doCallerWork(env, obj, IS_STATIC);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeDynamic2CompiledTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeDynamic2CompiledTest.java
new file mode 100644
index 00000000000..dd4daef9849
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeDynamic2CompiledTest.java
@@ -0,0 +1,45 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeDynamic
+ * @build compiler.calls.common.InvokeDynamicPatcher
+ * @run driver compiler.calls.common.InvokeDynamicPatcher
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeDynamic
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeDynamic
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeDynamic
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeDynamic
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from compiled to compiled using InvokeDynamic
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeDynamic2InterpretedTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeDynamic2InterpretedTest.java
new file mode 100644
index 00000000000..3074acbc1a8
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeDynamic2InterpretedTest.java
@@ -0,0 +1,39 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeDynamic
+ * @build compiler.calls.common.InvokeDynamicPatcher
+ * @run driver compiler.calls.common.InvokeDynamicPatcher
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeDynamic::callee compiler.calls.common.InvokeDynamic
+ * -compileCaller 1 -checkCallerCompileLevel 1 -checkCalleeCompileLevel 0
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeDynamic::callee compiler.calls.common.InvokeDynamic
+ * -compileCaller 4 -checkCallerCompileLevel 4 -checkCalleeCompileLevel 0
+ * @summary check calls from compiled to interpreted using InvokeDynamic
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeDynamic2NativeTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeDynamic2NativeTest.java
new file mode 100644
index 00000000000..b06cbf5c89c
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeDynamic2NativeTest.java
@@ -0,0 +1,39 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeDynamic
+ * @build compiler.calls.common.InvokeDynamicPatcher
+ * @run driver compiler.calls.common.InvokeDynamicPatcher
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeDynamic
+ * -compileCaller 1 -checkCallerCompileLevel 1 -nativeCallee
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeDynamic
+ * -compileCaller 4 -checkCallerCompileLevel 4 -nativeCallee
+ * @summary check calls from compiled to native using InvokeDynamic
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeInterface2CompiledTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeInterface2CompiledTest.java
new file mode 100644
index 00000000000..fec0fda8aee
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeInterface2CompiledTest.java
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeInterface
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeInterface
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeInterface
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeInterface
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeInterface
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from compiled to compiled using InvokeInterface
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeInterface2InterpretedTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeInterface2InterpretedTest.java
new file mode 100644
index 00000000000..2baf4e7caa8
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeInterface2InterpretedTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeInterface
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeInterface::callee compiler.calls.common.InvokeInterface
+ * -compileCaller 1 -checkCallerCompileLevel 1 -checkCalleeCompileLevel 0
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeInterface::callee compiler.calls.common.InvokeInterface
+ * -compileCaller 4 -checkCallerCompileLevel 4 -checkCalleeCompileLevel 0
+ * @summary check calls from compiled to interpreted using InvokeInterface
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeInterface2NativeTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeInterface2NativeTest.java
new file mode 100644
index 00000000000..ec394a10f93
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeInterface2NativeTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeInterface
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeInterface
+ * -compileCaller 1 -checkCallerCompileLevel 1 -nativeCallee
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeInterface
+ * -compileCaller 4 -checkCallerCompileLevel 4 -nativeCallee
+ * @summary check calls from compiled to native using InvokeInterface
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeSpecial2CompiledTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeSpecial2CompiledTest.java
new file mode 100644
index 00000000000..5d659f5bbef
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeSpecial2CompiledTest.java
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeSpecial
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeSpecial
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeSpecial
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeSpecial
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeSpecial
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from compiled to compiled using InvokeSpecial
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeSpecial2InterpretedTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeSpecial2InterpretedTest.java
new file mode 100644
index 00000000000..1a6c6c9ec17
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeSpecial2InterpretedTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeSpecial
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeSpecial::callee compiler.calls.common.InvokeSpecial
+ * -compileCaller 1 -checkCallerCompileLevel 1 -checkCalleeCompileLevel 0
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeSpecial::callee compiler.calls.common.InvokeSpecial
+ * -compileCaller 4 -checkCallerCompileLevel 4 -checkCalleeCompileLevel 0
+ * @summary check calls from compiled to interpreted using InvokeSpecial
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeSpecial2NativeTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeSpecial2NativeTest.java
new file mode 100644
index 00000000000..e1b64749d22
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeSpecial2NativeTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeSpecial
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeSpecial
+ * -compileCaller 1 -checkCallerCompileLevel 1 -nativeCallee
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeSpecial
+ * -compileCaller 4 -checkCallerCompileLevel 4 -nativeCallee
+ * @summary check calls from compiled to native using InvokeSpecial
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeStatic2CompiledTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeStatic2CompiledTest.java
new file mode 100644
index 00000000000..f31ef6ba9ff
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeStatic2CompiledTest.java
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeStatic
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeStatic
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeStatic
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeStatic
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeStatic
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from compiled to compiled using InvokeStatic
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeStatic2InterpretedTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeStatic2InterpretedTest.java
new file mode 100644
index 00000000000..8a8b8565a05
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeStatic2InterpretedTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeStatic
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeStatic::callee compiler.calls.common.InvokeStatic
+ * -compileCaller 1 -checkCallerCompileLevel 1 -checkCalleeCompileLevel 0
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeStatic::callee compiler.calls.common.InvokeStatic
+ * -compileCaller 4 -checkCallerCompileLevel 4 -checkCalleeCompileLevel 0
+ * @summary check calls from compiled to interpreted using InvokeStatic
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeStatic2NativeTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeStatic2NativeTest.java
new file mode 100644
index 00000000000..955a727f00b
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeStatic2NativeTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeStatic
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeStatic
+ * -compileCaller 1 -checkCallerCompileLevel 1 -nativeCallee
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeStatic
+ * -compileCaller 4 -checkCallerCompileLevel 4 -nativeCallee
+ * @summary check calls from compiled to native using InvokeStatic
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeVirtual2CompiledTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeVirtual2CompiledTest.java
new file mode 100644
index 00000000000..53fb39ac117
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeVirtual2CompiledTest.java
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeVirtual
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeVirtual
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeVirtual
+ * -compileCaller 1 -checkCallerCompileLevel 1 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeVirtual
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeVirtual
+ * -compileCaller 4 -checkCallerCompileLevel 4 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from compiled to compiled using InvokeVirtual
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeVirtual2InterpretedTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeVirtual2InterpretedTest.java
new file mode 100644
index 00000000000..d875be780df
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeVirtual2InterpretedTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeVirtual
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeVirtual::callee compiler.calls.common.InvokeVirtual
+ * -compileCaller 1 -checkCallerCompileLevel 1 -checkCalleeCompileLevel 0
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch -XX:CompileCommand=exclude,compiler.calls.common.InvokeVirtual::callee compiler.calls.common.InvokeVirtual
+ * -compileCaller 4 -checkCallerCompileLevel 4 -checkCalleeCompileLevel 0
+ * @summary check calls from compiled to interpreted using InvokeVirtual
+ */
diff --git a/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeVirtual2NativeTest.java b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeVirtual2NativeTest.java
new file mode 100644
index 00000000000..0f69bb50cf4
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromCompiled/CompiledInvokeVirtual2NativeTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeVirtual
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeVirtual
+ * -compileCaller 1 -checkCallerCompileLevel 1 -nativeCallee
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeVirtual
+ * -compileCaller 4 -checkCallerCompileLevel 4 -nativeCallee
+ * @summary check calls from compiled to native using InvokeVirtual
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeDynamic2CompiledTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeDynamic2CompiledTest.java
new file mode 100644
index 00000000000..28b38025db6
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeDynamic2CompiledTest.java
@@ -0,0 +1,39 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeDynamic
+ * @build compiler.calls.common.InvokeDynamicPatcher
+ * @run driver compiler.calls.common.InvokeDynamicPatcher
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeDynamic::caller -Xbatch compiler.calls.common.InvokeDynamic
+ * -checkCallerCompileLevel 0 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeDynamic::caller -Xbatch compiler.calls.common.InvokeDynamic
+ * -checkCallerCompileLevel 0 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from interpreted to compiled using InvokeDynamic
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeDynamic2InterpretedTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeDynamic2InterpretedTest.java
new file mode 100644
index 00000000000..3359e8104be
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeDynamic2InterpretedTest.java
@@ -0,0 +1,36 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeDynamic
+ * @build compiler.calls.common.InvokeDynamicPatcher
+ * @run driver compiler.calls.common.InvokeDynamicPatcher
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeDynamic::caller -XX:CompileCommand=exclude,compiler.calls.common.InvokeDynamic::callee compiler.calls.common.InvokeDynamic
+ * -checkCallerCompileLevel 0 -checkCalleeCompileLevel 0
+ * @summary check calls from interpreted to interpreted using InvokeDynamic
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeDynamic2NativeTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeDynamic2NativeTest.java
new file mode 100644
index 00000000000..03fbfdda2a4
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeDynamic2NativeTest.java
@@ -0,0 +1,36 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeDynamic
+ * @build compiler.calls.common.InvokeDynamicPatcher
+ * @run driver compiler.calls.common.InvokeDynamicPatcher
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeDynamic::caller compiler.calls.common.InvokeDynamic
+ * -checkCallerCompileLevel 0 -nativeCallee
+ * @summary check calls from interpreted to native using InvokeDynamic
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeInterface2CompiledTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeInterface2CompiledTest.java
new file mode 100644
index 00000000000..84b4e5016ca
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeInterface2CompiledTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeInterface
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeInterface::caller -Xbatch compiler.calls.common.InvokeInterface
+ * -checkCallerCompileLevel 0 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeInterface::caller -Xbatch compiler.calls.common.InvokeInterface
+ * -checkCallerCompileLevel 0 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from interpreted to compiled using InvokeInterface
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeInterface2InterpretedTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeInterface2InterpretedTest.java
new file mode 100644
index 00000000000..a4f204f1d34
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeInterface2InterpretedTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeInterface
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeInterface::caller -XX:CompileCommand=exclude,compiler.calls.common.InvokeInterface::callee compiler.calls.common.InvokeInterface
+ * -checkCallerCompileLevel 0 -checkCalleeCompileLevel 0
+ * @summary check calls from interpreted to interpreted using InvokeInterface
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeInterface2NativeTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeInterface2NativeTest.java
new file mode 100644
index 00000000000..ca0044524e0
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeInterface2NativeTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeInterface
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeInterface::caller compiler.calls.common.InvokeInterface
+ * -checkCallerCompileLevel 0 -nativeCallee
+ * @summary check calls from interpreted to native using InvokeInterface
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeSpecial2CompiledTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeSpecial2CompiledTest.java
new file mode 100644
index 00000000000..d47585abf29
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeSpecial2CompiledTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeSpecial
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeSpecial::caller -Xbatch compiler.calls.common.InvokeSpecial
+ * -checkCallerCompileLevel 0 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeSpecial::caller -Xbatch compiler.calls.common.InvokeSpecial
+ * -checkCallerCompileLevel 0 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from interpreted to compiled using InvokeSpecial
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeSpecial2InterpretedTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeSpecial2InterpretedTest.java
new file mode 100644
index 00000000000..9c047fa9502
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeSpecial2InterpretedTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeSpecial
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeSpecial::caller -XX:CompileCommand=exclude,compiler.calls.common.InvokeSpecial::callee compiler.calls.common.InvokeSpecial
+ * -checkCallerCompileLevel 0 -checkCalleeCompileLevel 0
+ * @summary check calls from interpreted to interpreted using InvokeSpecial
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeSpecial2NativeTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeSpecial2NativeTest.java
new file mode 100644
index 00000000000..768d5eb9dae
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeSpecial2NativeTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeSpecial
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeSpecial::caller compiler.calls.common.InvokeSpecial
+ * -checkCallerCompileLevel 0 -nativeCallee
+ * @summary check calls from interpreted to native using InvokeSpecial
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeStatic2CompiledTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeStatic2CompiledTest.java
new file mode 100644
index 00000000000..de4f6c2b995
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeStatic2CompiledTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeStatic
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeStatic::caller -Xbatch compiler.calls.common.InvokeStatic
+ * -checkCallerCompileLevel 0 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeStatic::caller -Xbatch compiler.calls.common.InvokeStatic
+ * -checkCallerCompileLevel 0 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from interpreted to compiled using InvokeStatic
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeStatic2InterpretedTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeStatic2InterpretedTest.java
new file mode 100644
index 00000000000..06339099281
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeStatic2InterpretedTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeStatic
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeStatic::caller -XX:CompileCommand=exclude,compiler.calls.common.InvokeStatic::callee compiler.calls.common.InvokeStatic
+ * -checkCallerCompileLevel 0 -checkCalleeCompileLevel 0
+ * @summary check calls from interpreted to interpreted using InvokeStatic
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeStatic2NativeTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeStatic2NativeTest.java
new file mode 100644
index 00000000000..2a7deda7655
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeStatic2NativeTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeStatic
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeStatic::caller compiler.calls.common.InvokeStatic
+ * -checkCallerCompileLevel 0 -nativeCallee
+ * @summary check calls from interpreted to native using InvokeStatic
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeVirtual2CompiledTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeVirtual2CompiledTest.java
new file mode 100644
index 00000000000..fb7a645ec8d
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeVirtual2CompiledTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeVirtual
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeVirtual::caller -Xbatch compiler.calls.common.InvokeVirtual
+ * -checkCallerCompileLevel 0 -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeVirtual::caller -Xbatch compiler.calls.common.InvokeVirtual
+ * -checkCallerCompileLevel 0 -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from interpreted to compiled using InvokeVirtual
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeVirtual2InterpretedTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeVirtual2InterpretedTest.java
new file mode 100644
index 00000000000..c4eecef1d80
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeVirtual2InterpretedTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeVirtual
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeVirtual::caller -XX:CompileCommand=exclude,compiler.calls.common.InvokeVirtual::callee compiler.calls.common.InvokeVirtual
+ * -checkCallerCompileLevel 0 -checkCalleeCompileLevel 0
+ * @summary check calls from interpreted to interpreted using InvokeVirtual
+ */
diff --git a/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeVirtual2NativeTest.java b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeVirtual2NativeTest.java
new file mode 100644
index 00000000000..2ac9911b4d3
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromInterpreted/InterpretedInvokeVirtual2NativeTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeVirtual
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeVirtual::caller compiler.calls.common.InvokeVirtual
+ * -checkCallerCompileLevel 0 -nativeCallee
+ * @summary check calls from interpreted to native using InvokeVirtual
+ */
diff --git a/hotspot/test/compiler/calls/fromNative/NativeInvokeSpecial2CompiledTest.java b/hotspot/test/compiler/calls/fromNative/NativeInvokeSpecial2CompiledTest.java
new file mode 100644
index 00000000000..1a303bdf088
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromNative/NativeInvokeSpecial2CompiledTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeSpecial
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeSpecial
+ * -nativeCaller -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeSpecial
+ * -nativeCaller -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from native to compiled using InvokeSpecial
+ */
diff --git a/hotspot/test/compiler/calls/fromNative/NativeInvokeSpecial2InterpretedTest.java b/hotspot/test/compiler/calls/fromNative/NativeInvokeSpecial2InterpretedTest.java
new file mode 100644
index 00000000000..517422adf6e
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromNative/NativeInvokeSpecial2InterpretedTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeSpecial
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeSpecial::callee compiler.calls.common.InvokeSpecial
+ * -nativeCaller -checkCalleeCompileLevel 0
+ * @summary check calls from native to interpreted using InvokeSpecial
+ */
diff --git a/hotspot/test/compiler/calls/fromNative/NativeInvokeSpecial2NativeTest.java b/hotspot/test/compiler/calls/fromNative/NativeInvokeSpecial2NativeTest.java
new file mode 100644
index 00000000000..9b3d7ad166a
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromNative/NativeInvokeSpecial2NativeTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeSpecial
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * compiler.calls.common.InvokeSpecial
+ * -nativeCaller -nativeCallee
+ * @summary check calls from native to native using InvokeSpecial
+ */
diff --git a/hotspot/test/compiler/calls/fromNative/NativeInvokeStatic2CompiledTest.java b/hotspot/test/compiler/calls/fromNative/NativeInvokeStatic2CompiledTest.java
new file mode 100644
index 00000000000..546ed827801
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromNative/NativeInvokeStatic2CompiledTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeStatic
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeStatic
+ * -nativeCaller -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeStatic
+ * -nativeCaller -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from native to compiled using InvokeStatic
+ */
diff --git a/hotspot/test/compiler/calls/fromNative/NativeInvokeStatic2InterpretedTest.java b/hotspot/test/compiler/calls/fromNative/NativeInvokeStatic2InterpretedTest.java
new file mode 100644
index 00000000000..5e480d82f36
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromNative/NativeInvokeStatic2InterpretedTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeStatic
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeStatic::callee compiler.calls.common.InvokeStatic
+ * -nativeCaller -checkCalleeCompileLevel 0
+ * @summary check calls from native to interpreted using InvokeStatic
+ */
diff --git a/hotspot/test/compiler/calls/fromNative/NativeInvokeStatic2NativeTest.java b/hotspot/test/compiler/calls/fromNative/NativeInvokeStatic2NativeTest.java
new file mode 100644
index 00000000000..9ace6ea67b5
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromNative/NativeInvokeStatic2NativeTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeStatic
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * compiler.calls.common.InvokeStatic
+ * -nativeCaller -nativeCallee
+ * @summary check calls from native to native using InvokeStatic
+ */
diff --git a/hotspot/test/compiler/calls/fromNative/NativeInvokeVirtual2CompiledTest.java b/hotspot/test/compiler/calls/fromNative/NativeInvokeVirtual2CompiledTest.java
new file mode 100644
index 00000000000..56059718e81
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromNative/NativeInvokeVirtual2CompiledTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeVirtual
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeVirtual
+ * -nativeCaller -compileCallee 1 -checkCalleeCompileLevel 1
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -Xbatch compiler.calls.common.InvokeVirtual
+ * -nativeCaller -compileCallee 4 -checkCalleeCompileLevel 4
+ * @summary check calls from native to compiled using InvokeVirtual
+ */
diff --git a/hotspot/test/compiler/calls/fromNative/NativeInvokeVirtual2InterpretedTest.java b/hotspot/test/compiler/calls/fromNative/NativeInvokeVirtual2InterpretedTest.java
new file mode 100644
index 00000000000..09777265bc3
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromNative/NativeInvokeVirtual2InterpretedTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeVirtual
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * -XX:CompileCommand=exclude,compiler.calls.common.InvokeVirtual::callee compiler.calls.common.InvokeVirtual
+ * -nativeCaller -checkCalleeCompileLevel 0
+ * @summary check calls from native to interpreted using InvokeVirtual
+ */
diff --git a/hotspot/test/compiler/calls/fromNative/NativeInvokeVirtual2NativeTest.java b/hotspot/test/compiler/calls/fromNative/NativeInvokeVirtual2NativeTest.java
new file mode 100644
index 00000000000..d4ddd119fc3
--- /dev/null
+++ b/hotspot/test/compiler/calls/fromNative/NativeInvokeVirtual2NativeTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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
+ * @library /test/lib /testlibrary /
+ * @build compiler.calls.common.InvokeVirtual
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:.
+ * compiler.calls.common.InvokeVirtual
+ * -nativeCaller -nativeCallee
+ * @summary check calls from native to native using InvokeVirtual
+ */
diff --git a/hotspot/test/compiler/codegen/7184394/TestAESBase.java b/hotspot/test/compiler/codegen/7184394/TestAESBase.java
index 04edf19636f..6fa53c04a1a 100644
--- a/hotspot/test/compiler/codegen/7184394/TestAESBase.java
+++ b/hotspot/test/compiler/codegen/7184394/TestAESBase.java
@@ -104,8 +104,8 @@ abstract public class TestAESBase {
cipher = Cipher.getInstance(algorithm + "/" + mode + "/" + paddingStr, "SunJCE");
dCipher = Cipher.getInstance(algorithm + "/" + mode + "/" + paddingStr, "SunJCE");
- // CBC init
- if (mode.equals("CBC")) {
+ // CBC or CTR init
+ if (mode.equals("CBC") || mode.equals("CTR")) {
IvParameterSpec initVector = new IvParameterSpec(iv);
cipher.init(Cipher.ENCRYPT_MODE, key, initVector);
algParams = cipher.getParameters();
diff --git a/hotspot/test/compiler/codegen/7184394/TestAESMain.java b/hotspot/test/compiler/codegen/7184394/TestAESMain.java
index 6b5e072ea35..a4ed27f3bc2 100644
--- a/hotspot/test/compiler/codegen/7184394/TestAESMain.java
+++ b/hotspot/test/compiler/codegen/7184394/TestAESMain.java
@@ -51,6 +51,13 @@
* @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=GCM -DencInputOffset=1 -DencOutputOffset=1 TestAESMain
* @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=GCM -DencInputOffset=1 -DencOutputOffset=1 -DdecOutputOffset=1 TestAESMain
* @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=GCM -DencInputOffset=1 -DencOutputOffset=1 -DdecOutputOffset=1 -DpaddingStr=NoPadding -DmsgSize=640 TestAESMain
+ * @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=CTR TestAESMain
+ * @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=CTR -DencInputOffset=1 TestAESMain
+ * @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=CTR -DencOutputOffset=1 TestAESMain
+ * @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=CTR -DdecOutputOffset=1 TestAESMain
+ * @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=CTR -DencInputOffset=1 -DencOutputOffset=1 TestAESMain
+ * @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=CTR -DencInputOffset=1 -DencOutputOffset=1 -DdecOutputOffset=1 TestAESMain
+ * @run main/othervm/timeout=600 -Xbatch -DcheckOutput=true -Dmode=CTR -DencInputOffset=1 -DencOutputOffset=1 -DdecOutputOffset=1 -DpaddingStr=NoPadding -DmsgSize=640 TestAESMain
*
* @author Tom Deneau
*/
diff --git a/hotspot/test/compiler/compilercontrol/commandfile/ExcludeTest.java b/hotspot/test/compiler/compilercontrol/commandfile/ExcludeTest.java
index b4843a7d930..0e5dc7948e0 100644
--- a/hotspot/test/compiler/compilercontrol/commandfile/ExcludeTest.java
+++ b/hotspot/test/compiler/compilercontrol/commandfile/ExcludeTest.java
@@ -30,7 +30,7 @@
* compiler.testlibrary.CompilerUtils compiler.compilercontrol.share.actions.*
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
- * @run main/othervm compiler.compilercontrol.commands.ExcludeTest
+ * @run main/othervm compiler.compilercontrol.commandfile.ExcludeTest
*/
package compiler.compilercontrol.commandfile;
diff --git a/hotspot/test/compiler/compilercontrol/mixed/RandomValidCommandsTest.java b/hotspot/test/compiler/compilercontrol/mixed/RandomValidCommandsTest.java
index 508963836e3..951789991f7 100644
--- a/hotspot/test/compiler/compilercontrol/mixed/RandomValidCommandsTest.java
+++ b/hotspot/test/compiler/compilercontrol/mixed/RandomValidCommandsTest.java
@@ -24,7 +24,6 @@
/*
* @test
* @bug 8137167
- * @ignore 8140667
* @summary Randomly generates valid commands with random types
* @library /testlibrary /../../test/lib /compiler/testlibrary ../share /
* @build RandomValidCommandsTest pool.sub.* pool.subpack.* sun.hotspot.WhiteBox
diff --git a/hotspot/test/compiler/compilercontrol/parser/DirectiveStressTest.java b/hotspot/test/compiler/compilercontrol/parser/DirectiveStressTest.java
index 8e23273e643..ef1a311beca 100644
--- a/hotspot/test/compiler/compilercontrol/parser/DirectiveStressTest.java
+++ b/hotspot/test/compiler/compilercontrol/parser/DirectiveStressTest.java
@@ -44,7 +44,7 @@ import java.util.stream.Collectors;
public class DirectiveStressTest {
private static final int AMOUNT = Integer.getInteger(
"compiler.compilercontrol.parser.DirectiveStressTest.amount",
- Short.MAX_VALUE * 2 + 2);
+ 999);
private static final List DESCRIPTORS
= new PoolHelper().getAllMethods().stream()
.map(pair -> AbstractTestBase.getValidMethodDescriptor(
diff --git a/hotspot/test/compiler/compilercontrol/parser/HugeDirectiveUtil.java b/hotspot/test/compiler/compilercontrol/parser/HugeDirectiveUtil.java
index d5100ccc33d..6bf59324810 100644
--- a/hotspot/test/compiler/compilercontrol/parser/HugeDirectiveUtil.java
+++ b/hotspot/test/compiler/compilercontrol/parser/HugeDirectiveUtil.java
@@ -117,6 +117,7 @@ public final class HugeDirectiveUtil {
try {
output = ProcessTools.executeTestJvm(
"-XX:+UnlockDiagnosticVMOptions",
+ "-XX:CompilerDirectivesLimit=1000",
"-XX:CompilerDirectivesFile=" + fileName,
"-version");
} catch (Throwable thr) {
diff --git a/hotspot/test/compiler/compilercontrol/share/scenario/AbstractCommandBuilder.java b/hotspot/test/compiler/compilercontrol/share/scenario/AbstractCommandBuilder.java
index 6a5b6342f47..0d78cadd8e0 100644
--- a/hotspot/test/compiler/compilercontrol/share/scenario/AbstractCommandBuilder.java
+++ b/hotspot/test/compiler/compilercontrol/share/scenario/AbstractCommandBuilder.java
@@ -33,6 +33,7 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.Callable;
/**
@@ -48,38 +49,12 @@ public abstract class AbstractCommandBuilder
@Override
public void add(CompileCommand command) {
compileCommands.add(command);
+ CommandStateBuilder.getInstance().add(command);
}
@Override
public Map getStates() {
- Map states = new HashMap<>();
- for (CompileCommand compileCommand : compileCommands) {
- if (compileCommand.isValid()) {
- CompileCommand cc = new CompileCommand(compileCommand.command,
- compileCommand.methodDescriptor,
- /* CompileCommand option and file doesn't support
- compiler setting */
- null,
- compileCommand.type);
- MethodDescriptor md = cc.methodDescriptor;
- for (Pair> pair: METHODS) {
- Executable exec = pair.first;
- State state = states.getOrDefault(exec, new State());
- MethodDescriptor execDesc = new MethodDescriptor(exec);
- // if executable matches regex then apply the state
- if (execDesc.getCanonicalString().matches(md.getRegexp())) {
- state.apply(cc);
- } else {
- if (cc.command == Command.COMPILEONLY) {
- state.setC1Compilable(false);
- state.setC2Compilable(false);
- }
- }
- states.put(exec, state);
- }
- }
- }
- return states;
+ return CommandStateBuilder.getInstance().getStates();
}
@Override
@@ -89,7 +64,102 @@ public abstract class AbstractCommandBuilder
@Override
public boolean isValid() {
- // CompileCommand ignores invalid items
+ // -XX:CompileCommand(File) ignores invalid items
return true;
}
+
+ /*
+ * This is an internal class used to build states for commands given from
+ * options and a file. As all commands are added into a single set in
+ * CompilerOracle, we need a class that builds states in the same manner
+ */
+ private static class CommandStateBuilder {
+ private static final CommandStateBuilder INSTANCE
+ = new CommandStateBuilder();
+ private final List optionCommands = new ArrayList<>();
+ private final List fileCommands = new ArrayList<>();
+
+ private CommandStateBuilder() { }
+
+ public static CommandStateBuilder getInstance() {
+ return INSTANCE;
+ }
+
+ public void add(CompileCommand command) {
+ switch (command.type) {
+ case OPTION:
+ optionCommands.add(command);
+ break;
+ case FILE:
+ fileCommands.add(command);
+ break;
+ default:
+ throw new Error("TESTBUG: wrong type: " + command.type);
+ }
+ }
+
+ public Map getStates() {
+ List commandList = new ArrayList<>();
+ commandList.addAll(optionCommands);
+ commandList.addAll(fileCommands);
+ Map states = new HashMap<>();
+ for (Pair> pair : METHODS) {
+ Executable exec = pair.first;
+ State state = getState(commandList, states, exec);
+ states.put(exec, state);
+ }
+ return states;
+ }
+
+ private State getState(List commandList,
+ Map states, Executable exec) {
+ State state = states.getOrDefault(exec, new State());
+ MethodDescriptor execDesc = new MethodDescriptor(exec);
+ for (CompileCommand compileCommand : commandList) {
+ if (compileCommand.isValid()) {
+ // Create a copy without compiler set
+ CompileCommand cc = new CompileCommand(
+ compileCommand.command,
+ compileCommand.methodDescriptor,
+ /* CompileCommand option and file doesn't support
+ compiler setting */
+ null,
+ compileCommand.type);
+ MethodDescriptor md = cc.methodDescriptor;
+ // if executable matches regex then apply the state
+ if (execDesc.getCanonicalString().matches(md.getRegexp())) {
+ if (cc.command == Command.COMPILEONLY
+ && !state.isCompilable()) {
+ /* if the method was already excluded it will not
+ be compilable again */
+ } else {
+ state.apply(cc);
+ }
+ }
+ }
+ }
+
+ /*
+ * Set compilation states for methods that don't match
+ * any compileonly command. Such methods should be excluded
+ * from compilation
+ */
+ for (CompileCommand compileCommand : commandList) {
+ if (compileCommand.isValid()
+ && (compileCommand.command == Command.COMPILEONLY)) {
+ MethodDescriptor md = compileCommand.methodDescriptor;
+ if (!execDesc.getCanonicalString().matches(md.getRegexp())
+ && (state.getCompilableOptional(
+ // no matter C1, C2 or both
+ Scenario.Compiler.C2).isPresent())) {
+ /* compileonly excludes only methods that haven't been
+ already set to be compilable or excluded */
+ state.setC1Compilable(false);
+ state.setC2Compilable(false);
+ }
+ }
+ }
+ return state;
+ }
+ }
}
diff --git a/hotspot/test/compiler/compilercontrol/share/scenario/State.java b/hotspot/test/compiler/compilercontrol/share/scenario/State.java
index b9a81984b69..82a46e7dc69 100644
--- a/hotspot/test/compiler/compilercontrol/share/scenario/State.java
+++ b/hotspot/test/compiler/compilercontrol/share/scenario/State.java
@@ -135,6 +135,10 @@ public class State {
+ "\nprint_inline " + printInline;
}
+ public Optional getCompilableOptional(Scenario.Compiler compiler) {
+ return compile[compiler.ordinal()];
+ }
+
public boolean isC1Compilable() {
return compile[Scenario.Compiler.C1.ordinal()].orElse(true);
}
diff --git a/hotspot/test/compiler/cpuflags/AESIntrinsicsBase.java b/hotspot/test/compiler/cpuflags/AESIntrinsicsBase.java
new file mode 100644
index 00000000000..8e8deda71bd
--- /dev/null
+++ b/hotspot/test/compiler/cpuflags/AESIntrinsicsBase.java
@@ -0,0 +1,65 @@
+/*
+ * 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.
+ *
+ */
+import jdk.test.lib.cli.CommandLineOptionTest;
+import predicate.AESSupportPredicate;
+
+import java.util.Arrays;
+import java.util.function.BooleanSupplier;
+
+public abstract class AESIntrinsicsBase extends CommandLineOptionTest {
+ public static final BooleanSupplier AES_SUPPORTED_PREDICATE
+ = new AESSupportPredicate();
+ public static final String CIPHER_INTRINSIC = "com\\.sun\\.crypto\\"
+ + ".provider\\.CipherBlockChaining::"
+ + "(implEncrypt|implDecrypt) \\([0-9]+ bytes\\)\\s+\\(intrinsic[,\\)]";
+ public static final String AES_INTRINSIC = "com\\.sun\\.crypto\\"
+ + ".provider\\.AESCrypt::(implEncryptBlock|implDecryptBlock) \\([0-9]+ "
+ + "bytes\\)\\s+\\(intrinsic[,\\)]";
+ public static final String USE_AES = "UseAES";
+ public static final String USE_AES_INTRINSICS = "UseAESIntrinsics";
+ public static final String USE_SSE = "UseSSE";
+ public static final String USE_VIS = "UseVIS";
+ public static final String[] TEST_AES_CMD
+ = {"-XX:+IgnoreUnrecognizedVMOptions", "-XX:+PrintFlagsFinal",
+ "-Xbatch","-XX:+UnlockDiagnosticVMOptions",
+ "-XX:+PrintIntrinsics", "-DcheckOutput=true", "-Dmode=CBC",
+ "TestAESMain"};
+
+ protected AESIntrinsicsBase(BooleanSupplier predicate) {
+ super(predicate);
+ }
+
+ /**
+ * Prepares command for TestAESMain execution.
+ * @param args flags that must be added to command
+ * @return command for TestAESMain execution
+ */
+ public static String[] prepareArguments(String... args) {
+ String[] command = Arrays.copyOf(args, TEST_AES_CMD.length
+ + args.length);
+ System.arraycopy(TEST_AES_CMD, 0, command, args.length,
+ TEST_AES_CMD.length);
+ return command;
+ }
+}
diff --git a/hotspot/test/compiler/cpuflags/TestAESIntrinsicsOnSupportedConfig.java b/hotspot/test/compiler/cpuflags/TestAESIntrinsicsOnSupportedConfig.java
new file mode 100644
index 00000000000..638321ae9d4
--- /dev/null
+++ b/hotspot/test/compiler/cpuflags/TestAESIntrinsicsOnSupportedConfig.java
@@ -0,0 +1,255 @@
+/*
+ * 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.
+ *
+ */
+import jdk.test.lib.OutputAnalyzer;
+import jdk.test.lib.Platform;
+import jdk.test.lib.ProcessTools;
+
+/*
+ * @test
+ * @library /testlibrary /../../test/lib /compiler/whitebox
+ * /compiler/testlibrary /compiler/codegen/7184394
+ * @modules java.base/sun.misc
+ * java.management
+ * @ignore 8146128
+ * @build TestAESIntrinsicsOnSupportedConfig TestAESMain
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch
+ * TestAESIntrinsicsOnSupportedConfig
+ */
+public class TestAESIntrinsicsOnSupportedConfig extends AESIntrinsicsBase {
+
+ /**
+ * Constructs new TestAESIntrinsicsOnSupportedConfig that will be executed
+ * only if AESSupportPredicate returns true
+ */
+ private TestAESIntrinsicsOnSupportedConfig() {
+ super(AESIntrinsicsBase.AES_SUPPORTED_PREDICATE);
+ }
+
+ @Override
+ protected void runTestCases() throws Throwable {
+ testUseAES();
+ testUseAESUseSSE2();
+ testUseAESUseVIS2();
+ testNoUseAES();
+ testNoUseAESUseSSE2();
+ testNoUseAESUseVIS2();
+ testNoUseAESIntrinsic();
+ }
+
+ /**
+ * Test checks following situation:
-
-
+import sun.hotspot.cpuinfo.CPUInfo;
+import java.util.function.BooleanSupplier;
-bug 6176814
+public class AESSupportPredicate implements BooleanSupplier {
- This is an AUTOMATIC test, simply wait for completion
+ private static final String AES = "aes";
-