--- a/hotspot/agent/src/os/linux/LinuxDebuggerLocal.c Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/agent/src/os/linux/LinuxDebuggerLocal.c Wed Sep 10 17:06:36 2014 -0700
@@ -64,7 +64,10 @@
#define THROW_NEW_DEBUGGER_EXCEPTION(str) { throw_new_debugger_exception(env, str); return;}
void throw_new_debugger_exception(JNIEnv* env, const char* errMsg) {
- (*env)->ThrowNew(env, (*env)->FindClass(env, "sun/jvm/hotspot/debugger/DebuggerException"), errMsg);
+ jclass clazz;
+ clazz = (*env)->FindClass(env, "sun/jvm/hotspot/debugger/DebuggerException");
+ CHECK_EXCEPTION;
+ (*env)->ThrowNew(env, clazz, errMsg);
}
struct ps_prochandle* get_proc_handle(JNIEnv* env, jobject this_obj) {
@@ -149,11 +152,14 @@
const char* name;
jobject loadObject;
jobject loadObjectList;
+ jstring str;
base = get_lib_base(ph, i);
name = get_lib_name(ph, i);
- loadObject = (*env)->CallObjectMethod(env, this_obj, createLoadObject_ID,
- (*env)->NewStringUTF(env, name), (jlong)0, (jlong)base);
+
+ str = (*env)->NewStringUTF(env, name);
+ CHECK_EXCEPTION;
+ loadObject = (*env)->CallObjectMethod(env, this_obj, createLoadObject_ID, str, (jlong)0, (jlong)base);
CHECK_EXCEPTION;
loadObjectList = (*env)->GetObjectField(env, this_obj, loadObjectList_ID);
CHECK_EXCEPTION;
@@ -298,13 +304,18 @@
JNIEXPORT jobject JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_lookupByAddress0
(JNIEnv *env, jobject this_obj, jlong addr) {
uintptr_t offset;
+ jobject obj;
+ jstring str;
const char* sym = NULL;
struct ps_prochandle* ph = get_proc_handle(env, this_obj);
sym = symbol_for_pc(ph, (uintptr_t) addr, &offset);
if (sym == NULL) return 0;
- return (*env)->CallObjectMethod(env, this_obj, createClosestSymbol_ID,
- (*env)->NewStringUTF(env, sym), (jlong)offset);
+ str = (*env)->NewStringUTF(env, sym);
+ CHECK_EXCEPTION_(NULL);
+ obj = (*env)->CallObjectMethod(env, this_obj, createClosestSymbol_ID, str, (jlong)offset);
+ CHECK_EXCEPTION_(NULL);
+ return obj;
}
/*
--- a/hotspot/agent/src/os/solaris/proc/saproc.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/agent/src/os/solaris/proc/saproc.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -90,7 +90,9 @@
*/
static void throwNewDebuggerException(JNIEnv* env, const char* errMsg) {
- env->ThrowNew(env->FindClass("sun/jvm/hotspot/debugger/DebuggerException"), errMsg);
+ jclass clazz = env->FindClass("sun/jvm/hotspot/debugger/DebuggerException");
+ CHECK_EXCEPTION;
+ env->ThrowNew(clazz, errMsg);
}
// JNI ids for some fields, methods
@@ -962,6 +964,7 @@
CHECK_EXCEPTION_(0);
jboolean isCopy;
jlong* ptr = env->GetLongArrayElements(res, &isCopy);
+ CHECK_EXCEPTION_(NULL);
for (int i = 0; i < NPRGREG; i++) {
ptr[i] = (jlong) (uintptr_t) gregs[i];
}
@@ -1253,6 +1256,7 @@
(JNIEnv *env, jobject this_object, jstring name) {
jboolean isCopy;
const char* ptr = env->GetStringUTFChars(name, &isCopy);
+ CHECK_EXCEPTION_(NULL);
char buf[2*SYMBOL_BUF_SIZE + 1];
jstring res = 0;
if (cplus_demangle((char*) ptr, buf, sizeof(buf)) != DEMANGLE_ESPACE) {
@@ -1439,7 +1443,9 @@
"createClosestSymbol", "(Ljava/lang/String;J)Lsun/jvm/hotspot/debugger/cdbg/ClosestSymbol;");
CHECK_EXCEPTION;
- listAdd_ID = env->GetMethodID(env->FindClass("java/util/List"), "add", "(Ljava/lang/Object;)Z");
+ jclass list_clazz = env->FindClass("java/util/List");
+ CHECK_EXCEPTION;
+ listAdd_ID = env->GetMethodID(list_clazz, "add", "(Ljava/lang/Object;)Z");
CHECK_EXCEPTION;
// part of the class sharing workaround
--- a/hotspot/agent/src/os/win32/windbg/sawindbg.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/agent/src/os/win32/windbg/sawindbg.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -112,7 +112,9 @@
return;}
static void throwNewDebuggerException(JNIEnv* env, const char* errMsg) {
- env->ThrowNew(env->FindClass("sun/jvm/hotspot/debugger/DebuggerException"), errMsg);
+ jclass clazz = env->FindClass("sun/jvm/hotspot/debugger/DebuggerException");
+ CHECK_EXCEPTION;
+ env->ThrowNew(clazz, errMsg);
}
/*
@@ -310,15 +312,18 @@
static bool setImageAndSymbolPath(JNIEnv* env, jobject obj) {
jboolean isCopy;
jclass clazz = env->GetObjectClass(obj);
+ CHECK_EXCEPTION_(false);
jstring path;
const char* buf;
path = (jstring) env->GetStaticObjectField(clazz, imagePath_ID);
+ CHECK_EXCEPTION_(false);
buf = env->GetStringUTFChars(path, &isCopy);
CHECK_EXCEPTION_(false);
AutoJavaString imagePath(env, path, buf);
path = (jstring) env->GetStaticObjectField(clazz, symbolPath_ID);
+ CHECK_EXCEPTION_(false);
buf = env->GetStringUTFChars(path, &isCopy);
CHECK_EXCEPTION_(false);
AutoJavaString symbolPath(env, path, buf);
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayKlass.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayKlass.java Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -49,7 +49,6 @@
higherDimension = new MetadataField(type.getAddressField("_higher_dimension"), 0);
lowerDimension = new MetadataField(type.getAddressField("_lower_dimension"), 0);
vtableLen = new CIntField(type.getCIntegerField("_vtable_len"), 0);
- componentMirror = new OopField(type.getOopField("_component_mirror"), 0);
javaLangCloneableName = null;
javaLangObjectName = null;
javaIoSerializableName = null;
@@ -63,7 +62,6 @@
private static MetadataField higherDimension;
private static MetadataField lowerDimension;
private static CIntField vtableLen;
- private static OopField componentMirror;
public Klass getJavaSuper() {
SystemDictionary sysDict = VM.getVM().getSystemDictionary();
@@ -74,7 +72,6 @@
public Klass getHigherDimension() { return (Klass) higherDimension.getValue(this); }
public Klass getLowerDimension() { return (Klass) lowerDimension.getValue(this); }
public long getVtableLen() { return vtableLen.getValue(this); }
- public Oop getComponentMirror() { return componentMirror.getValue(this); }
// constant class names - javaLangCloneable, javaIoSerializable, javaLangObject
// Initialized lazily to avoid initialization ordering dependencies between ArrayKlass and SymbolTable
@@ -144,6 +141,5 @@
visitor.doMetadata(higherDimension, true);
visitor.doMetadata(lowerDimension, true);
visitor.doCInt(vtableLen, true);
- visitor.doOop(componentMirror, true);
}
}
--- a/hotspot/make/Makefile Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/Makefile Wed Sep 10 17:06:36 2014 -0700
@@ -337,7 +337,7 @@
export_product_jdk::
$(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR) generic_export
export_optimized_jdk::
- $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR) generic_export
+ $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR)/$(@:export_%_jdk=%) generic_export
export_fastdebug_jdk::
$(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR)/$(@:export_%_jdk=%) generic_export
export_debug_jdk::
@@ -890,3 +890,5 @@
create_jdk copy_jdk update_jdk test_jdk \
copy_product_jdk copy_fastdebug_jdk copy_debug_jdk \
$(HS_ALT_MAKE)/Makefile.make remove_old_debuginfo
+
+.NOTPARALLEL:
--- a/hotspot/make/aix/Makefile Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/aix/Makefile Wed Sep 10 17:06:36 2014 -0700
@@ -256,36 +256,36 @@
$(SUBDIRS_TIERED): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=tiered
+ +$(BUILDTREE) VARIANT=tiered
$(SUBDIRS_C2): $(BUILDTREE_MAKE)
ifeq ($(FORCE_TIERED),1)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=tiered FORCE_TIERED=1
+ +$(BUILDTREE) VARIANT=tiered FORCE_TIERED=1
else
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=compiler2
+ +$(BUILDTREE) VARIANT=compiler2
endif
$(SUBDIRS_C1): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=compiler1
+ +$(BUILDTREE) VARIANT=compiler1
$(SUBDIRS_CORE): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=core
+ +$(BUILDTREE) VARIANT=core
$(SUBDIRS_ZERO): $(BUILDTREE_MAKE) platform_zero
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=zero VARIANTARCH=$(VARIANTARCH)
+ +$(BUILDTREE) VARIANT=zero VARIANTARCH=$(VARIANTARCH)
$(SUBDIRS_SHARK): $(BUILDTREE_MAKE) platform_zero
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=shark VARIANTARCH=$(VARIANTARCH)
+ +$(BUILDTREE) VARIANT=shark VARIANTARCH=$(VARIANTARCH)
$(SUBDIRS_MINIMAL1): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=minimal1
+ +$(BUILDTREE) VARIANT=minimal1
platform_zero: $(GAMMADIR)/make/$(OSNAME)/platform_zero.in
@@ -379,3 +379,5 @@
.PHONY: all compiler1 compiler2 core zero shark
.PHONY: clean clean_compiler1 clean_compiler2 clean_core clean_zero clean_shark docs clean_docs
.PHONY: checks check_os_version check_j2se_version
+
+.NOTPARALLEL:
--- a/hotspot/make/aix/makefiles/buildtree.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/aix/makefiles/buildtree.make Wed Sep 10 17:06:36 2014 -0700
@@ -173,7 +173,7 @@
# Run make in each subdirectory recursively.
$(SUBMAKE_DIRS): $(SIMPLE_DIRS) FORCE
$(QUIETLY) [ -d $@ ] || { mkdir -p $@; }
- $(QUIETLY) cd $@ && $(BUILDTREE) TARGET=$(@F)
+ +$(QUIETLY) cd $@ && $(BUILDTREE) TARGET=$(@F)
$(QUIETLY) touch $@
$(SIMPLE_DIRS):
@@ -364,3 +364,5 @@
FORCE:
.PHONY: all FORCE
+
+.NOTPARALLEL:
--- a/hotspot/make/aix/makefiles/mapfile-vers-debug Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/aix/makefiles/mapfile-vers-debug Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2002, 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
@@ -125,7 +125,6 @@
JVM_GetClassSignature;
JVM_GetClassSigners;
JVM_GetClassTypeAnnotations;
- JVM_GetComponentType;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
JVM_GetEnclosingMethodInfo;
--- a/hotspot/make/aix/makefiles/mapfile-vers-product Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/aix/makefiles/mapfile-vers-product Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2002, 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
@@ -125,7 +125,6 @@
JVM_GetClassSignature;
JVM_GetClassSigners;
JVM_GetClassTypeAnnotations;
- JVM_GetComponentType;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
JVM_GetEnclosingMethodInfo;
--- a/hotspot/make/aix/makefiles/top.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/aix/makefiles/top.make Wed Sep 10 17:06:36 2014 -0700
@@ -69,7 +69,13 @@
# Wierd argument adjustment for "gnumake -j..."
adjust-mflags = $(GENERATED)/adjust-mflags
-MFLAGS-adjusted = -r `$(adjust-mflags) "$(MFLAGS)" "$(HOTSPOT_BUILD_JOBS)"`
+# If SPEC is set, it's from configure and it's already controlling concurrency
+# for us. Skip setting -j with HOTSPOT_BUILD_JOBS.
+ifeq ($(SPEC), )
+ MFLAGS-adjusted = -r `$(adjust-mflags) "$(MFLAGS)" "$(HOTSPOT_BUILD_JOBS)"`
+else
+ MFLAGS-adjusted = -r $(MFLAGS)
+endif
# default target: update lists, make vm
@@ -116,7 +122,7 @@
@+mv $@+ $@
the_vm: vm_build_preliminaries $(adjust-mflags)
- @$(UpdatePCH)
+ +@$(UpdatePCH)
@$(MAKE) -f vm.make $(MFLAGS-adjusted)
install gamma: the_vm
@@ -125,7 +131,7 @@
# next rules support "make foo.[ois]"
%.o %.i %.s:
- $(UpdatePCH)
+ +$(UpdatePCH)
$(MAKE) -f vm.make $(MFLAGS) $@
#$(MAKE) -f vm.make $@
@@ -142,3 +148,5 @@
.PHONY: default vm_build_preliminaries
.PHONY: lists ad_stuff jvmti_stuff sa_stuff the_vm clean realclean
.PHONY: checks check_os_version install
+
+.NOTPARALLEL:
--- a/hotspot/make/bsd/Makefile Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/bsd/Makefile Wed Sep 10 17:06:36 2014 -0700
@@ -250,36 +250,36 @@
$(SUBDIRS_TIERED): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=tiered
+ +$(BUILDTREE) VARIANT=tiered
$(SUBDIRS_C2): $(BUILDTREE_MAKE)
ifeq ($(FORCE_TIERED),1)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=tiered FORCE_TIERED=1
+ +$(BUILDTREE) VARIANT=tiered FORCE_TIERED=1
else
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=compiler2
+ +$(BUILDTREE) VARIANT=compiler2
endif
$(SUBDIRS_C1): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=compiler1
+ +$(BUILDTREE) VARIANT=compiler1
$(SUBDIRS_CORE): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=core
+ +$(BUILDTREE) VARIANT=core
$(SUBDIRS_ZERO): $(BUILDTREE_MAKE) platform_zero
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=zero VARIANTARCH=$(VARIANTARCH)
+ +$(BUILDTREE) VARIANT=zero VARIANTARCH=$(VARIANTARCH)
$(SUBDIRS_SHARK): $(BUILDTREE_MAKE) platform_zero
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=shark VARIANTARCH=$(VARIANTARCH)
+ +$(BUILDTREE) VARIANT=shark VARIANTARCH=$(VARIANTARCH)
$(SUBDIRS_MINIMAL1): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=minimal1
+ +$(BUILDTREE) VARIANT=minimal1
platform_zero: $(GAMMADIR)/make/$(OSNAME)/platform_zero.in
$(SED) 's/@ZERO_ARCHDEF@/$(ZERO_ARCHDEF)/g;s/@ZERO_LIBARCH@/$(ZERO_LIBARCH)/g;' < $< > $@
@@ -392,3 +392,5 @@
.PHONY: clean clean_compiler1 clean_compiler2 clean_core clean_zero clean_shark docs clean_docs
.PHONY: checks check_os_version check_j2se_version
.PHONY: $(HS_ALT_MAKE)/$(OSNAME)/Makefile.make
+
+.NOTPARALLEL:
--- a/hotspot/make/bsd/makefiles/buildtree.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/bsd/makefiles/buildtree.make Wed Sep 10 17:06:36 2014 -0700
@@ -178,7 +178,7 @@
# Run make in each subdirectory recursively.
$(SUBMAKE_DIRS): $(SIMPLE_DIRS) FORCE
$(QUIETLY) [ -d $@ ] || { mkdir -p $@; }
- $(QUIETLY) cd $@ && $(BUILDTREE) TARGET=$(@F)
+ +$(QUIETLY) cd $@ && $(BUILDTREE) TARGET=$(@F)
$(QUIETLY) touch $@
$(SIMPLE_DIRS):
@@ -378,3 +378,5 @@
FORCE:
.PHONY: all FORCE
+
+.NOTPARALLEL:
--- a/hotspot/make/bsd/makefiles/gcc.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/bsd/makefiles/gcc.make Wed Sep 10 17:06:36 2014 -0700
@@ -325,6 +325,10 @@
else ifeq ($(shell expr $(CC_VER_MAJOR) = 5 \& $(CC_VER_MINOR) = 1), 1)
OPT_CFLAGS/loopTransform.o += $(OPT_CFLAGS/NOOPT)
OPT_CFLAGS/unsafe.o += -O1
+ # Clang 6.0
+ else ifeq ($(shell expr $(CC_VER_MAJOR) = 6 \& $(CC_VER_MINOR) = 0), 1)
+ OPT_CFLAGS/loopTransform.o += $(OPT_CFLAGS/NOOPT)
+ OPT_CFLAGS/unsafe.o += -O1
else
$(error "Update compiler workarounds for Clang $(CC_VER_MAJOR).$(CC_VER_MINOR)")
endif
--- a/hotspot/make/bsd/makefiles/mapfile-vers-darwin-debug Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/bsd/makefiles/mapfile-vers-darwin-debug Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2002, 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
@@ -123,7 +123,6 @@
_JVM_GetClassSignature
_JVM_GetClassSigners
_JVM_GetClassTypeAnnotations
- _JVM_GetComponentType
_JVM_GetDeclaredClasses
_JVM_GetDeclaringClass
_JVM_GetEnclosingMethodInfo
--- a/hotspot/make/bsd/makefiles/mapfile-vers-darwin-product Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/bsd/makefiles/mapfile-vers-darwin-product Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2002, 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
@@ -123,7 +123,6 @@
_JVM_GetClassSignature
_JVM_GetClassSigners
_JVM_GetClassTypeAnnotations
- _JVM_GetComponentType
_JVM_GetDeclaredClasses
_JVM_GetDeclaringClass
_JVM_GetEnclosingMethodInfo
--- a/hotspot/make/bsd/makefiles/mapfile-vers-debug Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/bsd/makefiles/mapfile-vers-debug Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2002, 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
@@ -125,7 +125,6 @@
JVM_GetClassSignature;
JVM_GetClassSigners;
JVM_GetClassTypeAnnotations;
- JVM_GetComponentType;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
JVM_GetEnclosingMethodInfo;
--- a/hotspot/make/bsd/makefiles/mapfile-vers-product Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/bsd/makefiles/mapfile-vers-product Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2002, 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
@@ -125,7 +125,6 @@
JVM_GetClassSignature;
JVM_GetClassSigners;
JVM_GetClassTypeAnnotations;
- JVM_GetComponentType;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
JVM_GetEnclosingMethodInfo;
--- a/hotspot/make/bsd/makefiles/top.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/bsd/makefiles/top.make Wed Sep 10 17:06:36 2014 -0700
@@ -69,7 +69,13 @@
# Wierd argument adjustment for "gnumake -j..."
adjust-mflags = $(GENERATED)/adjust-mflags
-MFLAGS-adjusted = -r `$(adjust-mflags) "$(MFLAGS)" "$(HOTSPOT_BUILD_JOBS)"`
+# If SPEC is set, it's from configure and it's already controlling concurrency
+# for us. Skip setting -j with HOTSPOT_BUILD_JOBS.
+ifeq ($(SPEC), )
+ MFLAGS-adjusted = -r `$(adjust-mflags) "$(MFLAGS)" "$(HOTSPOT_BUILD_JOBS)"`
+else
+ MFLAGS-adjusted = -r $(MFLAGS)
+endif
# default target: update lists, make vm
@@ -125,7 +131,7 @@
@+mv $@+ $@
the_vm: vm_build_preliminaries $(adjust-mflags)
- @$(UpdatePCH)
+ +@$(UpdatePCH)
@$(MAKE) -f vm.make $(MFLAGS-adjusted)
install : the_vm
@@ -134,7 +140,7 @@
# next rules support "make foo.[ois]"
%.o %.i %.s:
- $(UpdatePCH)
+ +$(UpdatePCH)
$(MAKE) -f vm.make $(MFLAGS) $@
#$(MAKE) -f vm.make $@
@@ -151,3 +157,5 @@
.PHONY: default vm_build_preliminaries
.PHONY: lists ad_stuff jvmti_stuff sa_stuff the_vm clean realclean
.PHONY: checks check_os_version install
+
+.NOTPARALLEL:
--- a/hotspot/make/linux/Makefile Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/linux/Makefile Wed Sep 10 17:06:36 2014 -0700
@@ -256,36 +256,36 @@
$(SUBDIRS_TIERED): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=tiered
+ +$(BUILDTREE) VARIANT=tiered
$(SUBDIRS_C2): $(BUILDTREE_MAKE)
ifeq ($(FORCE_TIERED),1)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=tiered FORCE_TIERED=1
+ +$(BUILDTREE) VARIANT=tiered FORCE_TIERED=1
else
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=compiler2
+ +$(BUILDTREE) VARIANT=compiler2
endif
$(SUBDIRS_C1): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=compiler1
+ +$(BUILDTREE) VARIANT=compiler1
$(SUBDIRS_CORE): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=core
+ +$(BUILDTREE) VARIANT=core
$(SUBDIRS_ZERO): $(BUILDTREE_MAKE) platform_zero
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=zero VARIANTARCH=$(VARIANTARCH)
+ +$(BUILDTREE) VARIANT=zero VARIANTARCH=$(VARIANTARCH)
$(SUBDIRS_SHARK): $(BUILDTREE_MAKE) platform_zero
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=shark VARIANTARCH=$(VARIANTARCH)
+ +$(BUILDTREE) VARIANT=shark VARIANTARCH=$(VARIANTARCH)
$(SUBDIRS_MINIMAL1): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=minimal1
+ +$(BUILDTREE) VARIANT=minimal1
platform_zero: $(GAMMADIR)/make/$(OSNAME)/platform_zero.in
@@ -399,3 +399,5 @@
.PHONY: clean clean_compiler1 clean_compiler2 clean_core clean_zero clean_shark docs clean_docs
.PHONY: checks check_os_version check_j2se_version
.PHONY: $(HS_ALT_MAKE)/$(OSNAME)/Makefile.make
+
+.NOTPARALLEL:
--- a/hotspot/make/linux/makefiles/buildtree.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/linux/makefiles/buildtree.make Wed Sep 10 17:06:36 2014 -0700
@@ -172,7 +172,7 @@
# Run make in each subdirectory recursively.
$(SUBMAKE_DIRS): $(SIMPLE_DIRS) FORCE
$(QUIETLY) [ -d $@ ] || { mkdir -p $@; }
- $(QUIETLY) cd $@ && $(BUILDTREE) TARGET=$(@F)
+ +$(QUIETLY) cd $@ && $(BUILDTREE) TARGET=$(@F)
$(QUIETLY) touch $@
$(SIMPLE_DIRS):
@@ -377,3 +377,5 @@
FORCE:
.PHONY: all FORCE
+
+.NOTPARALLEL:
--- a/hotspot/make/linux/makefiles/mapfile-vers-debug Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/linux/makefiles/mapfile-vers-debug Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2002, 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
@@ -125,7 +125,6 @@
JVM_GetClassSignature;
JVM_GetClassSigners;
JVM_GetClassTypeAnnotations;
- JVM_GetComponentType;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
JVM_GetEnclosingMethodInfo;
--- a/hotspot/make/linux/makefiles/mapfile-vers-product Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/linux/makefiles/mapfile-vers-product Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2002, 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
@@ -125,7 +125,6 @@
JVM_GetClassSignature;
JVM_GetClassSigners;
JVM_GetClassTypeAnnotations;
- JVM_GetComponentType;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
JVM_GetEnclosingMethodInfo;
--- a/hotspot/make/linux/makefiles/top.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/linux/makefiles/top.make Wed Sep 10 17:06:36 2014 -0700
@@ -69,7 +69,13 @@
# Wierd argument adjustment for "gnumake -j..."
adjust-mflags = $(GENERATED)/adjust-mflags
-MFLAGS-adjusted = -r `$(adjust-mflags) "$(MFLAGS)" "$(HOTSPOT_BUILD_JOBS)"`
+# If SPEC is set, it's from configure and it's already controlling concurrency
+# for us. Skip setting -j with HOTSPOT_BUILD_JOBS.
+ifeq ($(SPEC), )
+ MFLAGS-adjusted = -r `$(adjust-mflags) "$(MFLAGS)" "$(HOTSPOT_BUILD_JOBS)"`
+else
+ MFLAGS-adjusted = -r $(MFLAGS)
+endif
# default target: update lists, make vm
@@ -119,7 +125,7 @@
@+mv $@+ $@
the_vm: vm_build_preliminaries $(adjust-mflags)
- @$(UpdatePCH)
+ +@$(UpdatePCH)
@$(MAKE) -f vm.make $(MFLAGS-adjusted)
install: the_vm
@@ -128,7 +134,7 @@
# next rules support "make foo.[ois]"
%.o %.i %.s:
- $(UpdatePCH)
+ +$(UpdatePCH)
$(MAKE) -f vm.make $(MFLAGS) $@
#$(MAKE) -f vm.make $@
@@ -145,3 +151,5 @@
.PHONY: default vm_build_preliminaries
.PHONY: lists ad_stuff jvmti_stuff sa_stuff the_vm clean realclean
.PHONY: checks check_os_version install
+
+.NOTPARALLEL:
--- a/hotspot/make/solaris/Makefile Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/solaris/Makefile Wed Sep 10 17:06:36 2014 -0700
@@ -200,24 +200,24 @@
$(SUBDIRS_TIERED): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=tiered
+ +$(BUILDTREE) VARIANT=tiered
$(SUBDIRS_C2): $(BUILDTREE_MAKE)
ifeq ($(FORCE_TIERED),1)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=tiered FORCE_TIERED=1
+ +$(BUILDTREE) VARIANT=tiered FORCE_TIERED=1
else
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=compiler2
+ +$(BUILDTREE) VARIANT=compiler2
endif
$(SUBDIRS_C1): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=compiler1
+ +$(BUILDTREE) VARIANT=compiler1
$(SUBDIRS_CORE): $(BUILDTREE_MAKE)
$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
- $(BUILDTREE) VARIANT=core
+ +$(BUILDTREE) VARIANT=core
# Define INSTALL=y at command line to automatically copy JVM into JAVA_HOME
@@ -292,3 +292,5 @@
.PHONY: all compiler1 compiler2 core
.PHONY: clean clean_compiler1 clean_compiler2 clean_core docs clean_docs
.PHONY: checks check_os_version check_j2se_version
+
+.NOTPARALLEL:
--- a/hotspot/make/solaris/makefiles/buildtree.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/solaris/makefiles/buildtree.make Wed Sep 10 17:06:36 2014 -0700
@@ -165,7 +165,7 @@
# Run make in each subdirectory recursively.
$(SUBMAKE_DIRS): $(SIMPLE_DIRS) FORCE
$(QUIETLY) [ -d $@ ] || { mkdir -p $@; }
- $(QUIETLY) cd $@ && $(BUILDTREE) TARGET=$(@F)
+ +$(QUIETLY) cd $@ && $(BUILDTREE) TARGET=$(@F)
$(QUIETLY) touch $@
$(SIMPLE_DIRS):
@@ -364,3 +364,5 @@
FORCE:
.PHONY: all FORCE
+
+.NOTPARALLEL:
--- a/hotspot/make/solaris/makefiles/mapfile-vers Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/solaris/makefiles/mapfile-vers Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2000, 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
@@ -124,7 +124,6 @@
JVM_GetClassNameUTF;
JVM_GetClassSignature;
JVM_GetClassSigners;
- JVM_GetComponentType;
JVM_GetClassTypeAnnotations;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
--- a/hotspot/make/solaris/makefiles/sparcWorks.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/solaris/makefiles/sparcWorks.make Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1998, 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
@@ -53,9 +53,9 @@
VALIDATED_COMPILER_REVS := 5.8
VALIDATED_CC_COMPILER_REVS := 5.8
else
- # Validated compiler for JDK7 is SS12 update 1 + patches (5.10)
- VALIDATED_COMPILER_REVS := 5.10
- VALIDATED_CC_COMPILER_REVS := 5.10
+ # Validated compiler for JDK9 is SS12.3 (5.12)
+ VALIDATED_COMPILER_REVS := 5.12
+ VALIDATED_CC_COMPILER_REVS := 5.12
endif
# Warning messages about not using the above validated versions
--- a/hotspot/make/solaris/makefiles/top.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/solaris/makefiles/top.make Wed Sep 10 17:06:36 2014 -0700
@@ -62,7 +62,13 @@
# Wierd argument adjustment for "gnumake -j..."
adjust-mflags = $(GENERATED)/adjust-mflags
-MFLAGS-adjusted = -r `$(adjust-mflags) "$(MFLAGS)" "$(HOTSPOT_BUILD_JOBS)"`
+# If SPEC is set, it's from configure and it's already controlling concurrency
+# for us. Skip setting -j with HOTSPOT_BUILD_JOBS.
+ifeq ($(SPEC), )
+ MFLAGS-adjusted = -r `$(adjust-mflags) "$(MFLAGS)" "$(HOTSPOT_BUILD_JOBS)"`
+else
+ MFLAGS-adjusted = -r $(MFLAGS)
+endif
# default target: update lists, make vm
@@ -136,3 +142,5 @@
.PHONY: default vm_build_preliminaries
.PHONY: lists ad_stuff jvmti_stuff trace_stuff sa_stuff the_vm clean realclean
.PHONY: checks check_os_version install
+
+.NOTPARALLEL:
--- a/hotspot/make/windows/makefiles/projectcreator.make Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/make/windows/makefiles/projectcreator.make Wed Sep 10 17:06:36 2014 -0700
@@ -31,12 +31,8 @@
ProjectCreatorSources=\
$(WorkSpace)\src\share\tools\ProjectCreator\ProjectCreator.java \
$(WorkSpace)\src\share\tools\ProjectCreator\FileTreeCreator.java \
- $(WorkSpace)\src\share\tools\ProjectCreator\FileTreeCreatorVC7.java \
$(WorkSpace)\src\share\tools\ProjectCreator\FileTreeCreatorVC10.java \
$(WorkSpace)\src\share\tools\ProjectCreator\WinGammaPlatform.java \
- $(WorkSpace)\src\share\tools\ProjectCreator\WinGammaPlatformVC7.java \
- $(WorkSpace)\src\share\tools\ProjectCreator\WinGammaPlatformVC8.java \
- $(WorkSpace)\src\share\tools\ProjectCreator\WinGammaPlatformVC9.java \
$(WorkSpace)\src\share\tools\ProjectCreator\WinGammaPlatformVC10.java \
$(WorkSpace)\src\share\tools\ProjectCreator\Util.java \
$(WorkSpace)\src\share\tools\ProjectCreator\BuildConfig.java \
--- a/hotspot/src/cpu/x86/vm/assembler_x86.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/cpu/x86/vm/assembler_x86.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -4937,6 +4937,26 @@
emit_arith(0x03, 0xC0, dst, src);
}
+void Assembler::adcxq(Register dst, Register src) {
+ //assert(VM_Version::supports_adx(), "adx instructions not supported");
+ emit_int8((unsigned char)0x66);
+ int encode = prefixq_and_encode(dst->encoding(), src->encoding());
+ emit_int8(0x0F);
+ emit_int8(0x38);
+ emit_int8((unsigned char)0xF6);
+ emit_int8((unsigned char)(0xC0 | encode));
+}
+
+void Assembler::adoxq(Register dst, Register src) {
+ //assert(VM_Version::supports_adx(), "adx instructions not supported");
+ emit_int8((unsigned char)0xF3);
+ int encode = prefixq_and_encode(dst->encoding(), src->encoding());
+ emit_int8(0x0F);
+ emit_int8(0x38);
+ emit_int8((unsigned char)0xF6);
+ emit_int8((unsigned char)(0xC0 | encode));
+}
+
void Assembler::andq(Address dst, int32_t imm32) {
InstructionMark im(this);
prefixq(dst);
@@ -5444,6 +5464,26 @@
emit_int8((unsigned char)(0xC0 | encode));
}
+void Assembler::mulq(Address src) {
+ InstructionMark im(this);
+ prefixq(src);
+ emit_int8((unsigned char)0xF7);
+ emit_operand(rsp, src);
+}
+
+void Assembler::mulq(Register src) {
+ int encode = prefixq_and_encode(src->encoding());
+ emit_int8((unsigned char)0xF7);
+ emit_int8((unsigned char)(0xE0 | encode));
+}
+
+void Assembler::mulxq(Register dst1, Register dst2, Register src) {
+ assert(VM_Version::supports_bmi2(), "bit manipulation instructions not supported");
+ int encode = vex_prefix_and_encode(dst1->encoding(), dst2->encoding(), src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F_38, true, false);
+ emit_int8((unsigned char)0xF6);
+ emit_int8((unsigned char)(0xC0 | encode));
+}
+
void Assembler::negq(Register dst) {
int encode = prefixq_and_encode(dst->encoding());
emit_int8((unsigned char)0xF7);
@@ -5572,6 +5612,28 @@
emit_int8(imm8);
}
}
+
+void Assembler::rorq(Register dst, int imm8) {
+ assert(isShiftCount(imm8 >> 1), "illegal shift count");
+ int encode = prefixq_and_encode(dst->encoding());
+ if (imm8 == 1) {
+ emit_int8((unsigned char)0xD1);
+ emit_int8((unsigned char)(0xC8 | encode));
+ } else {
+ emit_int8((unsigned char)0xC1);
+ emit_int8((unsigned char)(0xc8 | encode));
+ emit_int8(imm8);
+ }
+}
+
+void Assembler::rorxq(Register dst, Register src, int imm8) {
+ assert(VM_Version::supports_bmi2(), "bit manipulation instructions not supported");
+ int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F_3A, true, false);
+ emit_int8((unsigned char)0xF0);
+ emit_int8((unsigned char)(0xC0 | encode));
+ emit_int8(imm8);
+}
+
void Assembler::sarq(Register dst, int imm8) {
assert(isShiftCount(imm8 >> 1), "illegal shift count");
int encode = prefixq_and_encode(dst->encoding());
--- a/hotspot/src/cpu/x86/vm/assembler_x86.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/cpu/x86/vm/assembler_x86.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -888,6 +888,14 @@
void addq(Register dst, Address src);
void addq(Register dst, Register src);
+#ifdef _LP64
+ //Add Unsigned Integers with Carry Flag
+ void adcxq(Register dst, Register src);
+
+ //Add Unsigned Integers with Overflow Flag
+ void adoxq(Register dst, Register src);
+#endif
+
void addr_nop_4();
void addr_nop_5();
void addr_nop_7();
@@ -1204,19 +1212,20 @@
void idivl(Register src);
void divl(Register src); // Unsigned division
+#ifdef _LP64
void idivq(Register src);
+#endif
void imull(Register dst, Register src);
void imull(Register dst, Register src, int value);
void imull(Register dst, Address src);
+#ifdef _LP64
void imulq(Register dst, Register src);
void imulq(Register dst, Register src, int value);
-#ifdef _LP64
void imulq(Register dst, Address src);
#endif
-
// jcc is the generic conditional branch generator to run-
// time routines, jcc is used for branches to labels. jcc
// takes a branch opcode (cc) and a label (L) and generates
@@ -1408,9 +1417,16 @@
void movzwq(Register dst, Register src);
#endif
+ // Unsigned multiply with RAX destination register
void mull(Address src);
void mull(Register src);
+#ifdef _LP64
+ void mulq(Address src);
+ void mulq(Register src);
+ void mulxq(Register dst1, Register dst2, Register src);
+#endif
+
// Multiply Scalar Double-Precision Floating-Point Values
void mulsd(XMMRegister dst, Address src);
void mulsd(XMMRegister dst, XMMRegister src);
@@ -1541,6 +1557,11 @@
void ret(int imm16);
+#ifdef _LP64
+ void rorq(Register dst, int imm8);
+ void rorxq(Register dst, Register src, int imm8);
+#endif
+
void sahf();
void sarl(Register dst, int imm8);
--- a/hotspot/src/cpu/x86/vm/globals_x86.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/cpu/x86/vm/globals_x86.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -176,6 +176,8 @@
"Use count trailing zeros instruction") \
\
product(bool, UseBMI1Instructions, false, \
- "Use BMI instructions")
-
+ "Use BMI1 instructions") \
+ \
+ product(bool, UseBMI2Instructions, false, \
+ "Use BMI2 instructions")
#endif // CPU_X86_VM_GLOBALS_X86_HPP
--- a/hotspot/src/cpu/x86/vm/macroAssembler_x86.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/cpu/x86/vm/macroAssembler_x86.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -7293,6 +7293,467 @@
bind(L_done);
}
+#ifdef _LP64
+/**
+ * Helper for multiply_to_len().
+ */
+void MacroAssembler::add2_with_carry(Register dest_hi, Register dest_lo, Register src1, Register src2) {
+ addq(dest_lo, src1);
+ adcq(dest_hi, 0);
+ addq(dest_lo, src2);
+ adcq(dest_hi, 0);
+}
+
+/**
+ * Multiply 64 bit by 64 bit first loop.
+ */
+void MacroAssembler::multiply_64_x_64_loop(Register x, Register xstart, Register x_xstart,
+ Register y, Register y_idx, Register z,
+ Register carry, Register product,
+ Register idx, Register kdx) {
+ //
+ // jlong carry, x[], y[], z[];
+ // for (int idx=ystart, kdx=ystart+1+xstart; idx >= 0; idx-, kdx--) {
+ // huge_128 product = y[idx] * x[xstart] + carry;
+ // z[kdx] = (jlong)product;
+ // carry = (jlong)(product >>> 64);
+ // }
+ // z[xstart] = carry;
+ //
+
+ Label L_first_loop, L_first_loop_exit;
+ Label L_one_x, L_one_y, L_multiply;
+
+ decrementl(xstart);
+ jcc(Assembler::negative, L_one_x);
+
+ movq(x_xstart, Address(x, xstart, Address::times_4, 0));
+ rorq(x_xstart, 32); // convert big-endian to little-endian
+
+ bind(L_first_loop);
+ decrementl(idx);
+ jcc(Assembler::negative, L_first_loop_exit);
+ decrementl(idx);
+ jcc(Assembler::negative, L_one_y);
+ movq(y_idx, Address(y, idx, Address::times_4, 0));
+ rorq(y_idx, 32); // convert big-endian to little-endian
+ bind(L_multiply);
+ movq(product, x_xstart);
+ mulq(y_idx); // product(rax) * y_idx -> rdx:rax
+ addq(product, carry);
+ adcq(rdx, 0);
+ subl(kdx, 2);
+ movl(Address(z, kdx, Address::times_4, 4), product);
+ shrq(product, 32);
+ movl(Address(z, kdx, Address::times_4, 0), product);
+ movq(carry, rdx);
+ jmp(L_first_loop);
+
+ bind(L_one_y);
+ movl(y_idx, Address(y, 0));
+ jmp(L_multiply);
+
+ bind(L_one_x);
+ movl(x_xstart, Address(x, 0));
+ jmp(L_first_loop);
+
+ bind(L_first_loop_exit);
+}
+
+/**
+ * Multiply 64 bit by 64 bit and add 128 bit.
+ */
+void MacroAssembler::multiply_add_128_x_128(Register x_xstart, Register y, Register z,
+ Register yz_idx, Register idx,
+ Register carry, Register product, int offset) {
+ // huge_128 product = (y[idx] * x_xstart) + z[kdx] + carry;
+ // z[kdx] = (jlong)product;
+
+ movq(yz_idx, Address(y, idx, Address::times_4, offset));
+ rorq(yz_idx, 32); // convert big-endian to little-endian
+ movq(product, x_xstart);
+ mulq(yz_idx); // product(rax) * yz_idx -> rdx:product(rax)
+ movq(yz_idx, Address(z, idx, Address::times_4, offset));
+ rorq(yz_idx, 32); // convert big-endian to little-endian
+
+ add2_with_carry(rdx, product, carry, yz_idx);
+
+ movl(Address(z, idx, Address::times_4, offset+4), product);
+ shrq(product, 32);
+ movl(Address(z, idx, Address::times_4, offset), product);
+
+}
+
+/**
+ * Multiply 128 bit by 128 bit. Unrolled inner loop.
+ */
+void MacroAssembler::multiply_128_x_128_loop(Register x_xstart, Register y, Register z,
+ Register yz_idx, Register idx, Register jdx,
+ Register carry, Register product,
+ Register carry2) {
+ // jlong carry, x[], y[], z[];
+ // int kdx = ystart+1;
+ // for (int idx=ystart-2; idx >= 0; idx -= 2) { // Third loop
+ // huge_128 product = (y[idx+1] * x_xstart) + z[kdx+idx+1] + carry;
+ // z[kdx+idx+1] = (jlong)product;
+ // jlong carry2 = (jlong)(product >>> 64);
+ // product = (y[idx] * x_xstart) + z[kdx+idx] + carry2;
+ // z[kdx+idx] = (jlong)product;
+ // carry = (jlong)(product >>> 64);
+ // }
+ // idx += 2;
+ // if (idx > 0) {
+ // product = (y[idx] * x_xstart) + z[kdx+idx] + carry;
+ // z[kdx+idx] = (jlong)product;
+ // carry = (jlong)(product >>> 64);
+ // }
+ //
+
+ Label L_third_loop, L_third_loop_exit, L_post_third_loop_done;
+
+ movl(jdx, idx);
+ andl(jdx, 0xFFFFFFFC);
+ shrl(jdx, 2);
+
+ bind(L_third_loop);
+ subl(jdx, 1);
+ jcc(Assembler::negative, L_third_loop_exit);
+ subl(idx, 4);
+
+ multiply_add_128_x_128(x_xstart, y, z, yz_idx, idx, carry, product, 8);
+ movq(carry2, rdx);
+
+ multiply_add_128_x_128(x_xstart, y, z, yz_idx, idx, carry2, product, 0);
+ movq(carry, rdx);
+ jmp(L_third_loop);
+
+ bind (L_third_loop_exit);
+
+ andl (idx, 0x3);
+ jcc(Assembler::zero, L_post_third_loop_done);
+
+ Label L_check_1;
+ subl(idx, 2);
+ jcc(Assembler::negative, L_check_1);
+
+ multiply_add_128_x_128(x_xstart, y, z, yz_idx, idx, carry, product, 0);
+ movq(carry, rdx);
+
+ bind (L_check_1);
+ addl (idx, 0x2);
+ andl (idx, 0x1);
+ subl(idx, 1);
+ jcc(Assembler::negative, L_post_third_loop_done);
+
+ movl(yz_idx, Address(y, idx, Address::times_4, 0));
+ movq(product, x_xstart);
+ mulq(yz_idx); // product(rax) * yz_idx -> rdx:product(rax)
+ movl(yz_idx, Address(z, idx, Address::times_4, 0));
+
+ add2_with_carry(rdx, product, yz_idx, carry);
+
+ movl(Address(z, idx, Address::times_4, 0), product);
+ shrq(product, 32);
+
+ shlq(rdx, 32);
+ orq(product, rdx);
+ movq(carry, product);
+
+ bind(L_post_third_loop_done);
+}
+
+/**
+ * Multiply 128 bit by 128 bit using BMI2. Unrolled inner loop.
+ *
+ */
+void MacroAssembler::multiply_128_x_128_bmi2_loop(Register y, Register z,
+ Register carry, Register carry2,
+ Register idx, Register jdx,
+ Register yz_idx1, Register yz_idx2,
+ Register tmp, Register tmp3, Register tmp4) {
+ assert(UseBMI2Instructions, "should be used only when BMI2 is available");
+
+ // jlong carry, x[], y[], z[];
+ // int kdx = ystart+1;
+ // for (int idx=ystart-2; idx >= 0; idx -= 2) { // Third loop
+ // huge_128 tmp3 = (y[idx+1] * rdx) + z[kdx+idx+1] + carry;
+ // jlong carry2 = (jlong)(tmp3 >>> 64);
+ // huge_128 tmp4 = (y[idx] * rdx) + z[kdx+idx] + carry2;
+ // carry = (jlong)(tmp4 >>> 64);
+ // z[kdx+idx+1] = (jlong)tmp3;
+ // z[kdx+idx] = (jlong)tmp4;
+ // }
+ // idx += 2;
+ // if (idx > 0) {
+ // yz_idx1 = (y[idx] * rdx) + z[kdx+idx] + carry;
+ // z[kdx+idx] = (jlong)yz_idx1;
+ // carry = (jlong)(yz_idx1 >>> 64);
+ // }
+ //
+
+ Label L_third_loop, L_third_loop_exit, L_post_third_loop_done;
+
+ movl(jdx, idx);
+ andl(jdx, 0xFFFFFFFC);
+ shrl(jdx, 2);
+
+ bind(L_third_loop);
+ subl(jdx, 1);
+ jcc(Assembler::negative, L_third_loop_exit);
+ subl(idx, 4);
+
+ movq(yz_idx1, Address(y, idx, Address::times_4, 8));
+ rorxq(yz_idx1, yz_idx1, 32); // convert big-endian to little-endian
+ movq(yz_idx2, Address(y, idx, Address::times_4, 0));
+ rorxq(yz_idx2, yz_idx2, 32);
+
+ mulxq(tmp4, tmp3, yz_idx1); // yz_idx1 * rdx -> tmp4:tmp3
+ mulxq(carry2, tmp, yz_idx2); // yz_idx2 * rdx -> carry2:tmp
+
+ movq(yz_idx1, Address(z, idx, Address::times_4, 8));
+ rorxq(yz_idx1, yz_idx1, 32);
+ movq(yz_idx2, Address(z, idx, Address::times_4, 0));
+ rorxq(yz_idx2, yz_idx2, 32);
+
+ if (VM_Version::supports_adx()) {
+ adcxq(tmp3, carry);
+ adoxq(tmp3, yz_idx1);
+
+ adcxq(tmp4, tmp);
+ adoxq(tmp4, yz_idx2);
+
+ movl(carry, 0); // does not affect flags
+ adcxq(carry2, carry);
+ adoxq(carry2, carry);
+ } else {
+ add2_with_carry(tmp4, tmp3, carry, yz_idx1);
+ add2_with_carry(carry2, tmp4, tmp, yz_idx2);
+ }
+ movq(carry, carry2);
+
+ movl(Address(z, idx, Address::times_4, 12), tmp3);
+ shrq(tmp3, 32);
+ movl(Address(z, idx, Address::times_4, 8), tmp3);
+
+ movl(Address(z, idx, Address::times_4, 4), tmp4);
+ shrq(tmp4, 32);
+ movl(Address(z, idx, Address::times_4, 0), tmp4);
+
+ jmp(L_third_loop);
+
+ bind (L_third_loop_exit);
+
+ andl (idx, 0x3);
+ jcc(Assembler::zero, L_post_third_loop_done);
+
+ Label L_check_1;
+ subl(idx, 2);
+ jcc(Assembler::negative, L_check_1);
+
+ movq(yz_idx1, Address(y, idx, Address::times_4, 0));
+ rorxq(yz_idx1, yz_idx1, 32);
+ mulxq(tmp4, tmp3, yz_idx1); // yz_idx1 * rdx -> tmp4:tmp3
+ movq(yz_idx2, Address(z, idx, Address::times_4, 0));
+ rorxq(yz_idx2, yz_idx2, 32);
+
+ add2_with_carry(tmp4, tmp3, carry, yz_idx2);
+
+ movl(Address(z, idx, Address::times_4, 4), tmp3);
+ shrq(tmp3, 32);
+ movl(Address(z, idx, Address::times_4, 0), tmp3);
+ movq(carry, tmp4);
+
+ bind (L_check_1);
+ addl (idx, 0x2);
+ andl (idx, 0x1);
+ subl(idx, 1);
+ jcc(Assembler::negative, L_post_third_loop_done);
+ movl(tmp4, Address(y, idx, Address::times_4, 0));
+ mulxq(carry2, tmp3, tmp4); // tmp4 * rdx -> carry2:tmp3
+ movl(tmp4, Address(z, idx, Address::times_4, 0));
+
+ add2_with_carry(carry2, tmp3, tmp4, carry);
+
+ movl(Address(z, idx, Address::times_4, 0), tmp3);
+ shrq(tmp3, 32);
+
+ shlq(carry2, 32);
+ orq(tmp3, carry2);
+ movq(carry, tmp3);
+
+ bind(L_post_third_loop_done);
+}
+
+/**
+ * Code for BigInteger::multiplyToLen() instrinsic.
+ *
+ * rdi: x
+ * rax: xlen
+ * rsi: y
+ * rcx: ylen
+ * r8: z
+ * r11: zlen
+ * r12: tmp1
+ * r13: tmp2
+ * r14: tmp3
+ * r15: tmp4
+ * rbx: tmp5
+ *
+ */
+void MacroAssembler::multiply_to_len(Register x, Register xlen, Register y, Register ylen, Register z, Register zlen,
+ Register tmp1, Register tmp2, Register tmp3, Register tmp4, Register tmp5) {
+ ShortBranchVerifier sbv(this);
+ assert_different_registers(x, xlen, y, ylen, z, zlen, tmp1, tmp2, tmp3, tmp4, tmp5, rdx);
+
+ push(tmp1);
+ push(tmp2);
+ push(tmp3);
+ push(tmp4);
+ push(tmp5);
+
+ push(xlen);
+ push(zlen);
+
+ const Register idx = tmp1;
+ const Register kdx = tmp2;
+ const Register xstart = tmp3;
+
+ const Register y_idx = tmp4;
+ const Register carry = tmp5;
+ const Register product = xlen;
+ const Register x_xstart = zlen; // reuse register
+
+ // First Loop.
+ //
+ // final static long LONG_MASK = 0xffffffffL;
+ // int xstart = xlen - 1;
+ // int ystart = ylen - 1;
+ // long carry = 0;
+ // for (int idx=ystart, kdx=ystart+1+xstart; idx >= 0; idx-, kdx--) {
+ // long product = (y[idx] & LONG_MASK) * (x[xstart] & LONG_MASK) + carry;
+ // z[kdx] = (int)product;
+ // carry = product >>> 32;
+ // }
+ // z[xstart] = (int)carry;
+ //
+
+ movl(idx, ylen); // idx = ylen;
+ movl(kdx, zlen); // kdx = xlen+ylen;
+ xorq(carry, carry); // carry = 0;
+
+ Label L_done;
+
+ movl(xstart, xlen);
+ decrementl(xstart);
+ jcc(Assembler::negative, L_done);
+
+ multiply_64_x_64_loop(x, xstart, x_xstart, y, y_idx, z, carry, product, idx, kdx);
+
+ Label L_second_loop;
+ testl(kdx, kdx);
+ jcc(Assembler::zero, L_second_loop);
+
+ Label L_carry;
+ subl(kdx, 1);
+ jcc(Assembler::zero, L_carry);
+
+ movl(Address(z, kdx, Address::times_4, 0), carry);
+ shrq(carry, 32);
+ subl(kdx, 1);
+
+ bind(L_carry);
+ movl(Address(z, kdx, Address::times_4, 0), carry);
+
+ // Second and third (nested) loops.
+ //
+ // for (int i = xstart-1; i >= 0; i--) { // Second loop
+ // carry = 0;
+ // for (int jdx=ystart, k=ystart+1+i; jdx >= 0; jdx--, k--) { // Third loop
+ // long product = (y[jdx] & LONG_MASK) * (x[i] & LONG_MASK) +
+ // (z[k] & LONG_MASK) + carry;
+ // z[k] = (int)product;
+ // carry = product >>> 32;
+ // }
+ // z[i] = (int)carry;
+ // }
+ //
+ // i = xlen, j = tmp1, k = tmp2, carry = tmp5, x[i] = rdx
+
+ const Register jdx = tmp1;
+
+ bind(L_second_loop);
+ xorl(carry, carry); // carry = 0;
+ movl(jdx, ylen); // j = ystart+1
+
+ subl(xstart, 1); // i = xstart-1;
+ jcc(Assembler::negative, L_done);
+
+ push (z);
+
+ Label L_last_x;
+ lea(z, Address(z, xstart, Address::times_4, 4)); // z = z + k - j
+ subl(xstart, 1); // i = xstart-1;
+ jcc(Assembler::negative, L_last_x);
+
+ if (UseBMI2Instructions) {
+ movq(rdx, Address(x, xstart, Address::times_4, 0));
+ rorxq(rdx, rdx, 32); // convert big-endian to little-endian
+ } else {
+ movq(x_xstart, Address(x, xstart, Address::times_4, 0));
+ rorq(x_xstart, 32); // convert big-endian to little-endian
+ }
+
+ Label L_third_loop_prologue;
+ bind(L_third_loop_prologue);
+
+ push (x);
+ push (xstart);
+ push (ylen);
+
+
+ if (UseBMI2Instructions) {
+ multiply_128_x_128_bmi2_loop(y, z, carry, x, jdx, ylen, product, tmp2, x_xstart, tmp3, tmp4);
+ } else { // !UseBMI2Instructions
+ multiply_128_x_128_loop(x_xstart, y, z, y_idx, jdx, ylen, carry, product, x);
+ }
+
+ pop(ylen);
+ pop(xlen);
+ pop(x);
+ pop(z);
+
+ movl(tmp3, xlen);
+ addl(tmp3, 1);
+ movl(Address(z, tmp3, Address::times_4, 0), carry);
+ subl(tmp3, 1);
+ jccb(Assembler::negative, L_done);
+
+ shrq(carry, 32);
+ movl(Address(z, tmp3, Address::times_4, 0), carry);
+ jmp(L_second_loop);
+
+ // Next infrequent code is moved outside loops.
+ bind(L_last_x);
+ if (UseBMI2Instructions) {
+ movl(rdx, Address(x, 0));
+ } else {
+ movl(x_xstart, Address(x, 0));
+ }
+ jmp(L_third_loop_prologue);
+
+ bind(L_done);
+
+ pop(zlen);
+ pop(xlen);
+
+ pop(tmp5);
+ pop(tmp4);
+ pop(tmp3);
+ pop(tmp2);
+ pop(tmp1);
+}
+#endif
+
/**
* Emits code to update CRC-32 with a byte value according to constants in table
*
--- a/hotspot/src/cpu/x86/vm/macroAssembler_x86.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/cpu/x86/vm/macroAssembler_x86.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -1221,6 +1221,28 @@
XMMRegister tmp1, XMMRegister tmp2, XMMRegister tmp3,
XMMRegister tmp4, Register tmp5, Register result);
+#ifdef _LP64
+ void add2_with_carry(Register dest_hi, Register dest_lo, Register src1, Register src2);
+ void multiply_64_x_64_loop(Register x, Register xstart, Register x_xstart,
+ Register y, Register y_idx, Register z,
+ Register carry, Register product,
+ Register idx, Register kdx);
+ void multiply_add_128_x_128(Register x_xstart, Register y, Register z,
+ Register yz_idx, Register idx,
+ Register carry, Register product, int offset);
+ void multiply_128_x_128_bmi2_loop(Register y, Register z,
+ Register carry, Register carry2,
+ Register idx, Register jdx,
+ Register yz_idx1, Register yz_idx2,
+ Register tmp, Register tmp3, Register tmp4);
+ void multiply_128_x_128_loop(Register x_xstart, Register y, Register z,
+ Register yz_idx, Register idx, Register jdx,
+ Register carry, Register product,
+ Register carry2);
+ void multiply_to_len(Register x, Register xlen, Register y, Register ylen, Register z, Register zlen,
+ Register tmp1, Register tmp2, Register tmp3, Register tmp4, Register tmp5);
+#endif
+
// CRC32 code for java.util.zip.CRC32::updateBytes() instrinsic.
void update_byte_crc32(Register crc, Register val, Register table);
void kernel_crc32(Register crc, Register buf, Register len, Register table, Register tmp);
--- a/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -3677,6 +3677,70 @@
return start;
}
+
+ /**
+ * Arguments:
+ *
+ * Input:
+ * c_rarg0 - x address
+ * c_rarg1 - x length
+ * c_rarg2 - y address
+ * c_rarg3 - y lenth
+ * not Win64
+ * c_rarg4 - z address
+ * c_rarg5 - z length
+ * Win64
+ * rsp+40 - z address
+ * rsp+48 - z length
+ */
+ address generate_multiplyToLen() {
+ __ align(CodeEntryAlignment);
+ StubCodeMark mark(this, "StubRoutines", "multiplyToLen");
+
+ address start = __ pc();
+ // Win64: rcx, rdx, r8, r9 (c_rarg0, c_rarg1, ...)
+ // Unix: rdi, rsi, rdx, rcx, r8, r9 (c_rarg0, c_rarg1, ...)
+ const Register x = rdi;
+ const Register xlen = rax;
+ const Register y = rsi;
+ const Register ylen = rcx;
+ const Register z = r8;
+ const Register zlen = r11;
+
+ // Next registers will be saved on stack in multiply_to_len().
+ const Register tmp1 = r12;
+ const Register tmp2 = r13;
+ const Register tmp3 = r14;
+ const Register tmp4 = r15;
+ const Register tmp5 = rbx;
+
+ BLOCK_COMMENT("Entry:");
+ __ enter(); // required for proper stackwalking of RuntimeStub frame
+
+#ifndef _WIN64
+ __ movptr(zlen, r9); // Save r9 in r11 - zlen
+#endif
+ setup_arg_regs(4); // x => rdi, xlen => rsi, y => rdx
+ // ylen => rcx, z => r8, zlen => r11
+ // r9 and r10 may be used to save non-volatile registers
+#ifdef _WIN64
+ // last 2 arguments (#4, #5) are on stack on Win64
+ __ movptr(z, Address(rsp, 6 * wordSize));
+ __ movptr(zlen, Address(rsp, 7 * wordSize));
+#endif
+
+ __ movptr(xlen, rsi);
+ __ movptr(y, rdx);
+ __ multiply_to_len(x, xlen, y, ylen, z, zlen, tmp1, tmp2, tmp3, tmp4, tmp5);
+
+ restore_arg_regs();
+
+ __ leave(); // required for proper stackwalking of RuntimeStub frame
+ __ ret(0);
+
+ return start;
+ }
+
#undef __
#define __ masm->
@@ -3917,6 +3981,11 @@
generate_safefetch("SafeFetchN", sizeof(intptr_t), &StubRoutines::_safefetchN_entry,
&StubRoutines::_safefetchN_fault_pc,
&StubRoutines::_safefetchN_continuation_pc);
+#ifdef COMPILER2
+ if (UseMultiplyToLenIntrinsic) {
+ StubRoutines::_multiplyToLen = generate_multiplyToLen();
+ }
+#endif
}
public:
--- a/hotspot/src/cpu/x86/vm/vm_version_x86.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/cpu/x86/vm/vm_version_x86.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -485,7 +485,7 @@
}
char buf[256];
- jio_snprintf(buf, sizeof(buf), "(%u cores per cpu, %u threads per core) family %d model %d stepping %d%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
+ jio_snprintf(buf, sizeof(buf), "(%u cores per cpu, %u threads per core) family %d model %d stepping %d%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
cores_per_cpu(), threads_per_core(),
cpu_family(), _model, _stepping,
(supports_cmov() ? ", cmov" : ""),
@@ -514,7 +514,8 @@
(supports_tscinv_bit() ? ", tscinvbit": ""),
(supports_tscinv() ? ", tscinv": ""),
(supports_bmi1() ? ", bmi1" : ""),
- (supports_bmi2() ? ", bmi2" : ""));
+ (supports_bmi2() ? ", bmi2" : ""),
+ (supports_adx() ? ", adx" : ""));
_features_str = os::strdup(buf);
// UseSSE is set to the smaller of what hardware supports and what
@@ -566,7 +567,7 @@
}
} else if (UseCRC32Intrinsics) {
if (!FLAG_IS_DEFAULT(UseCRC32Intrinsics))
- warning("CRC32 Intrinsics requires AVX and CLMUL instructions (not available on this CPU)");
+ warning("CRC32 Intrinsics requires CLMUL instructions (not available on this CPU)");
FLAG_SET_DEFAULT(UseCRC32Intrinsics, false);
}
@@ -689,7 +690,20 @@
}
#endif
}
+
+#ifdef _LP64
+ if (FLAG_IS_DEFAULT(UseMultiplyToLenIntrinsic)) {
+ UseMultiplyToLenIntrinsic = true;
+ }
+#else
+ if (UseMultiplyToLenIntrinsic) {
+ if (!FLAG_IS_DEFAULT(UseMultiplyToLenIntrinsic)) {
+ warning("multiplyToLen intrinsic is not available in 32-bit VM");
+ }
+ FLAG_SET_DEFAULT(UseMultiplyToLenIntrinsic, false);
+ }
#endif
+#endif // COMPILER2
// On new cpus instructions which update whole XMM register should be used
// to prevent partial register stall due to dependencies on high half.
@@ -832,6 +846,9 @@
}
}
}
+ if(FLAG_IS_DEFAULT(AllocatePrefetchInstr) && supports_3dnow_prefetch()) {
+ AllocatePrefetchInstr = 3;
+ }
}
// Use count leading zeros count instruction if available.
@@ -844,23 +861,35 @@
FLAG_SET_DEFAULT(UseCountLeadingZerosInstruction, false);
}
+ // Use count trailing zeros instruction if available
if (supports_bmi1()) {
+ // tzcnt does not require VEX prefix
+ if (FLAG_IS_DEFAULT(UseCountTrailingZerosInstruction)) {
+ UseCountTrailingZerosInstruction = true;
+ }
+ } else if (UseCountTrailingZerosInstruction) {
+ warning("tzcnt instruction is not available on this CPU");
+ FLAG_SET_DEFAULT(UseCountTrailingZerosInstruction, false);
+ }
+
+ // BMI instructions use an encoding with VEX prefix.
+ // VEX prefix is generated only when AVX > 0.
+ if (supports_bmi1() && supports_avx()) {
if (FLAG_IS_DEFAULT(UseBMI1Instructions)) {
UseBMI1Instructions = true;
}
} else if (UseBMI1Instructions) {
- warning("BMI1 instructions are not available on this CPU");
+ warning("BMI1 instructions are not available on this CPU (AVX is also required)");
FLAG_SET_DEFAULT(UseBMI1Instructions, false);
}
- // Use count trailing zeros instruction if available
- if (supports_bmi1()) {
- if (FLAG_IS_DEFAULT(UseCountTrailingZerosInstruction)) {
- UseCountTrailingZerosInstruction = UseBMI1Instructions;
+ if (supports_bmi2() && supports_avx()) {
+ if (FLAG_IS_DEFAULT(UseBMI2Instructions)) {
+ UseBMI2Instructions = true;
}
- } else if (UseCountTrailingZerosInstruction) {
- warning("tzcnt instruction is not available on this CPU");
- FLAG_SET_DEFAULT(UseCountTrailingZerosInstruction, false);
+ } else if (UseBMI2Instructions) {
+ warning("BMI2 instructions are not available on this CPU (AVX is also required)");
+ FLAG_SET_DEFAULT(UseBMI2Instructions, false);
}
// Use population count instruction if available.
--- a/hotspot/src/cpu/x86/vm/vm_version_x86.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/cpu/x86/vm/vm_version_x86.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -209,7 +209,9 @@
erms : 1,
: 1,
rtm : 1,
- : 20;
+ : 7,
+ adx : 1,
+ : 12;
} bits;
};
@@ -260,7 +262,8 @@
CPU_CLMUL = (1 << 21), // carryless multiply for CRC
CPU_BMI1 = (1 << 22),
CPU_BMI2 = (1 << 23),
- CPU_RTM = (1 << 24) // Restricted Transactional Memory instructions
+ CPU_RTM = (1 << 24), // Restricted Transactional Memory instructions
+ CPU_ADX = (1 << 25)
} cpuFeatureFlags;
enum {
@@ -465,10 +468,16 @@
}
// Intel features.
if(is_intel()) {
+ if(_cpuid_info.sef_cpuid7_ebx.bits.adx != 0)
+ result |= CPU_ADX;
if(_cpuid_info.sef_cpuid7_ebx.bits.bmi2 != 0)
result |= CPU_BMI2;
if(_cpuid_info.ext_cpuid1_ecx.bits.lzcnt_intel != 0)
result |= CPU_LZCNT;
+ // for Intel, ecx.bits.misalignsse bit (bit 8) indicates support for prefetchw
+ if (_cpuid_info.ext_cpuid1_ecx.bits.misalignsse != 0) {
+ result |= CPU_3DNOW_PREFETCH;
+ }
}
return result;
@@ -625,6 +634,7 @@
static bool supports_rtm() { return (_cpuFeatures & CPU_RTM) != 0; }
static bool supports_bmi1() { return (_cpuFeatures & CPU_BMI1) != 0; }
static bool supports_bmi2() { return (_cpuFeatures & CPU_BMI2) != 0; }
+ static bool supports_adx() { return (_cpuFeatures & CPU_ADX) != 0; }
// Intel features
static bool is_intel_family_core() { return is_intel() &&
extended_cpu_family() == CPU_FAMILY_INTEL_CORE; }
--- a/hotspot/src/cpu/zero/vm/cppInterpreter_zero.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/cpu/zero/vm/cppInterpreter_zero.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -820,14 +820,10 @@
}
address InterpreterGenerator::generate_native_entry(bool synchronized) {
- assert(synchronized == false, "should be");
-
return generate_entry((address) CppInterpreter::native_entry);
}
address InterpreterGenerator::generate_normal_entry(bool synchronized) {
- assert(synchronized == false, "should be");
-
return generate_entry((address) CppInterpreter::normal_entry);
}
--- a/hotspot/src/os/aix/vm/os_aix.inline.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/aix/vm/os_aix.inline.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -269,4 +269,8 @@
return true;
}
+inline void os::exit(int num) {
+ ::exit(num);
+}
+
#endif // OS_AIX_VM_OS_AIX_INLINE_HPP
--- a/hotspot/src/os/bsd/vm/os_bsd.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/bsd/vm/os_bsd.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -1641,8 +1641,20 @@
return true;
}
+int _print_dll_info_cb(const char * name, address base_address, address top_address, void * param) {
+ outputStream * out = (outputStream *) param;
+ out->print_cr(PTR_FORMAT " \t%s", base_address, name);
+ return 0;
+}
+
void os::print_dll_info(outputStream *st) {
st->print_cr("Dynamic libraries:");
+ if (get_loaded_modules_info(_print_dll_info_cb, (void *)st)) {
+ st->print_cr("Error: Cannot print dynamic libraries.");
+ }
+}
+
+int os::get_loaded_modules_info(os::LoadedModulesCallbackFunc callback, void *param) {
#ifdef RTLD_DI_LINKMAP
Dl_info dli;
void *handle;
@@ -1651,41 +1663,41 @@
if (dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli) == 0 ||
dli.dli_fname == NULL) {
- st->print_cr("Error: Cannot print dynamic libraries.");
- return;
+ return 1;
}
handle = dlopen(dli.dli_fname, RTLD_LAZY);
if (handle == NULL) {
- st->print_cr("Error: Cannot print dynamic libraries.");
- return;
+ return 1;
}
dlinfo(handle, RTLD_DI_LINKMAP, &map);
if (map == NULL) {
- st->print_cr("Error: Cannot print dynamic libraries.");
- return;
+ dlclose(handle);
+ return 1;
}
while (map->l_prev != NULL)
map = map->l_prev;
while (map != NULL) {
- st->print_cr(PTR_FORMAT " \t%s", map->l_addr, map->l_name);
+ // Value for top_address is returned as 0 since we don't have any information about module size
+ if (callback(map->l_name, (address)map->l_addr, (address)0, param)) {
+ dlclose(handle);
+ return 1;
+ }
map = map->l_next;
}
dlclose(handle);
#elif defined(__APPLE__)
- uint32_t count;
- uint32_t i;
-
- count = _dyld_image_count();
- for (i = 1; i < count; i++) {
- const char *name = _dyld_get_image_name(i);
- intptr_t slide = _dyld_get_image_vmaddr_slide(i);
- st->print_cr(PTR_FORMAT " \t%s", slide, name);
+ for (uint32_t i = 1; i < _dyld_image_count(); i++) {
+ // Value for top_address is returned as 0 since we don't have any information about module size
+ if (callback(_dyld_get_image_name(i), (address)_dyld_get_image_header(i), (address)0, param)) {
+ return 1;
+ }
}
+ return 0;
#else
- st->print_cr("Error: Cannot print dynamic libraries.");
+ return 1;
#endif
}
--- a/hotspot/src/os/bsd/vm/os_bsd.inline.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/bsd/vm/os_bsd.inline.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -274,4 +274,8 @@
#endif
}
+inline void os::exit(int num) {
+ ::exit(num);
+}
+
#endif // OS_BSD_VM_OS_BSD_INLINE_HPP
--- a/hotspot/src/os/linux/vm/os_linux.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/linux/vm/os_linux.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -2122,6 +2122,40 @@
}
}
+int os::get_loaded_modules_info(os::LoadedModulesCallbackFunc callback, void *param) {
+ FILE *procmapsFile = NULL;
+
+ // Open the procfs maps file for the current process
+ if ((procmapsFile = fopen("/proc/self/maps", "r")) != NULL) {
+ // Allocate PATH_MAX for file name plus a reasonable size for other fields.
+ char line[PATH_MAX + 100];
+
+ // Read line by line from 'file'
+ while (fgets(line, sizeof(line), procmapsFile) != NULL) {
+ u8 base, top, offset, inode;
+ char permissions[5];
+ char device[6];
+ char name[PATH_MAX + 1];
+
+ // Parse fields from line
+ sscanf(line, "%lx-%lx %4s %lx %5s %ld %s", &base, &top, permissions, &offset, device, &inode, name);
+
+ // Filter by device id '00:00' so that we only get file system mapped files.
+ if (strcmp(device, "00:00") != 0) {
+
+ // Call callback with the fields of interest
+ if(callback(name, (address)base, (address)top, param)) {
+ // Oops abort, callback aborted
+ fclose(procmapsFile);
+ return 1;
+ }
+ }
+ }
+ fclose(procmapsFile);
+ }
+ return 0;
+}
+
void os::print_os_info_brief(outputStream* st) {
os::Linux::print_distro_info(st);
--- a/hotspot/src/os/linux/vm/os_linux.inline.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/linux/vm/os_linux.inline.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -263,4 +263,8 @@
return Linux::_clock_gettime != NULL;
}
+inline void os::exit(int num) {
+ ::exit(num);
+}
+
#endif // OS_LINUX_VM_OS_LINUX_INLINE_HPP
--- a/hotspot/src/os/posix/vm/os_posix.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/posix/vm/os_posix.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -215,6 +215,9 @@
struct utsname name;
uname(&name);
st->print("%s ", name.sysname);
+#ifdef ASSERT
+ st->print("%s ", name.nodename);
+#endif
st->print("%s ", name.release);
st->print("%s ", name.version);
st->print("%s", name.machine);
--- a/hotspot/src/os/solaris/vm/os_solaris.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/solaris/vm/os_solaris.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -1728,41 +1728,54 @@
return false;
}
-// Prints the names and full paths of all opened dynamic libraries
-// for current process
-void os::print_dll_info(outputStream * st) {
+int os::get_loaded_modules_info(os::LoadedModulesCallbackFunc callback, void *param) {
Dl_info dli;
- void *handle;
+ // Sanity check?
+ if (dladdr(CAST_FROM_FN_PTR(void *, os::get_loaded_modules_info), &dli) == 0 ||
+ dli.dli_fname == NULL) {
+ return 1;
+ }
+
+ void * handle = dlopen(dli.dli_fname, RTLD_LAZY);
+ if (handle == NULL) {
+ return 1;
+ }
+
Link_map *map;
- Link_map *p;
-
- st->print_cr("Dynamic libraries:"); st->flush();
-
- if (dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli) == 0 ||
- dli.dli_fname == NULL) {
- st->print_cr("Error: Cannot print dynamic libraries.");
- return;
- }
- handle = dlopen(dli.dli_fname, RTLD_LAZY);
- if (handle == NULL) {
- st->print_cr("Error: Cannot print dynamic libraries.");
- return;
- }
dlinfo(handle, RTLD_DI_LINKMAP, &map);
if (map == NULL) {
- st->print_cr("Error: Cannot print dynamic libraries.");
- return;
- }
-
- while (map->l_prev != NULL)
+ dlclose(handle);
+ return 1;
+ }
+
+ while (map->l_prev != NULL) {
map = map->l_prev;
+ }
while (map != NULL) {
- st->print_cr(PTR_FORMAT " \t%s", map->l_addr, map->l_name);
+ // Iterate through all map entries and call callback with fields of interest
+ if(callback(map->l_name, (address)map->l_addr, (address)0, param)) {
+ dlclose(handle);
+ return 1;
+ }
map = map->l_next;
}
dlclose(handle);
+ return 0;
+}
+
+int _print_dll_info_cb(const char * name, address base_address, address top_address, void * param) {
+ outputStream * out = (outputStream *) param;
+ out->print_cr(PTR_FORMAT " \t%s", base_address, name);
+ return 0;
+}
+
+void os::print_dll_info(outputStream * st) {
+ st->print_cr("Dynamic libraries:"); st->flush();
+ if (get_loaded_modules_info(_print_dll_info_cb, (void *)st)) {
+ st->print_cr("Error: Cannot print dynamic libraries.");
+ }
}
// Loads .dll/.so and
--- a/hotspot/src/os/solaris/vm/os_solaris.inline.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/solaris/vm/os_solaris.inline.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -157,4 +157,8 @@
return true;
}
+inline void os::exit(int num) {
+ ::exit(num);
+}
+
#endif // OS_SOLARIS_VM_OS_SOLARIS_INLINE_HPP
--- a/hotspot/src/os/windows/vm/os_windows.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/windows/vm/os_windows.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -22,8 +22,8 @@
*
*/
-// Must be at least Windows 2000 or XP to use IsDebuggerPresent
-#define _WIN32_WINNT 0x500
+// Must be at least Windows Vista or Server 2008 to use InitOnceExecuteOnce
+#define _WIN32_WINNT 0x0600
// no precompiled headers
#include "classfile/classLoader.hpp"
@@ -414,8 +414,6 @@
LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);
-extern jint volatile vm_getting_terminated;
-
// Thread start routine for all new Java threads
static unsigned __stdcall java_start(Thread* thread) {
// Try to randomize the cache line index of hot stack frames.
@@ -437,13 +435,10 @@
}
}
- // Diagnostic code to investigate JDK-6573254 (Part I)
- unsigned res = 90115; // non-java thread
+ // Diagnostic code to investigate JDK-6573254
+ int res = 90115; // non-java thread
if (thread->is_Java_thread()) {
- JavaThread* java_thread = (JavaThread*)thread;
- res = java_lang_Thread::is_daemon(java_thread->threadObj())
- ? 70115 // java daemon thread
- : 80115; // java non-daemon thread
+ res = 60115; // java thread
}
// Install a win32 structured exception handler around every thread created
@@ -463,12 +458,9 @@
Atomic::dec_ptr((intptr_t*)&os::win32::_os_thread_count);
}
- // Diagnostic code to investigate JDK-6573254 (Part II)
- if (OrderAccess::load_acquire(&vm_getting_terminated)) {
- return res;
- }
-
- return 0;
+ // Thread must not return from exit_process_or_thread(), but if it does,
+ // let it proceed to exit normally
+ return (unsigned)os::win32::exit_process_or_thread(os::win32::EPT_THREAD, res);
}
static OSThread* create_os_thread(Thread* thread, HANDLE thread_handle,
@@ -1074,16 +1066,15 @@
}
-
void os::abort(bool dump_core) {
os::shutdown();
// no core dump on Windows
- ::exit(1);
+ win32::exit_process_or_thread(win32::EPT_PROCESS, 1);
}
// Die immediately, no exit hook, no abort hook, no cleanup.
void os::die() {
- _exit(-1);
+ win32::exit_process_or_thread(win32::EPT_PROCESS_DIE, -1);
}
// Directory routines copied from src/win32/native/java/io/dirent_md.c
@@ -1305,122 +1296,6 @@
}
#endif
-
-// Enumerate all modules for a given process ID
-//
-// Notice that Windows 95/98/Me and Windows NT/2000/XP have
-// different API for doing this. We use PSAPI.DLL on NT based
-// Windows and ToolHelp on 95/98/Me.
-
-// Callback function that is called by enumerate_modules() on
-// every DLL module.
-// Input parameters:
-// int pid,
-// char* module_file_name,
-// address module_base_addr,
-// unsigned module_size,
-// void* param
-typedef int (*EnumModulesCallbackFunc)(int, char *, address, unsigned, void *);
-
-// enumerate_modules for Windows NT, using PSAPI
-static int _enumerate_modules_winnt(int pid, EnumModulesCallbackFunc func,
- void * param) {
- HANDLE hProcess;
-
-#define MAX_NUM_MODULES 128
- HMODULE modules[MAX_NUM_MODULES];
- static char filename[MAX_PATH];
- int result = 0;
-
- if (!os::PSApiDll::PSApiAvailable()) {
- return 0;
- }
-
- hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
- FALSE, pid);
- if (hProcess == NULL) return 0;
-
- DWORD size_needed;
- if (!os::PSApiDll::EnumProcessModules(hProcess, modules,
- sizeof(modules), &size_needed)) {
- CloseHandle(hProcess);
- return 0;
- }
-
- // number of modules that are currently loaded
- int num_modules = size_needed / sizeof(HMODULE);
-
- for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) {
- // Get Full pathname:
- if (!os::PSApiDll::GetModuleFileNameEx(hProcess, modules[i],
- filename, sizeof(filename))) {
- filename[0] = '\0';
- }
-
- MODULEINFO modinfo;
- if (!os::PSApiDll::GetModuleInformation(hProcess, modules[i],
- &modinfo, sizeof(modinfo))) {
- modinfo.lpBaseOfDll = NULL;
- modinfo.SizeOfImage = 0;
- }
-
- // Invoke callback function
- result = func(pid, filename, (address)modinfo.lpBaseOfDll,
- modinfo.SizeOfImage, param);
- if (result) break;
- }
-
- CloseHandle(hProcess);
- return result;
-}
-
-
-// enumerate_modules for Windows 95/98/ME, using TOOLHELP
-static int _enumerate_modules_windows(int pid, EnumModulesCallbackFunc func,
- void *param) {
- HANDLE hSnapShot;
- static MODULEENTRY32 modentry;
- int result = 0;
-
- if (!os::Kernel32Dll::HelpToolsAvailable()) {
- return 0;
- }
-
- // Get a handle to a Toolhelp snapshot of the system
- hSnapShot = os::Kernel32Dll::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
- if (hSnapShot == INVALID_HANDLE_VALUE) {
- return FALSE;
- }
-
- // iterate through all modules
- modentry.dwSize = sizeof(MODULEENTRY32);
- bool not_done = os::Kernel32Dll::Module32First(hSnapShot, &modentry) != 0;
-
- while (not_done) {
- // invoke the callback
- result=func(pid, modentry.szExePath, (address)modentry.modBaseAddr,
- modentry.modBaseSize, param);
- if (result) break;
-
- modentry.dwSize = sizeof(MODULEENTRY32);
- not_done = os::Kernel32Dll::Module32Next(hSnapShot, &modentry) != 0;
- }
-
- CloseHandle(hSnapShot);
- return result;
-}
-
-int enumerate_modules(int pid, EnumModulesCallbackFunc func, void * param) {
- // Get current process ID if caller doesn't provide it.
- if (!pid) pid = os::current_process_id();
-
- if (os::win32::is_nt()) {
- return _enumerate_modules_winnt (pid, func, param);
- } else {
- return _enumerate_modules_windows(pid, func, param);
- }
-}
-
struct _modinfo {
address addr;
char* full_path; // point to a char buffer
@@ -1428,13 +1303,13 @@
address base_addr;
};
-static int _locate_module_by_addr(int pid, char * mod_fname, address base_addr,
- unsigned size, void * param) {
+static int _locate_module_by_addr(const char * mod_fname, address base_addr,
+ address top_address, void * param) {
struct _modinfo *pmod = (struct _modinfo *)param;
if (!pmod) return -1;
- if (base_addr <= pmod->addr &&
- base_addr+size > pmod->addr) {
+ if (base_addr <= pmod->addr &&
+ top_address > pmod->addr) {
// if a buffer is provided, copy path name to the buffer
if (pmod->full_path) {
jio_snprintf(pmod->full_path, pmod->buflen, "%s", mod_fname);
@@ -1459,8 +1334,7 @@
mi.addr = addr;
mi.full_path = buf;
mi.buflen = buflen;
- int pid = os::current_process_id();
- if (enumerate_modules(pid, _locate_module_by_addr, (void *)&mi)) {
+ if (get_loaded_modules_info(_locate_module_by_addr, (void *)&mi)) {
// buf already contains path name
if (offset) *offset = addr - mi.base_addr;
return true;
@@ -1485,14 +1359,14 @@
}
// save the start and end address of jvm.dll into param[0] and param[1]
-static int _locate_jvm_dll(int pid, char* mod_fname, address base_addr,
- unsigned size, void * param) {
+static int _locate_jvm_dll(const char* mod_fname, address base_addr,
+ address top_address, void * param) {
if (!param) return -1;
- if (base_addr <= (address)_locate_jvm_dll &&
- base_addr+size > (address)_locate_jvm_dll) {
+ if (base_addr <= (address)_locate_jvm_dll &&
+ top_address > (address)_locate_jvm_dll) {
((address*)param)[0] = base_addr;
- ((address*)param)[1] = base_addr + size;
+ ((address*)param)[1] = top_address;
return 1;
}
return 0;
@@ -1503,8 +1377,7 @@
// check if addr is inside jvm.dll
bool os::address_is_in_vm(address addr) {
if (!vm_lib_location[0] || !vm_lib_location[1]) {
- int pid = os::current_process_id();
- if (!enumerate_modules(pid, _locate_jvm_dll, (void *)vm_lib_location)) {
+ if (!get_loaded_modules_info(_locate_jvm_dll, (void *)vm_lib_location)) {
assert(false, "Can't find jvm module.");
return false;
}
@@ -1514,14 +1387,13 @@
}
// print module info; param is outputStream*
-static int _print_module(int pid, char* fname, address base,
- unsigned size, void* param) {
+static int _print_module(const char* fname, address base_address,
+ address top_address, void* param) {
if (!param) return -1;
outputStream* st = (outputStream*)param;
- address end_addr = base + size;
- st->print(PTR_FORMAT " - " PTR_FORMAT " \t%s\n", base, end_addr, fname);
+ st->print(PTR_FORMAT " - " PTR_FORMAT " \t%s\n", base_address, top_address, fname);
return 0;
}
@@ -1640,11 +1512,60 @@
return NULL;
}
-
void os::print_dll_info(outputStream *st) {
+ st->print_cr("Dynamic libraries:");
+ get_loaded_modules_info(_print_module, (void *)st);
+}
+
+int os::get_loaded_modules_info(os::LoadedModulesCallbackFunc callback, void *param) {
+ HANDLE hProcess;
+
+# define MAX_NUM_MODULES 128
+ HMODULE modules[MAX_NUM_MODULES];
+ static char filename[MAX_PATH];
+ int result = 0;
+
+ if (!os::PSApiDll::PSApiAvailable()) {
+ return 0;
+ }
+
int pid = os::current_process_id();
- st->print_cr("Dynamic libraries:");
- enumerate_modules(pid, _print_module, (void *)st);
+ hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
+ FALSE, pid);
+ if (hProcess == NULL) return 0;
+
+ DWORD size_needed;
+ if (!os::PSApiDll::EnumProcessModules(hProcess, modules,
+ sizeof(modules), &size_needed)) {
+ CloseHandle(hProcess);
+ return 0;
+ }
+
+ // number of modules that are currently loaded
+ int num_modules = size_needed / sizeof(HMODULE);
+
+ for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) {
+ // Get Full pathname:
+ if (!os::PSApiDll::GetModuleFileNameEx(hProcess, modules[i],
+ filename, sizeof(filename))) {
+ filename[0] = '\0';
+ }
+
+ MODULEINFO modinfo;
+ if (!os::PSApiDll::GetModuleInformation(hProcess, modules[i],
+ &modinfo, sizeof(modinfo))) {
+ modinfo.lpBaseOfDll = NULL;
+ modinfo.SizeOfImage = 0;
+ }
+
+ // Invoke callback function
+ result = callback(filename, (address)modinfo.lpBaseOfDll,
+ (address)((u8)modinfo.lpBaseOfDll + (u8)modinfo.SizeOfImage), param);
+ if (result) break;
+ }
+
+ CloseHandle(hProcess);
+ return result;
}
void os::print_os_info_brief(outputStream* st) {
@@ -1652,8 +1573,17 @@
}
void os::print_os_info(outputStream* st) {
- st->print("OS:");
-
+#ifdef ASSERT
+ char buffer[1024];
+ DWORD size = sizeof(buffer);
+ st->print(" HostName: ");
+ if (GetComputerNameEx(ComputerNameDnsHostname, buffer, &size)) {
+ st->print("%s", buffer);
+ } else {
+ st->print("N/A");
+ }
+#endif
+ st->print(" OS:");
os::win32::print_windows_version(st);
}
@@ -3688,6 +3618,10 @@
bool os::win32::_is_windows_2003 = false;
bool os::win32::_is_windows_server = false;
+// 6573254
+// Currently, the bug is observed across all the supported Windows releases,
+// including the latest one (as of this writing - Windows Server 2012 R2)
+bool os::win32::_has_exit_bug = true;
bool os::win32::_has_performance_count = 0;
void os::win32::initialize_system_info() {
@@ -3785,6 +3719,69 @@
return NULL;
}
+#define MIN_EXIT_MUTEXES 1
+#define MAX_EXIT_MUTEXES 16
+
+struct ExitMutexes {
+ DWORD count;
+ HANDLE handles[MAX_EXIT_MUTEXES];
+};
+
+static BOOL CALLBACK init_muts_call(PINIT_ONCE, PVOID ppmuts, PVOID*) {
+ static ExitMutexes muts;
+
+ muts.count = os::processor_count();
+ if (muts.count < MIN_EXIT_MUTEXES) {
+ muts.count = MIN_EXIT_MUTEXES;
+ } else if (muts.count > MAX_EXIT_MUTEXES) {
+ muts.count = MAX_EXIT_MUTEXES;
+ }
+
+ for (DWORD i = 0; i < muts.count; ++i) {
+ muts.handles[i] = CreateMutex(NULL, FALSE, NULL);
+ if (muts.handles[i] == NULL) {
+ return FALSE;
+ }
+ }
+ *((ExitMutexes**)ppmuts) = &muts;
+ return TRUE;
+}
+
+int os::win32::exit_process_or_thread(Ept what, int exit_code) {
+ if (os::win32::has_exit_bug()) {
+ static INIT_ONCE init_once_muts = INIT_ONCE_STATIC_INIT;
+ static ExitMutexes* pmuts;
+
+ if (!InitOnceExecuteOnce(&init_once_muts, init_muts_call, &pmuts, NULL)) {
+ warning("ExitMutex initialization failed in %s: %d\n", __FILE__, __LINE__);
+ } else if (WaitForMultipleObjects(pmuts->count, pmuts->handles,
+ (what != EPT_THREAD), // exiting process waits for all mutexes
+ INFINITE) == WAIT_FAILED) {
+ warning("ExitMutex acquisition failed in %s: %d\n", __FILE__, __LINE__);
+ }
+ }
+
+ switch (what) {
+ case EPT_THREAD:
+ _endthreadex((unsigned)exit_code);
+ break;
+
+ case EPT_PROCESS:
+ ::exit(exit_code);
+ break;
+
+ case EPT_PROCESS_DIE:
+ _exit(exit_code);
+ break;
+ }
+
+ // should not reach here
+ return exit_code;
+}
+
+#undef MIN_EXIT_MUTEXES
+#undef MAX_EXIT_MUTEXES
+
void os::win32::setmode_streams() {
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
--- a/hotspot/src/os/windows/vm/os_windows.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/windows/vm/os_windows.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -36,6 +36,7 @@
class win32 {
friend class os;
+ friend unsigned __stdcall java_start(class Thread*);
protected:
static int _vm_page_size;
@@ -47,6 +48,7 @@
static bool _is_nt;
static bool _is_windows_2003;
static bool _is_windows_server;
+ static bool _has_exit_bug;
static bool _has_performance_count;
static void print_windows_version(outputStream* st);
@@ -69,8 +71,12 @@
// load dll from Windows system directory or Windows directory
static HINSTANCE load_Windows_dll(const char* name, char *ebuf, int ebuflen);
- private:
- static void initialize_performance_counter();
+ private:
+ enum Ept { EPT_THREAD, EPT_PROCESS, EPT_PROCESS_DIE };
+ // Wrapper around _endthreadex(), exit() and _exit()
+ static int exit_process_or_thread(Ept what, int exit_code);
+
+ static void initialize_performance_counter();
public:
// Generic interface:
@@ -88,6 +94,9 @@
// Tells whether the platform is Windows 2003
static bool is_windows_2003() { return _is_windows_2003; }
+ // Tells whether there can be the race bug during process exit on this platform
+ static bool has_exit_bug() { return _has_exit_bug; }
+
// Returns the byte size of a virtual memory page
static int vm_page_size() { return _vm_page_size; }
--- a/hotspot/src/os/windows/vm/os_windows.inline.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/os/windows/vm/os_windows.inline.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -100,6 +100,10 @@
return win32::_has_performance_count;
}
+inline void os::exit(int num) {
+ win32::exit_process_or_thread(win32::EPT_PROCESS, num);
+}
+
#define CALL_TEST_FUNC_WITH_WRAPPER_IF_NEEDED(f) \
os::win32::call_test_func_with_wrapper(f)
--- a/hotspot/src/share/tools/ProjectCreator/FileTreeCreatorVC7.java Wed Sep 10 11:52:16 2014 -0600
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,156 +0,0 @@
-import static java.nio.file.FileVisitResult.CONTINUE;
-
-import java.io.IOException;
-import java.nio.file.FileSystems;
-import java.nio.file.FileVisitResult;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.attribute.BasicFileAttributes;
-import java.util.Stack;
-import java.util.Vector;
-
-public class FileTreeCreatorVC7 extends FileTreeCreator {
-
- public FileTreeCreatorVC7(Path startDir, Vector<BuildConfig> allConfigs, WinGammaPlatform wg) {
- super(startDir, allConfigs, wg);
- }
-
- @Override
- public FileVisitResult visitFile(Path file, BasicFileAttributes attr) {
- DirAttributes currentFileAttr = attributes.peek().clone();
- boolean usePch = false;
- boolean disablePch = false;
- boolean useIgnore = false;
- String fileName = file.getFileName().toString();
-
- // usePch applies to all configs for a file.
- if (fileName.equals(BuildConfig.getFieldString(null, "UseToGeneratePch"))) {
- usePch = true;
- }
-
- for (BuildConfig cfg : allConfigs) {
- if (cfg.lookupHashFieldInContext("IgnoreFile", fileName) != null) {
- useIgnore = true;
- currentFileAttr.setIgnore(cfg);
- } else if (cfg.matchesIgnoredPath(file.toAbsolutePath().toString())) {
- useIgnore = true;
- currentFileAttr.setIgnore(cfg);
- }
-
- if (cfg.lookupHashFieldInContext("DisablePch", fileName) != null) {
- disablePch = true;
- currentFileAttr.setDisablePch(cfg);
- }
-
- Vector<String> rv = new Vector<String>();
- cfg.collectRelevantVectors(rv, "AdditionalFile");
- for(String addFile : rv) {
- if (addFile.equals(fileName)) {
- // supress any ignore
- currentFileAttr.removeFromIgnored(cfg);
- }
- }
- }
-
- if (!useIgnore && !disablePch && !usePch) {
- wg.tag("File", new String[] { "RelativePath", vcProjLocation.relativize(file).toString()});
- } else {
- wg.startTag(
- "File",
- new String[] { "RelativePath", vcProjLocation.relativize(file).toString()});
-
- for (BuildConfig cfg : allConfigs) {
- boolean ignore = currentFileAttr.hasIgnore(cfg);
- String [] fileConfAttr;
-
- if (ignore) {
- fileConfAttr = new String[] {"Name", cfg.get("Name"), "ExcludedFromBuild", "TRUE" };
- } else {
- fileConfAttr = new String[] {"Name", cfg.get("Name")};
- }
-
- if (!disablePch && !usePch && !ignore) {
- continue;
- } else if (!disablePch && !usePch) {
- wg.tag("FileConfiguration", fileConfAttr);
- } else {
- wg.startTag("FileConfiguration", fileConfAttr);
- if (usePch) {
- // usePch always applies to all configs, might not always be so.
- wg.tag("Tool", new String[] {
- "Name", "VCCLCompilerTool", "UsePrecompiledHeader",
- "1" });
- assert(!disablePch);
- }
- if (disablePch) {
- if (currentFileAttr.hasDisablePch(cfg)) {
- wg.tag("Tool", new String[] {
- "Name", "VCCLCompilerTool", "UsePrecompiledHeader",
- "0" });
- }
- assert(!usePch);
- }
- wg.endTag();
- }
- }
- wg.endTag();
- }
-
- return CONTINUE;
- }
-
- @Override
- public FileVisitResult preVisitDirectory(Path path, BasicFileAttributes attrs)
- throws IOException {
- Boolean hide = false;
- DirAttributes newAttr = attributes.peek().clone();
-
- String rPath;
- if (path.toAbsolutePath().toString().equals(this.startDir.toAbsolutePath().toString())){
- rPath = startDir.toString();
- } else {
- rPath = path.getFileName().toString();
- }
-
- // check per config ignorePaths!
- for (BuildConfig cfg : allConfigs) {
- if (cfg.matchesIgnoredPath(path.toAbsolutePath().toString())) {
- newAttr.setIgnore(cfg);
- }
-
- // Hide is always on all configs. And additional files are never hiddden
- if (cfg.matchesHidePath(path.toAbsolutePath().toString())) {
- hide = true;
- break;
- }
- }
-
- if (!hide) {
- wg.startTag("Filter", new String[] {
- "Name", rPath});
-
- attributes.push(newAttr);
- return super.preVisitDirectory(path, attrs);
- } else {
- return FileVisitResult.SKIP_SUBTREE;
- }
- }
-
- @Override
- public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
- //end matching attributes set by ignorepath
- wg.endTag();
- attributes.pop();
-
- return CONTINUE;
- }
-
- @Override
- public FileVisitResult visitFileFailed(Path file, IOException exc) {
- return CONTINUE;
- }
-
- public void writeFileTree() throws IOException {
- Files.walkFileTree(this.startDir, this);
- }
- }
\ No newline at end of file
--- a/hotspot/src/share/tools/ProjectCreator/WinGammaPlatformVC10.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/tools/ProjectCreator/WinGammaPlatformVC10.java Wed Sep 10 17:06:36 2014 -0700
@@ -33,7 +33,7 @@
import java.util.UUID;
import java.util.Vector;
-public class WinGammaPlatformVC10 extends WinGammaPlatformVC7 {
+public class WinGammaPlatformVC10 extends WinGammaPlatform {
LinkedList <String>filters = new LinkedList<String>();
--- a/hotspot/src/share/tools/ProjectCreator/WinGammaPlatformVC7.java Wed Sep 10 11:52:16 2014 -0600
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,353 +0,0 @@
-/*
- * Copyright (c) 2005, 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.
- *
- */
-
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.nio.file.FileSystems;
-import java.util.Vector;
-
-public class WinGammaPlatformVC7 extends WinGammaPlatform {
-
- // TODO How about moving all globals configs to its own BuildConfig?
-
- String projectVersion() {
- return "7.10";
- };
-
- public void writeProjectFile(String projectFileName, String projectName,
- Vector<BuildConfig> allConfigs) throws IOException {
- System.out.println();
- System.out.println(" Writing .vcproj file: " + projectFileName);
- // If we got this far without an error, we're safe to actually
- // write the .vcproj file
- printWriter = new PrintWriter(new FileWriter(projectFileName));
-
- printWriter
- .println("<?xml version=\"1.0\" encoding=\"windows-1251\"?>");
- startTag("VisualStudioProject", new String[] { "ProjectType",
- "Visual C++", "Version", projectVersion(), "Name", projectName,
- "ProjectGUID", "{8822CB5C-1C41-41C2-8493-9F6E1994338B}",
- "SccProjectName", "", "SccLocalPath", "" });
- startTag("Platforms");
- tag("Platform",
- new String[] { "Name",
- (String) BuildConfig.getField(null, "PlatformName") });
- endTag();
-
- startTag("Configurations");
-
- for (BuildConfig cfg : allConfigs) {
- writeConfiguration(cfg);
- }
-
- endTag();
-
- tag("References");
-
- writeFiles(allConfigs);
-
- tag("Globals");
-
- endTag();
- printWriter.close();
-
- System.out.println(" Done.");
- }
-
- void writeCustomToolConfig(Vector<BuildConfig> configs, String[] customToolAttrs) {
- for (BuildConfig cfg : configs) {
- startTag("FileConfiguration",
- new String[] { "Name", (String) cfg.get("Name") });
- tag("Tool", customToolAttrs);
-
- endTag();
- }
- }
-
- void writeFiles(Vector<BuildConfig> allConfigs) {
-
- // This code assummes there are no config specific includes.
- startTag("Files");
- String sourceBase = BuildConfig.getFieldString(null, "SourceBase");
-
- // Use first config for all global absolute includes.
- BuildConfig baseConfig = allConfigs.firstElement();
- Vector<String> rv = new Vector<String>();
-
- // Then use first config for all relative includes
- Vector<String> ri = new Vector<String>();
- baseConfig.collectRelevantVectors(ri, "RelativeSrcInclude");
- for (String f : ri) {
- rv.add(sourceBase + Util.sep + f);
- }
-
- baseConfig.collectRelevantVectors(rv, "AbsoluteSrcInclude");
-
- handleIncludes(rv, allConfigs);
-
- startTag("Filter", new String[] { "Name", "Resource Files", "Filter",
- "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe" });
- endTag();
-
- endTag();
- }
-
- // Will visit file tree for each include
- private void handleIncludes(Vector<String> includes, Vector<BuildConfig> allConfigs) {
- for (String path : includes) {
- FileTreeCreatorVC7 ftc = new FileTreeCreatorVC7(FileSystems.getDefault().getPath(path) , allConfigs, this);
- try {
- ftc.writeFileTree();
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- }
-
- void writeConfiguration(BuildConfig cfg) {
- startTag("Configuration", new String[] { "Name", cfg.get("Name"),
- "OutputDirectory", cfg.get("OutputDir"),
- "IntermediateDirectory", cfg.get("OutputDir"),
- "ConfigurationType", "2", "UseOfMFC", "0",
- "ATLMinimizesCRunTimeLibraryUsage", "FALSE" });
-
- tagV("Tool", cfg.getV("CompilerFlags"));
-
- tag("Tool", new String[] { "Name", "VCCustomBuildTool" });
-
- tagV("Tool", cfg.getV("LinkerFlags"));
-
- String postBuildCmd = BuildConfig.getFieldString(null,
- "PostbuildCommand");
- if (postBuildCmd != null) {
- tag("Tool",
- new String[] {
- "Name",
- "VCPostBuildEventTool",
- "Description",
- BuildConfig
- .getFieldString(null, "PostbuildDescription"),
- // Caution: String.replace(String,String) is available
- // from JDK5 onwards only
- "CommandLine",
- cfg.expandFormat(postBuildCmd.replace("\t",
- "
")) });
- }
-
- tag("Tool", new String[] { "Name", "VCPreBuildEventTool" });
-
- tag("Tool",
- new String[] {
- "Name",
- "VCPreLinkEventTool",
- "Description",
- BuildConfig.getFieldString(null, "PrelinkDescription"),
- // Caution: String.replace(String,String) is available
- // from JDK5 onwards only
- "CommandLine",
- cfg.expandFormat(BuildConfig.getFieldString(null,
- "PrelinkCommand").replace("\t", "
")) });
-
- tag("Tool", new String[] { "Name", "VCResourceCompilerTool",
- "PreprocessorDefinitions", "NDEBUG", "Culture", "1033" });
-
- tag("Tool", new String[] { "Name", "VCMIDLTool",
- "PreprocessorDefinitions", "NDEBUG", "MkTypLibCompatible",
- "TRUE", "SuppressStartupBanner", "TRUE", "TargetEnvironment",
- "1", "TypeLibraryName",
- cfg.get("OutputDir") + Util.sep + "vm.tlb", "HeaderFileName",
- "" });
-
- endTag();
- }
-
-
-
- protected String getProjectExt() {
- return ".vcproj";
- }
-}
-
-class CompilerInterfaceVC7 extends CompilerInterface {
- void getBaseCompilerFlags_common(Vector defines, Vector includes,
- String outDir, Vector rv) {
-
- // advanced M$ IDE (2003) can only recognize name if it's first or
- // second attribute in the tag - go guess
- addAttr(rv, "Name", "VCCLCompilerTool");
- addAttr(rv, "AdditionalIncludeDirectories", Util.join(",", includes));
- addAttr(rv, "PreprocessorDefinitions",
- Util.join(";", defines).replace("\"", """));
- addAttr(rv, "PrecompiledHeaderThrough", "precompiled.hpp");
- addAttr(rv, "PrecompiledHeaderFile", outDir + Util.sep + "vm.pch");
- addAttr(rv, "AssemblerListingLocation", outDir);
- addAttr(rv, "ObjectFile", outDir + Util.sep);
- addAttr(rv, "ProgramDataBaseFileName", outDir + Util.sep + "jvm.pdb");
- // Set /nologo optin
- addAttr(rv, "SuppressStartupBanner", "TRUE");
- // Surpass the default /Tc or /Tp. 0 is compileAsDefault
- addAttr(rv, "CompileAs", "0");
- // Set /W3 option. 3 is warningLevel_3
- addAttr(rv, "WarningLevel", "3");
- // Set /WX option,
- addAttr(rv, "WarnAsError", "TRUE");
- // Set /GS option
- addAttr(rv, "BufferSecurityCheck", "FALSE");
- // Set /Zi option. 3 is debugEnabled
- addAttr(rv, "DebugInformationFormat", "3");
- }
-
- Vector getBaseCompilerFlags(Vector defines, Vector includes, String outDir) {
- Vector rv = new Vector();
-
- getBaseCompilerFlags_common(defines, includes, outDir, rv);
- // Set /Yu option. 3 is pchUseUsingSpecific
- // Note: Starting VC8 pchUseUsingSpecific is 2 !!!
- addAttr(rv, "UsePrecompiledHeader", "3");
- // Set /EHsc- option
- addAttr(rv, "ExceptionHandling", "FALSE");
-
- return rv;
- }
-
- Vector getBaseLinkerFlags(String outDir, String outDll, String platformName) {
- Vector rv = new Vector();
-
- addAttr(rv, "Name", "VCLinkerTool");
- addAttr(rv, "AdditionalOptions",
- "/export:JNI_GetDefaultJavaVMInitArgs "
- + "/export:JNI_CreateJavaVM "
- + "/export:JVM_FindClassFromBootLoader "
- + "/export:JNI_GetCreatedJavaVMs "
- + "/export:jio_snprintf /export:jio_printf "
- + "/export:jio_fprintf /export:jio_vfprintf "
- + "/export:jio_vsnprintf "
- + "/export:JVM_GetVersionInfo "
- + "/export:JVM_GetThreadStateNames "
- + "/export:JVM_GetThreadStateValues "
- + "/export:JVM_InitAgentProperties ");
- addAttr(rv, "AdditionalDependencies", "Wsock32.lib winmm.lib");
- addAttr(rv, "OutputFile", outDll);
- // Set /INCREMENTAL option. 1 is linkIncrementalNo
- addAttr(rv, "LinkIncremental", "1");
- addAttr(rv, "SuppressStartupBanner", "TRUE");
- addAttr(rv, "ModuleDefinitionFile", outDir + Util.sep + "vm.def");
- addAttr(rv, "ProgramDatabaseFile", outDir + Util.sep + "jvm.pdb");
- // Set /SUBSYSTEM option. 2 is subSystemWindows
- addAttr(rv, "SubSystem", "2");
- addAttr(rv, "BaseAddress", "0x8000000");
- addAttr(rv, "ImportLibrary", outDir + Util.sep + "jvm.lib");
- if (platformName.equals("Win32")) {
- // Set /MACHINE option. 1 is X86
- addAttr(rv, "TargetMachine", "1");
- } else {
- // Set /MACHINE option. 17 is X64
- addAttr(rv, "TargetMachine", "17");
- }
-
- return rv;
- }
-
- void getDebugCompilerFlags_common(String opt, Vector rv) {
-
- // Set /On option
- addAttr(rv, "Optimization", opt);
- // Set /FR option. 1 is brAllInfo
- addAttr(rv, "BrowseInformation", "1");
- addAttr(rv, "BrowseInformationFile", "$(IntDir)" + Util.sep);
- // Set /MD option. 2 is rtMultiThreadedDLL
- addAttr(rv, "RuntimeLibrary", "2");
- // Set /Oy- option
- addAttr(rv, "OmitFramePointers", "FALSE");
-
- }
-
- Vector getDebugCompilerFlags(String opt, String platformName) {
- Vector rv = new Vector();
-
- getDebugCompilerFlags_common(opt, rv);
-
- return rv;
- }
-
- Vector getDebugLinkerFlags() {
- Vector rv = new Vector();
-
- addAttr(rv, "GenerateDebugInformation", "TRUE"); // == /DEBUG option
-
- return rv;
- }
-
- void getAdditionalNonKernelLinkerFlags(Vector rv) {
- extAttr(rv, "AdditionalOptions", "/export:AsyncGetCallTrace ");
- }
-
- void getProductCompilerFlags_common(Vector rv) {
- // Set /O2 option. 2 is optimizeMaxSpeed
- addAttr(rv, "Optimization", "2");
- // Set /Oy- option
- addAttr(rv, "OmitFramePointers", "FALSE");
- // Set /Ob option. 1 is expandOnlyInline
- addAttr(rv, "InlineFunctionExpansion", "1");
- // Set /GF option.
- addAttr(rv, "StringPooling", "TRUE");
- // Set /MD option. 2 is rtMultiThreadedDLL
- addAttr(rv, "RuntimeLibrary", "2");
- // Set /Gy option
- addAttr(rv, "EnableFunctionLevelLinking", "TRUE");
- }
-
- Vector getProductCompilerFlags() {
- Vector rv = new Vector();
-
- getProductCompilerFlags_common(rv);
-
- return rv;
- }
-
- Vector getProductLinkerFlags() {
- Vector rv = new Vector();
-
- // Set /OPT:REF option. 2 is optReferences
- addAttr(rv, "OptimizeReferences", "2");
- // Set /OPT:optFolding option. 2 is optFolding
- addAttr(rv, "EnableCOMDATFolding", "2");
-
- return rv;
- }
-
- String getOptFlag() {
- return "2";
- }
-
- String getNoOptFlag() {
- return "0";
- }
-
- String makeCfgName(String flavourBuild, String platform) {
- return flavourBuild + "|" + platform;
- }
-
-}
--- a/hotspot/src/share/tools/ProjectCreator/WinGammaPlatformVC8.java Wed Sep 10 11:52:16 2014 -0600
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2005, 2010, 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 java.util.Vector;
-
-public class WinGammaPlatformVC8 extends WinGammaPlatformVC7 {
-
- String projectVersion() {return "8.00";};
-
-}
-
-class CompilerInterfaceVC8 extends CompilerInterfaceVC7 {
-
- Vector getBaseCompilerFlags(Vector defines, Vector includes, String outDir) {
- Vector rv = new Vector();
-
- getBaseCompilerFlags_common(defines,includes, outDir, rv);
- // Set /Yu option. 2 is pchUseUsingSpecific
- addAttr(rv, "UsePrecompiledHeader", "2");
- // Set /EHsc- option. 0 is cppExceptionHandlingNo
- addAttr(rv, "ExceptionHandling", "0");
-
- // enable multi process builds
- extAttr(rv, "AdditionalOptions", "/MP");
-
- return rv;
- }
-
-
- Vector getDebugCompilerFlags(String opt, String platformName) {
- Vector rv = new Vector();
-
- getDebugCompilerFlags_common(opt,rv);
-
- return rv;
- }
-
- Vector getProductCompilerFlags() {
- Vector rv = new Vector();
-
- getProductCompilerFlags_common(rv);
-
- return rv;
- }
-
-
-}
--- a/hotspot/src/share/tools/ProjectCreator/WinGammaPlatformVC9.java Wed Sep 10 11:52:16 2014 -0600
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2005, 2010, 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.
- *
- */
-
-public class WinGammaPlatformVC9 extends WinGammaPlatformVC8 {
-
- String projectVersion() {return "9.00";};
-
-}
-
-class CompilerInterfaceVC9 extends CompilerInterfaceVC8 {
-}
--- a/hotspot/src/share/vm/asm/codeBuffer.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/asm/codeBuffer.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -134,6 +134,10 @@
// free any overflow storage
delete _overflow_arena;
+ // Claim is that stack allocation ensures resources are cleaned up.
+ // This is resource clean up, let's hope that all were properly copied out.
+ free_strings();
+
#ifdef ASSERT
// Save allocation type to execute assert in ~ResourceObj()
// which is called after this destructor.
@@ -705,7 +709,7 @@
relocate_code_to(&dest);
// transfer strings and comments from buffer to blob
- dest_blob->set_strings(_strings);
+ dest_blob->set_strings(_code_strings);
// Done moving code bytes; were they the right size?
assert(round_to(dest.total_content_size(), oopSize) == dest_blob->content_size(), "sanity");
@@ -1005,11 +1009,11 @@
void CodeBuffer::block_comment(intptr_t offset, const char * comment) {
- _strings.add_comment(offset, comment);
+ _code_strings.add_comment(offset, comment);
}
const char* CodeBuffer::code_string(const char* str) {
- return _strings.add_string(str);
+ return _code_strings.add_string(str);
}
class CodeString: public CHeapObj<mtCode> {
@@ -1075,6 +1079,7 @@
}
void CodeStrings::add_comment(intptr_t offset, const char * comment) {
+ check_valid();
CodeString* c = new CodeString(comment, offset);
CodeString* inspos = (_strings == NULL) ? NULL : find_last(offset);
@@ -1090,11 +1095,32 @@
}
void CodeStrings::assign(CodeStrings& other) {
+ other.check_valid();
+ // Cannot do following because CodeStrings constructor is not alway run!
+ assert(is_null(), "Cannot assign onto non-empty CodeStrings");
_strings = other._strings;
+ other.set_null_and_invalidate();
+}
+
+// Deep copy of CodeStrings for consistent memory management.
+// Only used for actual disassembly so this is cheaper than reference counting
+// for the "normal" fastdebug case.
+void CodeStrings::copy(CodeStrings& other) {
+ other.check_valid();
+ check_valid();
+ assert(is_null(), "Cannot copy onto non-empty CodeStrings");
+ CodeString* n = other._strings;
+ CodeString** ps = &_strings;
+ while (n != NULL) {
+ *ps = new CodeString(n->string(),n->offset());
+ ps = &((*ps)->_next);
+ n = n->next();
+ }
}
void CodeStrings::print_block_comment(outputStream* stream, intptr_t offset) const {
- if (_strings != NULL) {
+ check_valid();
+ if (_strings != NULL) {
CodeString* c = find(offset);
while (c && c->offset() == offset) {
stream->bol();
@@ -1105,7 +1131,7 @@
}
}
-
+// Also sets isNull()
void CodeStrings::free() {
CodeString* n = _strings;
while (n) {
@@ -1115,10 +1141,11 @@
delete n;
n = p;
}
- _strings = NULL;
+ set_null_and_invalidate();
}
const char* CodeStrings::add_string(const char * string) {
+ check_valid();
CodeString* s = new CodeString(string);
s->set_next(_strings);
_strings = s;
--- a/hotspot/src/share/vm/asm/codeBuffer.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/asm/codeBuffer.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -27,6 +27,7 @@
#include "code/oopRecorder.hpp"
#include "code/relocInfo.hpp"
+#include "utilities/debug.hpp"
class CodeStrings;
class PhaseCFG;
@@ -245,15 +246,39 @@
private:
#ifndef PRODUCT
CodeString* _strings;
+#ifdef ASSERT
+ // Becomes true after copy-out, forbids further use.
+ bool _defunct; // Zero bit pattern is "valid", see memset call in decode_env::decode_env
+#endif
#endif
CodeString* find(intptr_t offset) const;
CodeString* find_last(intptr_t offset) const;
+ void set_null_and_invalidate() {
+#ifndef PRODUCT
+ _strings = NULL;
+#ifdef ASSERT
+ _defunct = true;
+#endif
+#endif
+ }
+
public:
CodeStrings() {
#ifndef PRODUCT
_strings = NULL;
+#ifdef ASSERT
+ _defunct = false;
+#endif
+#endif
+ }
+
+ bool is_null() {
+#ifdef ASSERT
+ return _strings == NULL;
+#else
+ return true;
#endif
}
@@ -261,8 +286,17 @@
void add_comment(intptr_t offset, const char * comment) PRODUCT_RETURN;
void print_block_comment(outputStream* stream, intptr_t offset) const PRODUCT_RETURN;
+ // MOVE strings from other to this; invalidate other.
void assign(CodeStrings& other) PRODUCT_RETURN;
+ // COPY strings from other to this; leave other valid.
+ void copy(CodeStrings& other) PRODUCT_RETURN;
void free() PRODUCT_RETURN;
+ // Guarantee that _strings are used at most once; assign invalidates a buffer.
+ inline void check_valid() const {
+#ifdef ASSERT
+ assert(!_defunct, "Use of invalid CodeStrings");
+#endif
+ }
};
// A CodeBuffer describes a memory space into which assembly
@@ -330,7 +364,7 @@
csize_t _total_size; // size in bytes of combined memory buffer
OopRecorder* _oop_recorder;
- CodeStrings _strings;
+ CodeStrings _code_strings;
OopRecorder _default_oop_recorder; // override with initialize_oop_recorder
Arena* _overflow_arena;
@@ -531,7 +565,13 @@
void initialize_oop_recorder(OopRecorder* r);
OopRecorder* oop_recorder() const { return _oop_recorder; }
- CodeStrings& strings() { return _strings; }
+ CodeStrings& strings() { return _code_strings; }
+
+ void free_strings() {
+ if (!_code_strings.is_null()) {
+ _code_strings.free(); // sets _strings Null as a side-effect.
+ }
+ }
// Code generation
void relocate(address at, RelocationHolder const& rspec, int format = 0) {
--- a/hotspot/src/share/vm/asm/register.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/asm/register.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -275,4 +275,101 @@
);
}
+inline void assert_different_registers(
+ AbstractRegister a,
+ AbstractRegister b,
+ AbstractRegister c,
+ AbstractRegister d,
+ AbstractRegister e,
+ AbstractRegister f,
+ AbstractRegister g,
+ AbstractRegister h,
+ AbstractRegister i,
+ AbstractRegister j
+) {
+ assert(
+ a != b && a != c && a != d && a != e && a != f && a != g && a != h && a != i && a != j
+ && b != c && b != d && b != e && b != f && b != g && b != h && b != i && b != j
+ && c != d && c != e && c != f && c != g && c != h && c != i && c != j
+ && d != e && d != f && d != g && d != h && d != i && d != j
+ && e != f && e != g && e != h && e != i && e != j
+ && f != g && f != h && f != i && f != j
+ && g != h && g != i && g != j
+ && h != i && h != j
+ && i != j,
+ err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
+ ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
+ ", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT
+ ", i=" INTPTR_FORMAT ", j=" INTPTR_FORMAT "",
+ p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j))
+ );
+}
+
+inline void assert_different_registers(
+ AbstractRegister a,
+ AbstractRegister b,
+ AbstractRegister c,
+ AbstractRegister d,
+ AbstractRegister e,
+ AbstractRegister f,
+ AbstractRegister g,
+ AbstractRegister h,
+ AbstractRegister i,
+ AbstractRegister j,
+ AbstractRegister k
+) {
+ assert(
+ a != b && a != c && a != d && a != e && a != f && a != g && a != h && a != i && a != j && a !=k
+ && b != c && b != d && b != e && b != f && b != g && b != h && b != i && b != j && b !=k
+ && c != d && c != e && c != f && c != g && c != h && c != i && c != j && c !=k
+ && d != e && d != f && d != g && d != h && d != i && d != j && d !=k
+ && e != f && e != g && e != h && e != i && e != j && e !=k
+ && f != g && f != h && f != i && f != j && f !=k
+ && g != h && g != i && g != j && g !=k
+ && h != i && h != j && h !=k
+ && i != j && i !=k
+ && j !=k,
+ err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
+ ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
+ ", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT
+ ", i=" INTPTR_FORMAT ", j=" INTPTR_FORMAT ", k=" INTPTR_FORMAT "",
+ p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j), p2i(k))
+ );
+}
+
+inline void assert_different_registers(
+ AbstractRegister a,
+ AbstractRegister b,
+ AbstractRegister c,
+ AbstractRegister d,
+ AbstractRegister e,
+ AbstractRegister f,
+ AbstractRegister g,
+ AbstractRegister h,
+ AbstractRegister i,
+ AbstractRegister j,
+ AbstractRegister k,
+ AbstractRegister l
+) {
+ assert(
+ a != b && a != c && a != d && a != e && a != f && a != g && a != h && a != i && a != j && a !=k && a !=l
+ && b != c && b != d && b != e && b != f && b != g && b != h && b != i && b != j && b !=k && b !=l
+ && c != d && c != e && c != f && c != g && c != h && c != i && c != j && c !=k && c !=l
+ && d != e && d != f && d != g && d != h && d != i && d != j && d !=k && d !=l
+ && e != f && e != g && e != h && e != i && e != j && e !=k && e !=l
+ && f != g && f != h && f != i && f != j && f !=k && f !=l
+ && g != h && g != i && g != j && g !=k && g !=l
+ && h != i && h != j && h !=k && h !=l
+ && i != j && i !=k && i !=l
+ && j !=k && j !=l
+ && k !=l,
+ err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
+ ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
+ ", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT
+ ", i=" INTPTR_FORMAT ", j=" INTPTR_FORMAT ", k=" INTPTR_FORMAT
+ ", l=" INTPTR_FORMAT "",
+ p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j), p2i(k), p2i(l))
+ );
+}
+
#endif // SHARE_VM_ASM_REGISTER_HPP
--- a/hotspot/src/share/vm/ci/ciArrayKlass.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/ci/ciArrayKlass.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 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
@@ -52,11 +52,6 @@
ciType* base_element_type(); // JLS calls this the "element type"
bool is_leaf_type(); // No subtypes of this array type.
- ciInstance* component_mirror() {
- // This is a real field in ArrayKlass, but we derive it from element_type.
- return element_type()->java_mirror();
- }
-
// What kind of vmObject is this?
bool is_array_klass() const { return true; }
bool is_java_klass() const { return true; }
--- a/hotspot/src/share/vm/ci/ciMethod.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/ci/ciMethod.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -1102,6 +1102,22 @@
}
// ------------------------------------------------------------------
+// ciMethod::has_option_value
+//
+template<typename T>
+bool ciMethod::has_option_value(const char* option, T& value) {
+ check_is_loaded();
+ VM_ENTRY_MARK;
+ methodHandle mh(THREAD, get_Method());
+ return CompilerOracle::has_option_value(mh, option, value);
+}
+// Explicit instantiation for all OptionTypes supported.
+template bool ciMethod::has_option_value<intx>(const char* option, intx& value);
+template bool ciMethod::has_option_value<uintx>(const char* option, uintx& value);
+template bool ciMethod::has_option_value<bool>(const char* option, bool& value);
+template bool ciMethod::has_option_value<ccstr>(const char* option, ccstr& value);
+
+// ------------------------------------------------------------------
// ciMethod::can_be_compiled
//
// Have previous compilations of this method succeeded?
--- a/hotspot/src/share/vm/ci/ciMethod.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/ci/ciMethod.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -269,6 +269,8 @@
bool should_print_assembly();
bool break_at_execute();
bool has_option(const char *option);
+ template<typename T>
+ bool has_option_value(const char* option, T& value);
bool can_be_compiled();
bool can_be_osr_compiled(int entry_bci);
void set_not_compilable(const char* reason = NULL);
--- a/hotspot/src/share/vm/ci/ciMethodData.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/ci/ciMethodData.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -81,19 +81,38 @@
void ciMethodData::load_extra_data() {
MethodData* mdo = get_MethodData();
+ MutexLocker(mdo->extra_data_lock());
+
// speculative trap entries also hold a pointer to a Method so need to be translated
DataLayout* dp_src = mdo->extra_data_base();
- DataLayout* end_src = mdo->extra_data_limit();
+ DataLayout* end_src = mdo->args_data_limit();
DataLayout* dp_dst = extra_data_base();
for (;; dp_src = MethodData::next_extra(dp_src), dp_dst = MethodData::next_extra(dp_dst)) {
assert(dp_src < end_src, "moved past end of extra data");
- // New traps in the MDO can be added as we translate the copy so
- // look at the entries in the copy.
- switch(dp_dst->tag()) {
+ assert(((intptr_t)dp_dst) - ((intptr_t)extra_data_base()) == ((intptr_t)dp_src) - ((intptr_t)mdo->extra_data_base()), "source and destination don't match");
+
+ // New traps in the MDO may have been added since we copied the
+ // data (concurrent deoptimizations before we acquired
+ // extra_data_lock above) or can be removed (a safepoint may occur
+ // in the translate_from call below) as we translate the copy:
+ // update the copy as we go.
+ int tag = dp_src->tag();
+ if (tag != DataLayout::arg_info_data_tag) {
+ memcpy(dp_dst, dp_src, ((intptr_t)MethodData::next_extra(dp_src)) - ((intptr_t)dp_src));
+ }
+
+ switch(tag) {
case DataLayout::speculative_trap_data_tag: {
ciSpeculativeTrapData* data_dst = new ciSpeculativeTrapData(dp_dst);
SpeculativeTrapData* data_src = new SpeculativeTrapData(dp_src);
+
data_dst->translate_from(data_src);
+
+#ifdef ASSERT
+ SpeculativeTrapData* data_src2 = new SpeculativeTrapData(dp_src);
+ assert(data_src2->method() == data_src->method() && data_src2->bci() == data_src->bci(), "entries changed while translating");
+#endif
+
break;
}
case DataLayout::bit_data_tag:
@@ -244,8 +263,8 @@
}
ciProfileData* ciMethodData::bci_to_extra_data(int bci, ciMethod* m, bool& two_free_slots) {
- DataLayout* dp = data_layout_at(data_size());
- DataLayout* end = data_layout_at(data_size() + extra_data_size());
+ DataLayout* dp = extra_data_base();
+ DataLayout* end = args_data_limit();
two_free_slots = false;
for (;dp < end; dp = MethodData::next_extra(dp)) {
switch(dp->tag()) {
@@ -492,8 +511,8 @@
ciArgInfoData *ciMethodData::arg_info() const {
// Should be last, have to skip all traps.
- DataLayout* dp = data_layout_at(data_size());
- DataLayout* end = data_layout_at(data_size() + extra_data_size());
+ DataLayout* dp = extra_data_base();
+ DataLayout* end = args_data_limit();
for (; dp < end; dp = MethodData::next_extra(dp)) {
if (dp->tag() == DataLayout::arg_info_data_tag)
return new ciArgInfoData(dp);
@@ -535,8 +554,8 @@
}
void ciMethodData::dump_replay_data_extra_data_helper(outputStream* out, int round, int& count) {
- DataLayout* dp = data_layout_at(data_size());
- DataLayout* end = data_layout_at(data_size() + extra_data_size());
+ DataLayout* dp = extra_data_base();
+ DataLayout* end = args_data_limit();
for (;dp < end; dp = MethodData::next_extra(dp)) {
switch(dp->tag()) {
@@ -653,8 +672,8 @@
data->print_data_on(st);
}
st->print_cr("--- Extra data:");
- DataLayout* dp = data_layout_at(data_size());
- DataLayout* end = data_layout_at(data_size() + extra_data_size());
+ DataLayout* dp = extra_data_base();
+ DataLayout* end = args_data_limit();
for (;; dp = MethodData::next_extra(dp)) {
assert(dp < end, "moved past end of extra data");
switch (dp->tag()) {
--- a/hotspot/src/share/vm/ci/ciMethodData.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/ci/ciMethodData.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -410,6 +410,9 @@
// Area dedicated to parameters. NULL if no parameter profiling for
// this method.
DataLayout* _parameters;
+ int parameters_size() const {
+ return _parameters == NULL ? 0 : parameters_type_data()->size_in_bytes();
+ }
ciMethodData(MethodData* md);
ciMethodData();
@@ -461,9 +464,6 @@
address data_base() const {
return (address) _data;
}
- DataLayout* limit_data_position() const {
- return (DataLayout*)((address)data_base() + _data_size);
- }
void load_extra_data();
ciProfileData* bci_to_extra_data(int bci, ciMethod* m, bool& two_free_slots);
@@ -524,7 +524,9 @@
ciProfileData* next_data(ciProfileData* current);
bool is_valid(ciProfileData* current) { return current != NULL; }
- DataLayout* extra_data_base() const { return limit_data_position(); }
+ DataLayout* extra_data_base() const { return data_layout_at(data_size()); }
+ DataLayout* args_data_limit() const { return data_layout_at(data_size() + extra_data_size() -
+ parameters_size()); }
// Get the data at an arbitrary bci, or NULL if there is none. If m
// is not NULL look for a SpeculativeTrapData if any first.
--- a/hotspot/src/share/vm/classfile/classFileStream.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/classFileStream.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 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
@@ -30,7 +30,7 @@
THROW_MSG(vmSymbols::java_lang_ClassFormatError(), "Truncated class file");
}
-ClassFileStream::ClassFileStream(u1* buffer, int length, char* source) {
+ClassFileStream::ClassFileStream(u1* buffer, int length, const char* source) {
_buffer_start = buffer;
_buffer_end = buffer + length;
_current = buffer;
--- a/hotspot/src/share/vm/classfile/classFileStream.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/classFileStream.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 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
@@ -39,20 +39,20 @@
u1* _buffer_start; // Buffer bottom
u1* _buffer_end; // Buffer top (one past last element)
u1* _current; // Current buffer position
- char* _source; // Source of stream (directory name, ZIP/JAR archive name)
+ const char* _source; // Source of stream (directory name, ZIP/JAR archive name)
bool _need_verify; // True if verification is on for the class file
void truncated_file_error(TRAPS);
public:
// Constructor
- ClassFileStream(u1* buffer, int length, char* source);
+ ClassFileStream(u1* buffer, int length, const char* source);
// Buffer access
u1* buffer() const { return _buffer_start; }
int length() const { return _buffer_end - _buffer_start; }
u1* current() const { return _current; }
void set_current(u1* pos) { _current = pos; }
- char* source() const { return _source; }
+ const char* source() const { return _source; }
void set_verify(bool flag) { _need_verify = flag; }
void check_truncated_file(bool b, TRAPS) {
--- a/hotspot/src/share/vm/classfile/classLoader.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/classLoader.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -189,9 +189,10 @@
return false;
}
-ClassPathDirEntry::ClassPathDirEntry(char* dir) : ClassPathEntry() {
- _dir = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass);
- strcpy(_dir, dir);
+ClassPathDirEntry::ClassPathDirEntry(const char* dir) : ClassPathEntry() {
+ char* copy = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass);
+ strcpy(copy, dir);
+ _dir = copy;
}
@@ -235,8 +236,9 @@
ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() {
_zip = zip;
- _zip_name = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass);
- strcpy(_zip_name, zip_name);
+ char *copy = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass);
+ strcpy(copy, zip_name);
+ _zip_name = copy;
}
ClassPathZipEntry::~ClassPathZipEntry() {
@@ -304,7 +306,7 @@
}
}
-LazyClassPathEntry::LazyClassPathEntry(char* path, const struct stat* st, bool throw_exception) : ClassPathEntry() {
+LazyClassPathEntry::LazyClassPathEntry(const char* path, const struct stat* st, bool throw_exception) : ClassPathEntry() {
_path = os::strdup_check_oom(path);
_st = *st;
_meta_index = NULL;
@@ -314,7 +316,7 @@
}
LazyClassPathEntry::~LazyClassPathEntry() {
- os::free(_path);
+ os::free((void*)_path);
}
bool LazyClassPathEntry::is_jar_file() {
@@ -563,17 +565,19 @@
void ClassLoader::setup_bootstrap_search_path() {
assert(_first_entry == NULL, "should not setup bootstrap class search path twice");
- char* sys_class_path = os::strdup_check_oom(Arguments::get_sysclasspath());
- if (!PrintSharedArchiveAndExit) {
+ const char* sys_class_path = Arguments::get_sysclasspath();
+ if (PrintSharedArchiveAndExit) {
+ // Don't print sys_class_path - this is the bootcp of this current VM process, not necessarily
+ // the same as the bootcp of the shared archive.
+ } else {
trace_class_path("[Bootstrap loader class path=", sys_class_path);
}
#if INCLUDE_CDS
if (DumpSharedSpaces) {
- _shared_paths_misc_info->add_boot_classpath(Arguments::get_sysclasspath());
+ _shared_paths_misc_info->add_boot_classpath(sys_class_path);
}
#endif
setup_search_path(sys_class_path);
- os::free(sys_class_path);
}
#if INCLUDE_CDS
@@ -593,7 +597,7 @@
}
#endif
-void ClassLoader::setup_search_path(char *class_path) {
+void ClassLoader::setup_search_path(const char *class_path) {
int offset = 0;
int len = (int)strlen(class_path);
int end = 0;
@@ -620,7 +624,7 @@
}
}
-ClassPathEntry* ClassLoader::create_class_path_entry(char *path, const struct stat* st,
+ClassPathEntry* ClassLoader::create_class_path_entry(const char *path, const struct stat* st,
bool lazy, bool throw_exception, TRAPS) {
JavaThread* thread = JavaThread::current();
if (lazy) {
@@ -687,11 +691,8 @@
struct stat st;
if (os::stat(path, &st) == 0) {
if ((st.st_mode & S_IFREG) == S_IFREG) {
- char orig_path[JVM_MAXPATHLEN];
char canonical_path[JVM_MAXPATHLEN];
-
- strcpy(orig_path, path);
- if (get_canonical_path(orig_path, canonical_path, JVM_MAXPATHLEN)) {
+ if (get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {
char* error_msg = NULL;
jzfile* zip;
{
@@ -737,7 +738,7 @@
}
// Returns true IFF the file/dir exists and the entry was successfully created.
-bool ClassLoader::update_class_path_entry_list(char *path,
+bool ClassLoader::update_class_path_entry_list(const char *path,
bool check_for_duplicates,
bool throw_exception) {
struct stat st;
@@ -762,8 +763,8 @@
if (DumpSharedSpaces) {
_shared_paths_misc_info->add_nonexist_path(path);
}
+#endif
return false;
-#endif
}
}
@@ -1269,11 +1270,17 @@
}
-bool ClassLoader::get_canonical_path(char* orig, char* out, int len) {
+bool ClassLoader::get_canonical_path(const char* orig, char* out, int len) {
assert(orig != NULL && out != NULL && len > 0, "bad arguments");
if (CanonicalizeEntry != NULL) {
- JNIEnv* env = JavaThread::current()->jni_environment();
- if ((CanonicalizeEntry)(env, os::native_path(orig), out, len) < 0) {
+ JavaThread* THREAD = JavaThread::current();
+ JNIEnv* env = THREAD->jni_environment();
+ ResourceMark rm(THREAD);
+
+ // os::native_path writes into orig_copy
+ char* orig_copy = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, strlen(orig)+1);
+ strcpy(orig_copy, orig);
+ if ((CanonicalizeEntry)(env, os::native_path(orig_copy), out, len) < 0) {
return false;
}
} else {
--- a/hotspot/src/share/vm/classfile/classLoader.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/classLoader.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -72,11 +72,11 @@
class ClassPathDirEntry: public ClassPathEntry {
private:
- char* _dir; // Name of directory
+ const char* _dir; // Name of directory
public:
bool is_jar_file() { return false; }
const char* name() { return _dir; }
- ClassPathDirEntry(char* dir);
+ ClassPathDirEntry(const char* dir);
ClassFileStream* open_stream(const char* name, TRAPS);
// Debugging
NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)
@@ -100,8 +100,8 @@
class ClassPathZipEntry: public ClassPathEntry {
private:
- jzfile* _zip; // The zip archive
- char* _zip_name; // Name of zip archive
+ jzfile* _zip; // The zip archive
+ const char* _zip_name; // Name of zip archive
public:
bool is_jar_file() { return true; }
const char* name() { return _zip_name; }
@@ -119,7 +119,7 @@
// For lazier loading of boot class path entries
class LazyClassPathEntry: public ClassPathEntry {
private:
- char* _path; // dir or file
+ const char* _path; // dir or file
struct stat _st;
MetaIndex* _meta_index;
bool _has_error;
@@ -129,7 +129,7 @@
public:
bool is_jar_file();
const char* name() { return _path; }
- LazyClassPathEntry(char* path, const struct stat* st, bool throw_exception);
+ LazyClassPathEntry(const char* path, const struct stat* st, bool throw_exception);
virtual ~LazyClassPathEntry();
u1* open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS);
@@ -216,17 +216,17 @@
static void setup_meta_index(const char* meta_index_path, const char* meta_index_dir,
int start_index);
static void setup_bootstrap_search_path();
- static void setup_search_path(char *class_path);
+ static void setup_search_path(const char *class_path);
static void load_zip_library();
- static ClassPathEntry* create_class_path_entry(char *path, const struct stat* st,
+ static ClassPathEntry* create_class_path_entry(const char *path, const struct stat* st,
bool lazy, bool throw_exception, TRAPS);
// Canonicalizes path names, so strcmp will work properly. This is mainly
// to avoid confusing the zip library
- static bool get_canonical_path(char* orig, char* out, int len);
+ static bool get_canonical_path(const char* orig, char* out, int len);
public:
- static bool update_class_path_entry_list(char *path,
+ static bool update_class_path_entry_list(const char *path,
bool check_for_duplicates,
bool throw_exception=true);
static void print_bootclasspath();
--- a/hotspot/src/share/vm/classfile/classLoaderData.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/classLoaderData.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -332,27 +332,6 @@
}
}
-#ifdef ASSERT
-class AllAliveClosure : public OopClosure {
- BoolObjectClosure* _is_alive_closure;
- bool _found_dead;
- public:
- AllAliveClosure(BoolObjectClosure* is_alive_closure) : _is_alive_closure(is_alive_closure), _found_dead(false) {}
- template <typename T> void do_oop_work(T* p) {
- T heap_oop = oopDesc::load_heap_oop(p);
- if (!oopDesc::is_null(heap_oop)) {
- oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
- if (!_is_alive_closure->do_object_b(obj)) {
- _found_dead = true;
- }
- }
- }
- void do_oop(oop* p) { do_oop_work<oop>(p); }
- void do_oop(narrowOop* p) { do_oop_work<narrowOop>(p); }
- bool found_dead() { return _found_dead; }
-};
-#endif
-
oop ClassLoaderData::keep_alive_object() const {
assert(!keep_alive(), "Don't use with CLDs that are artificially kept alive");
return is_anonymous() ? _klasses->java_mirror() : class_loader();
@@ -362,15 +341,6 @@
bool alive = keep_alive() // null class loader and incomplete anonymous klasses.
|| is_alive_closure->do_object_b(keep_alive_object());
-#ifdef ASSERT
- if (alive) {
- AllAliveClosure all_alive_closure(is_alive_closure);
- KlassToOopClosure klass_closure(&all_alive_closure);
- const_cast<ClassLoaderData*>(this)->oops_do(&all_alive_closure, &klass_closure, false);
- assert(!all_alive_closure.found_dead(), err_msg("Found dead oop in alive cld: " PTR_FORMAT, p2i(this)));
- }
-#endif
-
return alive;
}
@@ -776,7 +746,7 @@
// mark metadata seen on the stack and code cache so we can delete
// unneeded entries.
bool has_redefined_a_class = JvmtiExport::has_redefined_a_class();
- MetadataOnStackMark md_on_stack;
+ MetadataOnStackMark md_on_stack(has_redefined_a_class);
if (has_redefined_a_class) {
// purge_previous_versions also cleans weak method links. Because
// one method's MDO can reference another method from another
--- a/hotspot/src/share/vm/classfile/classLoaderExt.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/classLoaderExt.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -59,8 +59,8 @@
};
- static void add_class_path_entry(char* path, bool check_for_duplicates,
- ClassPathEntry* new_entry) {
+ static void add_class_path_entry(const char* path, bool check_for_duplicates,
+ ClassPathEntry* new_entry) {
ClassLoader::add_to_list(new_entry);
}
static void setup_search_paths() {}
--- a/hotspot/src/share/vm/classfile/javaClasses.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/javaClasses.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -620,7 +620,6 @@
// Two-way link between the array klass and its component mirror:
// (array_klass) k -> mirror -> component_mirror -> array_klass -> k
set_component_mirror(mirror(), comp_mirror());
- ArrayKlass::cast(k())->set_component_mirror(comp_mirror());
set_array_klass(comp_mirror(), k());
} else {
assert(k->oop_is_instance(), "Must be");
@@ -682,10 +681,9 @@
}
void java_lang_Class::set_component_mirror(oop java_class, oop comp_mirror) {
- if (_component_mirror_offset != 0) {
+ assert(_component_mirror_offset != 0, "must be set");
java_class->obj_field_put(_component_mirror_offset, comp_mirror);
}
-}
oop java_lang_Class::component_mirror(oop java_class) {
assert(_component_mirror_offset != 0, "must be set");
return java_class->obj_field(_component_mirror_offset);
@@ -875,22 +873,27 @@
assert(!offsets_computed, "offsets should be initialized only once");
offsets_computed = true;
- Klass* klass_oop = SystemDictionary::Class_klass();
+ Klass* k = SystemDictionary::Class_klass();
// The classRedefinedCount field is only present starting in 1.5,
// so don't go fatal.
compute_optional_offset(classRedefinedCount_offset,
- klass_oop, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
+ k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
// Needs to be optional because the old build runs Queens during bootstrapping
// and jdk8-9 doesn't have coordinated pushes yet.
compute_optional_offset(_class_loader_offset,
- klass_oop, vmSymbols::classLoader_name(),
+ k, vmSymbols::classLoader_name(),
vmSymbols::classloader_signature());
- compute_optional_offset(_component_mirror_offset,
- klass_oop, vmSymbols::componentType_name(),
+ compute_offset(_component_mirror_offset,
+ k, vmSymbols::componentType_name(),
vmSymbols::class_signature());
+ // Init lock is a C union with component_mirror. Only instanceKlass mirrors have
+ // init_lock and only ArrayKlass mirrors have component_mirror. Since both are oops
+ // GC treats them the same.
+ _init_lock_offset = _component_mirror_offset;
+
CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
}
--- a/hotspot/src/share/vm/classfile/javaClasses.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/javaClasses.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -222,7 +222,6 @@
macro(java_lang_Class, oop_size, int_signature, false) \
macro(java_lang_Class, static_oop_field_count, int_signature, false) \
macro(java_lang_Class, protection_domain, object_signature, false) \
- macro(java_lang_Class, init_lock, object_signature, false) \
macro(java_lang_Class, signers, object_signature, false)
class java_lang_Class : AllStatic {
--- a/hotspot/src/share/vm/classfile/metadataOnStackMark.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/metadataOnStackMark.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 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
@@ -41,7 +41,7 @@
// Walk metadata on the stack and mark it so that redefinition doesn't delete
// it. Class unloading also walks the previous versions and might try to
// delete it, so this class is used by class unloading also.
-MetadataOnStackMark::MetadataOnStackMark() {
+MetadataOnStackMark::MetadataOnStackMark(bool has_redefined_a_class) {
assert(SafepointSynchronize::is_at_safepoint(), "sanity check");
NOT_PRODUCT(_is_active = true;)
if (_marked_objects == NULL) {
@@ -49,7 +49,7 @@
}
Threads::metadata_do(Metadata::mark_on_stack);
- if (JvmtiExport::has_redefined_a_class()) {
+ if (has_redefined_a_class) {
CodeCache::alive_nmethods_do(nmethod::mark_on_stack);
}
CompileBroker::mark_on_stack();
--- a/hotspot/src/share/vm/classfile/metadataOnStackMark.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/metadataOnStackMark.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 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
@@ -37,7 +37,7 @@
class MetadataOnStackMark : public StackObj {
NOT_PRODUCT(static bool _is_active;)
public:
- MetadataOnStackMark();
+ MetadataOnStackMark(bool has_redefined_a_class);
~MetadataOnStackMark();
static void record(Metadata* m);
};
--- a/hotspot/src/share/vm/classfile/sharedPathsMiscInfo.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/sharedPathsMiscInfo.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -139,7 +139,7 @@
if (timestamp != st.st_mtime) {
return fail("Timestamp mismatch");
}
- if (filesize != st.st_size) {
+ if (filesize != st.st_size) {
return fail("File size mismatch");
}
}
--- a/hotspot/src/share/vm/classfile/sharedPathsMiscInfo.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/sharedPathsMiscInfo.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -165,7 +165,7 @@
out->print("Expecting that %s does not exist", path);
break;
case REQUIRED:
- out->print("Expecting that file %s must exist and not altered", path);
+ out->print("Expecting that file %s must exist and is not altered", path);
break;
default:
ShouldNotReachHere();
--- a/hotspot/src/share/vm/classfile/stringTable.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/stringTable.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -109,7 +109,7 @@
}
}
// If the bucket size is too deep check if this hash code is insufficient.
- if (count >= BasicHashtable<mtSymbol>::rehash_count && !needs_rehashing()) {
+ if (count >= rehash_count && !needs_rehashing()) {
_needs_rehashing = check_rehash_table(count);
}
return NULL;
--- a/hotspot/src/share/vm/classfile/stringTable.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/stringTable.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -28,7 +28,7 @@
#include "memory/allocation.inline.hpp"
#include "utilities/hashtable.hpp"
-class StringTable : public Hashtable<oop, mtSymbol> {
+class StringTable : public RehashableHashtable<oop, mtSymbol> {
friend class VMStructs;
friend class Symbol;
@@ -55,11 +55,11 @@
// in the range [start_idx, end_idx).
static void buckets_unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* f, int start_idx, int end_idx, int* processed, int* removed);
- StringTable() : Hashtable<oop, mtSymbol>((int)StringTableSize,
+ StringTable() : RehashableHashtable<oop, mtSymbol>((int)StringTableSize,
sizeof (HashtableEntry<oop, mtSymbol>)) {}
StringTable(HashtableBucket<mtSymbol>* t, int number_of_entries)
- : Hashtable<oop, mtSymbol>((int)StringTableSize, sizeof (HashtableEntry<oop, mtSymbol>), t,
+ : RehashableHashtable<oop, mtSymbol>((int)StringTableSize, sizeof (HashtableEntry<oop, mtSymbol>), t,
number_of_entries) {}
public:
// The string table
--- a/hotspot/src/share/vm/classfile/symbolTable.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/symbolTable.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -201,7 +201,7 @@
}
}
// If the bucket size is too deep check if this hash code is insufficient.
- if (count >= BasicHashtable<mtSymbol>::rehash_count && !needs_rehashing()) {
+ if (count >= rehash_count && !needs_rehashing()) {
_needs_rehashing = check_rehash_table(count);
}
return NULL;
--- a/hotspot/src/share/vm/classfile/symbolTable.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/symbolTable.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -73,7 +73,7 @@
operator Symbol*() { return _temp; }
};
-class SymbolTable : public Hashtable<Symbol*, mtSymbol> {
+class SymbolTable : public RehashableHashtable<Symbol*, mtSymbol> {
friend class VMStructs;
friend class ClassFileParser;
@@ -109,10 +109,10 @@
Symbol* lookup(int index, const char* name, int len, unsigned int hash);
SymbolTable()
- : Hashtable<Symbol*, mtSymbol>(SymbolTableSize, sizeof (HashtableEntry<Symbol*, mtSymbol>)) {}
+ : RehashableHashtable<Symbol*, mtSymbol>(SymbolTableSize, sizeof (HashtableEntry<Symbol*, mtSymbol>)) {}
SymbolTable(HashtableBucket<mtSymbol>* t, int number_of_entries)
- : Hashtable<Symbol*, mtSymbol>(SymbolTableSize, sizeof (HashtableEntry<Symbol*, mtSymbol>), t,
+ : RehashableHashtable<Symbol*, mtSymbol>(SymbolTableSize, sizeof (HashtableEntry<Symbol*, mtSymbol>), t,
number_of_entries) {}
// Arena for permanent symbols (null class loader) that are never unloaded
--- a/hotspot/src/share/vm/classfile/systemDictionary.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/systemDictionary.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -1243,7 +1243,6 @@
tty->print_cr("]");
}
-#if INCLUDE_CDS
if (DumpLoadedClassList != NULL && classlist_file->is_open()) {
// Only dump the classes that can be stored into CDS archive
if (SystemDictionaryShared::is_sharing_possible(loader_data)) {
@@ -1252,7 +1251,6 @@
classlist_file->flush();
}
}
-#endif
// notify a class loaded from shared object
ClassLoadingService::notify_class_loaded(InstanceKlass::cast(ik()),
@@ -1260,7 +1258,7 @@
}
return ik;
}
-#endif
+#endif // INCLUDE_CDS
instanceKlassHandle SystemDictionary::load_instance_class(Symbol* class_name, Handle class_loader, TRAPS) {
instanceKlassHandle nh = instanceKlassHandle(); // null Handle
--- a/hotspot/src/share/vm/classfile/vmSymbols.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/classfile/vmSymbols.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -399,7 +399,6 @@
template(oop_size_name, "oop_size") \
template(static_oop_field_count_name, "static_oop_field_count") \
template(protection_domain_name, "protection_domain") \
- template(init_lock_name, "init_lock") \
template(signers_name, "signers_name") \
template(loader_data_name, "loader_data") \
template(dependencies_name, "dependencies") \
@@ -747,8 +746,6 @@
do_name( isPrimitive_name, "isPrimitive") \
do_intrinsic(_getSuperclass, java_lang_Class, getSuperclass_name, void_class_signature, F_RN) \
do_name( getSuperclass_name, "getSuperclass") \
- do_intrinsic(_getComponentType, java_lang_Class, getComponentType_name, void_class_signature, F_RN) \
- do_name( getComponentType_name, "getComponentType") \
\
do_intrinsic(_getClassAccessFlags, sun_reflect_Reflection, getClassAccessFlags_name, class_int_signature, F_SN) \
do_name( getClassAccessFlags_name, "getClassAccessFlags") \
@@ -788,6 +785,11 @@
do_name( encodeISOArray_name, "encodeISOArray") \
do_signature(encodeISOArray_signature, "([CI[BII)I") \
\
+ do_class(java_math_BigInteger, "java/math/BigInteger") \
+ do_intrinsic(_multiplyToLen, java_math_BigInteger, multiplyToLen_name, multiplyToLen_signature, F_R) \
+ do_name( multiplyToLen_name, "multiplyToLen") \
+ do_signature(multiplyToLen_signature, "([II[II[I)[I") \
+ \
/* java/lang/ref/Reference */ \
do_intrinsic(_Reference_get, java_lang_ref_Reference, get_name, void_object_signature, F_R) \
\
--- a/hotspot/src/share/vm/code/codeBlob.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/code/codeBlob.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -238,6 +238,7 @@
void BufferBlob::free( BufferBlob *blob ) {
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
+ blob->flush();
{
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
CodeCache::free((CodeBlob*)blob);
--- a/hotspot/src/share/vm/code/nmethod.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/code/nmethod.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -2062,7 +2062,7 @@
"metadata must be found in exactly one place");
if (r->metadata_is_immediate() && r->metadata_value() != NULL) {
Metadata* md = r->metadata_value();
- f(md);
+ if (md != _method) f(md);
}
} else if (iter.type() == relocInfo::virtual_call_type) {
// Check compiledIC holders associated with this nmethod
--- a/hotspot/src/share/vm/compiler/compilerOracle.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/compiler/compilerOracle.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -168,48 +168,134 @@
}
}
+enum OptionType {
+ IntxType,
+ UintxType,
+ BoolType,
+ CcstrType,
+ UnknownType
+};
-class MethodOptionMatcher: public MethodMatcher {
- const char * option;
- public:
- MethodOptionMatcher(Symbol* class_name, Mode class_mode,
- Symbol* method_name, Mode method_mode,
- Symbol* signature, const char * opt, MethodMatcher* next):
- MethodMatcher(class_name, class_mode, method_name, method_mode, signature, next) {
- option = os::strdup_check_oom(opt);
+/* Methods to map real type names to OptionType */
+template<typename T>
+static OptionType get_type_for() {
+ return UnknownType;
+};
+
+template<> OptionType get_type_for<intx>() {
+ return IntxType;
+}
+
+template<> OptionType get_type_for<uintx>() {
+ return UintxType;
+}
+
+template<> OptionType get_type_for<bool>() {
+ return BoolType;
+}
+
+template<> OptionType get_type_for<ccstr>() {
+ return CcstrType;
+}
+
+template<typename T>
+static const T copy_value(const T value) {
+ return value;
+}
+
+template<> const ccstr copy_value<ccstr>(const ccstr value) {
+ return (const ccstr)os::strdup_check_oom(value);
+}
+
+template <typename T>
+class TypedMethodOptionMatcher : public MethodMatcher {
+ const char* _option;
+ OptionType _type;
+ const T _value;
+
+public:
+ TypedMethodOptionMatcher(Symbol* class_name, Mode class_mode,
+ Symbol* method_name, Mode method_mode,
+ Symbol* signature, const char* opt,
+ const T value, MethodMatcher* next) :
+ MethodMatcher(class_name, class_mode, method_name, method_mode, signature, next),
+ _type(get_type_for<T>()), _value(copy_value<T>(value)) {
+ _option = os::strdup_check_oom(opt);
}
- virtual ~MethodOptionMatcher() {
- os::free((void*)option);
+ ~TypedMethodOptionMatcher() {
+ os::free((void*)_option);
}
- bool match(methodHandle method, const char* opt) {
- MethodOptionMatcher* current = this;
+ TypedMethodOptionMatcher* match(methodHandle method, const char* opt) {
+ TypedMethodOptionMatcher* current = this;
while (current != NULL) {
- current = (MethodOptionMatcher*)current->find(method);
+ current = (TypedMethodOptionMatcher*)current->find(method);
if (current == NULL) {
- return false;
+ return NULL;
}
- if (strcmp(current->option, opt) == 0) {
- return true;
+ if (strcmp(current->_option, opt) == 0) {
+ return current;
}
current = current->next();
}
- return false;
+ return NULL;
+ }
+
+ TypedMethodOptionMatcher* next() {
+ return (TypedMethodOptionMatcher*)_next;
}
- MethodOptionMatcher* next() {
- return (MethodOptionMatcher*)_next;
- }
+ OptionType get_type(void) {
+ return _type;
+ };
+
+ T value() { return _value; }
- virtual void print() {
+ void print() {
+ ttyLocker ttyl;
print_base();
- tty->print(" %s", option);
+ tty->print(" %s", _option);
+ tty->print(" <unknown option type>");
tty->cr();
}
};
+template<>
+void TypedMethodOptionMatcher<intx>::print() {
+ ttyLocker ttyl;
+ print_base();
+ tty->print(" intx %s", _option);
+ tty->print(" = " INTX_FORMAT, _value);
+ tty->cr();
+};
+template<>
+void TypedMethodOptionMatcher<uintx>::print() {
+ ttyLocker ttyl;
+ print_base();
+ tty->print(" uintx %s", _option);
+ tty->print(" = " UINTX_FORMAT, _value);
+ tty->cr();
+};
+
+template<>
+void TypedMethodOptionMatcher<bool>::print() {
+ ttyLocker ttyl;
+ print_base();
+ tty->print(" bool %s", _option);
+ tty->print(" = %s", _value ? "true" : "false");
+ tty->cr();
+};
+
+template<>
+void TypedMethodOptionMatcher<ccstr>::print() {
+ ttyLocker ttyl;
+ print_base();
+ tty->print(" const char* %s", _option);
+ tty->print(" = '%s'", _value);
+ tty->cr();
+};
// this must parallel the command_names below
enum OracleCommand {
@@ -264,23 +350,46 @@
return lists[command];
}
-
-
+template<typename T>
static MethodMatcher* add_option_string(Symbol* class_name, MethodMatcher::Mode c_mode,
Symbol* method_name, MethodMatcher::Mode m_mode,
Symbol* signature,
- const char* option) {
- lists[OptionCommand] = new MethodOptionMatcher(class_name, c_mode, method_name, m_mode,
- signature, option, lists[OptionCommand]);
+ const char* option,
+ T value) {
+ lists[OptionCommand] = new TypedMethodOptionMatcher<T>(class_name, c_mode, method_name, m_mode,
+ signature, option, value, lists[OptionCommand]);
return lists[OptionCommand];
}
+template<typename T>
+static bool get_option_value(methodHandle method, const char* option, T& value) {
+ TypedMethodOptionMatcher<T>* m;
+ if (lists[OptionCommand] != NULL
+ && (m = ((TypedMethodOptionMatcher<T>*)lists[OptionCommand])->match(method, option)) != NULL
+ && m->get_type() == get_type_for<T>()) {
+ value = m->value();
+ return true;
+ } else {
+ return false;
+ }
+}
bool CompilerOracle::has_option_string(methodHandle method, const char* option) {
- return lists[OptionCommand] != NULL &&
- ((MethodOptionMatcher*)lists[OptionCommand])->match(method, option);
+ bool value = false;
+ get_option_value(method, option, value);
+ return value;
}
+template<typename T>
+bool CompilerOracle::has_option_value(methodHandle method, const char* option, T& value) {
+ return ::get_option_value(method, option, value);
+}
+
+// Explicit instantiation for all OptionTypes supported.
+template bool CompilerOracle::has_option_value<intx>(methodHandle method, const char* option, intx& value);
+template bool CompilerOracle::has_option_value<uintx>(methodHandle method, const char* option, uintx& value);
+template bool CompilerOracle::has_option_value<bool>(methodHandle method, const char* option, bool& value);
+template bool CompilerOracle::has_option_value<ccstr>(methodHandle method, const char* option, ccstr& value);
bool CompilerOracle::should_exclude(methodHandle method, bool& quietly) {
quietly = true;
@@ -422,6 +531,94 @@
+// Scan next flag and value in line, return MethodMatcher object on success, NULL on failure.
+// On failure, error_msg contains description for the first error.
+// For future extensions: set error_msg on first error.
+static MethodMatcher* scan_flag_and_value(const char* type, const char* line, int& total_bytes_read,
+ Symbol* c_name, MethodMatcher::Mode c_match,
+ Symbol* m_name, MethodMatcher::Mode m_match,
+ Symbol* signature,
+ char* errorbuf, const int buf_size) {
+ total_bytes_read = 0;
+ int bytes_read = 0;
+ char flag[256];
+
+ // Read flag name.
+ if (sscanf(line, "%*[ \t]%255[a-zA-Z0-9]%n", flag, &bytes_read) == 1) {
+ line += bytes_read;
+ total_bytes_read += bytes_read;
+
+ // Read value.
+ if (strcmp(type, "intx") == 0) {
+ intx value;
+ if (sscanf(line, "%*[ \t]" INTX_FORMAT "%n", &value, &bytes_read) == 1) {
+ total_bytes_read += bytes_read;
+ return add_option_string(c_name, c_match, m_name, m_match, signature, flag, value);
+ } else {
+ jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s ", flag, type);
+ }
+ } else if (strcmp(type, "uintx") == 0) {
+ uintx value;
+ if (sscanf(line, "%*[ \t]" UINTX_FORMAT "%n", &value, &bytes_read) == 1) {
+ total_bytes_read += bytes_read;
+ return add_option_string(c_name, c_match, m_name, m_match, signature, flag, value);
+ } else {
+ jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s", flag, type);
+ }
+ } else if (strcmp(type, "ccstr") == 0) {
+ ResourceMark rm;
+ char* value = NEW_RESOURCE_ARRAY(char, strlen(line) + 1);
+ if (sscanf(line, "%*[ \t]%255[_a-zA-Z0-9]%n", value, &bytes_read) == 1) {
+ total_bytes_read += bytes_read;
+ return add_option_string(c_name, c_match, m_name, m_match, signature, flag, (ccstr)value);
+ } else {
+ jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s", flag, type);
+ }
+ } else if (strcmp(type, "ccstrlist") == 0) {
+ // Accumulates several strings into one. The internal type is ccstr.
+ ResourceMark rm;
+ char* value = NEW_RESOURCE_ARRAY(char, strlen(line) + 1);
+ char* next_value = value;
+ if (sscanf(line, "%*[ \t]%255[_a-zA-Z0-9]%n", next_value, &bytes_read) == 1) {
+ total_bytes_read += bytes_read;
+ line += bytes_read;
+ next_value += bytes_read;
+ char* end_value = next_value-1;
+ while (sscanf(line, "%*[ \t]%255[_a-zA-Z0-9]%n", next_value, &bytes_read) == 1) {
+ total_bytes_read += bytes_read;
+ line += bytes_read;
+ *end_value = ' '; // override '\0'
+ next_value += bytes_read;
+ end_value = next_value-1;
+ }
+ return add_option_string(c_name, c_match, m_name, m_match, signature, flag, (ccstr)value);
+ } else {
+ jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s", flag, type);
+ }
+ } else if (strcmp(type, "bool") == 0) {
+ char value[256];
+ if (sscanf(line, "%*[ \t]%255[a-zA-Z]%n", value, &bytes_read) == 1) {
+ if (strcmp(value, "true") == 0) {
+ total_bytes_read += bytes_read;
+ return add_option_string(c_name, c_match, m_name, m_match, signature, flag, true);
+ } else if (strcmp(value, "false") == 0) {
+ total_bytes_read += bytes_read;
+ return add_option_string(c_name, c_match, m_name, m_match, signature, flag, false);
+ } else {
+ jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s", flag, type);
+ }
+ } else {
+ jio_snprintf(errorbuf, sizeof(errorbuf), " Value cannot be read for flag %s of type %s", flag, type);
+ }
+ } else {
+ jio_snprintf(errorbuf, sizeof(errorbuf), " Type %s not supported ", type);
+ }
+ } else {
+ jio_snprintf(errorbuf, sizeof(errorbuf), " Flag name for type %s should be alphanumeric ", type);
+ }
+ return NULL;
+}
+
void CompilerOracle::parse_from_line(char* line) {
if (line[0] == '\0') return;
if (line[0] == '#') return;
@@ -451,8 +648,10 @@
int bytes_read;
OracleCommand command = parse_command_name(line, &bytes_read);
line += bytes_read;
+ ResourceMark rm;
if (command == UnknownCommand) {
+ ttyLocker ttyl;
tty->print_cr("CompilerOracle: unrecognized line");
tty->print_cr(" \"%s\"", original_line);
return;
@@ -474,7 +673,7 @@
char method_name[256];
char sig[1024];
char errorbuf[1024];
- const char* error_msg = NULL;
+ const char* error_msg = NULL; // description of first error that appears
MethodMatcher* match = NULL;
if (scan_line(line, class_name, &c_match, method_name, &m_match, &bytes_read, error_msg)) {
@@ -493,43 +692,77 @@
}
if (command == OptionCommand) {
- // Look for trailing options to support
- // ciMethod::has_option("string") to control features in the
- // compiler. Multiple options may follow the method name.
- char option[256];
+ // Look for trailing options.
+ //
+ // Two types of trailing options are
+ // supported:
+ //
+ // (1) CompileCommand=option,Klass::method,flag
+ // (2) CompileCommand=option,Klass::method,type,flag,value
+ //
+ // Type (1) is used to support ciMethod::has_option("someflag")
+ // (i.e., to check if a flag "someflag" is enabled for a method).
+ //
+ // Type (2) is used to support options with a value. Values can have the
+ // the following types: intx, uintx, bool, ccstr, and ccstrlist.
+ //
+ // For future extensions: extend scan_flag_and_value()
+ char option[256]; // stores flag for Type (1) and type of Type (2)
while (sscanf(line, "%*[ \t]%255[a-zA-Z0-9]%n", option, &bytes_read) == 1) {
if (match != NULL && !_quiet) {
// Print out the last match added
+ ttyLocker ttyl;
tty->print("CompilerOracle: %s ", command_names[command]);
match->print();
}
- match = add_option_string(c_name, c_match, m_name, m_match, signature, option);
line += bytes_read;
- }
+
+ if (strcmp(option, "intx") == 0
+ || strcmp(option, "uintx") == 0
+ || strcmp(option, "bool") == 0
+ || strcmp(option, "ccstr") == 0
+ || strcmp(option, "ccstrlist") == 0
+ ) {
+
+ // Type (2) option: parse flag name and value.
+ match = scan_flag_and_value(option, line, bytes_read,
+ c_name, c_match, m_name, m_match, signature,
+ errorbuf, sizeof(errorbuf));
+ if (match == NULL) {
+ error_msg = errorbuf;
+ break;
+ }
+ line += bytes_read;
+ } else {
+ // Type (1) option
+ match = add_option_string(c_name, c_match, m_name, m_match, signature, option, true);
+ }
+ } // while(
} else {
- bytes_read = 0;
- sscanf(line, "%*[ \t]%n", &bytes_read);
- if (line[bytes_read] != '\0') {
- jio_snprintf(errorbuf, sizeof(errorbuf), " Unrecognized text after command: %s", line);
- error_msg = errorbuf;
- } else {
- match = add_predicate(command, c_name, c_match, m_name, m_match, signature);
- }
+ match = add_predicate(command, c_name, c_match, m_name, m_match, signature);
}
}
- if (match != NULL) {
- if (!_quiet) {
- ResourceMark rm;
- tty->print("CompilerOracle: %s ", command_names[command]);
- match->print();
- }
- } else {
+ ttyLocker ttyl;
+ if (error_msg != NULL) {
+ // an error has happened
tty->print_cr("CompilerOracle: unrecognized line");
tty->print_cr(" \"%s\"", original_line);
if (error_msg != NULL) {
tty->print_cr("%s", error_msg);
}
+ } else {
+ // check for remaining characters
+ bytes_read = 0;
+ sscanf(line, "%*[ \t]%n", &bytes_read);
+ if (line[bytes_read] != '\0') {
+ tty->print_cr("CompilerOracle: unrecognized line");
+ tty->print_cr(" \"%s\"", original_line);
+ tty->print_cr(" Unrecognized text %s after command ", line);
+ } else if (match != NULL && !_quiet) {
+ tty->print("CompilerOracle: %s ", command_names[command]);
+ match->print();
+ }
}
}
--- a/hotspot/src/share/vm/compiler/compilerOracle.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/compiler/compilerOracle.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -64,6 +64,11 @@
// Check to see if this method has option set for it
static bool has_option_string(methodHandle method, const char * option);
+ // Check if method has option and value set. If yes, overwrite value and return true,
+ // otherwise leave value unchanged and return false.
+ template<typename T>
+ static bool has_option_value(methodHandle method, const char* option, T& value);
+
// Reads from string instead of file
static void parse_from_string(const char* command_string, void (*parser)(char*));
--- a/hotspot/src/share/vm/compiler/disassembler.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/compiler/disassembler.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -246,12 +246,12 @@
};
decode_env::decode_env(CodeBlob* code, outputStream* output, CodeStrings c) {
- memset(this, 0, sizeof(*this));
+ memset(this, 0, sizeof(*this)); // Beware, this zeroes bits of fields.
_output = output ? output : tty;
_code = code;
if (code != NULL && code->is_nmethod())
_nm = (nmethod*) code;
- _strings.assign(c);
+ _strings.copy(c);
// by default, output pc but not bytes:
_print_pc = true;
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -22,372 +22,375 @@
*
*/
-
#include "precompiled.hpp"
+#include "code/codeCache.hpp"
#include "code/nmethod.hpp"
#include "gc_implementation/g1/g1CodeCacheRemSet.hpp"
+#include "gc_implementation/g1/heapRegion.hpp"
+#include "memory/heap.hpp"
#include "memory/iterator.hpp"
+#include "oops/oop.inline.hpp"
+#include "utilities/hashtable.inline.hpp"
+#include "utilities/stack.inline.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-G1CodeRootChunk::G1CodeRootChunk() : _top(NULL), _next(NULL), _prev(NULL), _free(NULL) {
- _top = bottom();
+class CodeRootSetTable : public Hashtable<nmethod*, mtGC> {
+ friend class G1CodeRootSetTest;
+ typedef HashtableEntry<nmethod*, mtGC> Entry;
+
+ static CodeRootSetTable* volatile _purge_list;
+
+ CodeRootSetTable* _purge_next;
+
+ unsigned int compute_hash(nmethod* nm) {
+ uintptr_t hash = (uintptr_t)nm;
+ return hash ^ (hash >> 7); // code heap blocks are 128byte aligned
+ }
+
+ Entry* new_entry(nmethod* nm);
+
+ public:
+ CodeRootSetTable(int size) : Hashtable<nmethod*, mtGC>(size, sizeof(Entry)), _purge_next(NULL) {}
+ ~CodeRootSetTable();
+
+ // Needs to be protected locks
+ bool add(nmethod* nm);
+ bool remove(nmethod* nm);
+
+ // Can be called without locking
+ bool contains(nmethod* nm);
+
+ int entry_size() const { return BasicHashtable<mtGC>::entry_size(); }
+
+ void copy_to(CodeRootSetTable* new_table);
+ void nmethods_do(CodeBlobClosure* blk);
+
+ template<typename CB>
+ void remove_if(CB& should_remove);
+
+ static void purge_list_append(CodeRootSetTable* tbl);
+ static void purge();
+
+ static size_t static_mem_size() {
+ return sizeof(_purge_list);
+ }
+};
+
+CodeRootSetTable* volatile CodeRootSetTable::_purge_list = NULL;
+
+CodeRootSetTable::Entry* CodeRootSetTable::new_entry(nmethod* nm) {
+ unsigned int hash = compute_hash(nm);
+ Entry* entry = (Entry*) new_entry_free_list();
+ if (entry == NULL) {
+ entry = (Entry*) NEW_C_HEAP_ARRAY2(char, entry_size(), mtGC, CURRENT_PC);
+ }
+ entry->set_next(NULL);
+ entry->set_hash(hash);
+ entry->set_literal(nm);
+ return entry;
}
-void G1CodeRootChunk::reset() {
- _next = _prev = NULL;
- _free = NULL;
- _top = bottom();
-}
-
-void G1CodeRootChunk::nmethods_do(CodeBlobClosure* cl) {
- NmethodOrLink* cur = bottom();
- while (cur != _top) {
- if (is_nmethod(cur)) {
- cl->do_code_blob(cur->_nmethod);
+CodeRootSetTable::~CodeRootSetTable() {
+ for (int index = 0; index < table_size(); ++index) {
+ for (Entry* e = bucket(index); e != NULL; ) {
+ Entry* to_remove = e;
+ // read next before freeing.
+ e = e->next();
+ unlink_entry(to_remove);
+ FREE_C_HEAP_ARRAY(char, to_remove, mtGC);
}
- cur++;
+ }
+ assert(number_of_entries() == 0, "should have removed all entries");
+ free_buckets();
+ for (BasicHashtableEntry<mtGC>* e = new_entry_free_list(); e != NULL; e = new_entry_free_list()) {
+ FREE_C_HEAP_ARRAY(char, e, mtGC);
}
}
-bool G1CodeRootChunk::remove_lock_free(nmethod* method) {
- NmethodOrLink* cur = bottom();
-
- for (NmethodOrLink* cur = bottom(); cur != _top; cur++) {
- if (cur->_nmethod == method) {
- bool result = Atomic::cmpxchg_ptr(NULL, &cur->_nmethod, method) == method;
+bool CodeRootSetTable::add(nmethod* nm) {
+ if (!contains(nm)) {
+ Entry* e = new_entry(nm);
+ int index = hash_to_index(e->hash());
+ add_entry(index, e);
+ return true;
+ }
+ return false;
+}
- if (!result) {
- // Someone else cleared out this entry.
- return false;
- }
+bool CodeRootSetTable::contains(nmethod* nm) {
+ int index = hash_to_index(compute_hash(nm));
+ for (Entry* e = bucket(index); e != NULL; e = e->next()) {
+ if (e->literal() == nm) {
+ return true;
+ }
+ }
+ return false;
+}
- // The method was cleared. Time to link it into the free list.
- NmethodOrLink* prev_free;
- do {
- prev_free = (NmethodOrLink*)_free;
- cur->_link = prev_free;
- } while (Atomic::cmpxchg_ptr(cur, &_free, prev_free) != prev_free);
-
+bool CodeRootSetTable::remove(nmethod* nm) {
+ int index = hash_to_index(compute_hash(nm));
+ Entry* previous = NULL;
+ for (Entry* e = bucket(index); e != NULL; previous = e, e = e->next()) {
+ if (e->literal() == nm) {
+ if (previous != NULL) {
+ previous->set_next(e->next());
+ } else {
+ set_entry(index, e->next());
+ }
+ free_entry(e);
return true;
}
}
-
return false;
}
-G1CodeRootChunkManager::G1CodeRootChunkManager() : _free_list(), _num_chunks_handed_out(0) {
- _free_list.initialize();
- _free_list.set_size(G1CodeRootChunk::word_size());
+void CodeRootSetTable::copy_to(CodeRootSetTable* new_table) {
+ for (int index = 0; index < table_size(); ++index) {
+ for (Entry* e = bucket(index); e != NULL; e = e->next()) {
+ new_table->add(e->literal());
+ }
+ }
+ new_table->copy_freelist(this);
}
-size_t G1CodeRootChunkManager::fl_mem_size() {
- return _free_list.count() * _free_list.size();
-}
-
-void G1CodeRootChunkManager::free_all_chunks(FreeList<G1CodeRootChunk>* list) {
- _num_chunks_handed_out -= list->count();
- _free_list.prepend(list);
+void CodeRootSetTable::nmethods_do(CodeBlobClosure* blk) {
+ for (int index = 0; index < table_size(); ++index) {
+ for (Entry* e = bucket(index); e != NULL; e = e->next()) {
+ blk->do_code_blob(e->literal());
+ }
+ }
}
-void G1CodeRootChunkManager::free_chunk(G1CodeRootChunk* chunk) {
- _free_list.return_chunk_at_head(chunk);
- _num_chunks_handed_out--;
+template<typename CB>
+void CodeRootSetTable::remove_if(CB& should_remove) {
+ for (int index = 0; index < table_size(); ++index) {
+ Entry* previous = NULL;
+ Entry* e = bucket(index);
+ while (e != NULL) {
+ Entry* next = e->next();
+ if (should_remove(e->literal())) {
+ if (previous != NULL) {
+ previous->set_next(next);
+ } else {
+ set_entry(index, next);
+ }
+ free_entry(e);
+ } else {
+ previous = e;
+ }
+ e = next;
+ }
+ }
+}
+
+G1CodeRootSet::~G1CodeRootSet() {
+ delete _table;
}
-void G1CodeRootChunkManager::purge_chunks(size_t keep_ratio) {
- size_t keep = _num_chunks_handed_out * keep_ratio / 100;
- if (keep >= (size_t)_free_list.count()) {
- return;
- }
+CodeRootSetTable* G1CodeRootSet::load_acquire_table() {
+ return (CodeRootSetTable*) OrderAccess::load_ptr_acquire(&_table);
+}
+
+void G1CodeRootSet::allocate_small_table() {
+ _table = new CodeRootSetTable(SmallSize);
+}
- FreeList<G1CodeRootChunk> temp;
- temp.initialize();
- temp.set_size(G1CodeRootChunk::word_size());
+void CodeRootSetTable::purge_list_append(CodeRootSetTable* table) {
+ for (;;) {
+ table->_purge_next = _purge_list;
+ CodeRootSetTable* old = (CodeRootSetTable*) Atomic::cmpxchg_ptr(table, &_purge_list, table->_purge_next);
+ if (old == table->_purge_next) {
+ break;
+ }
+ }
+}
- _free_list.getFirstNChunksFromList((size_t)_free_list.count() - keep, &temp);
-
- G1CodeRootChunk* cur = temp.get_chunk_at_head();
- while (cur != NULL) {
- delete cur;
- cur = temp.get_chunk_at_head();
+void CodeRootSetTable::purge() {
+ CodeRootSetTable* table = _purge_list;
+ _purge_list = NULL;
+ while (table != NULL) {
+ CodeRootSetTable* to_purge = table;
+ table = table->_purge_next;
+ delete to_purge;
}
}
-size_t G1CodeRootChunkManager::static_mem_size() {
- return sizeof(G1CodeRootChunkManager);
+void G1CodeRootSet::move_to_large() {
+ CodeRootSetTable* temp = new CodeRootSetTable(LargeSize);
+
+ _table->copy_to(temp);
+
+ CodeRootSetTable::purge_list_append(_table);
+
+ OrderAccess::release_store_ptr(&_table, temp);
}
-G1CodeRootChunk* G1CodeRootChunkManager::new_chunk() {
- G1CodeRootChunk* result = _free_list.get_chunk_at_head();
- if (result == NULL) {
- result = new G1CodeRootChunk();
+void G1CodeRootSet::purge() {
+ CodeRootSetTable::purge();
+}
+
+size_t G1CodeRootSet::static_mem_size() {
+ return CodeRootSetTable::static_mem_size();
+}
+
+void G1CodeRootSet::add(nmethod* method) {
+ bool added = false;
+ if (is_empty()) {
+ allocate_small_table();
+ }
+ added = _table->add(method);
+ if (_length == Threshold) {
+ move_to_large();
+ }
+ if (added) {
+ ++_length;
+ }
+}
+
+bool G1CodeRootSet::remove(nmethod* method) {
+ bool removed = false;
+ if (_table != NULL) {
+ removed = _table->remove(method);
+ }
+ if (removed) {
+ _length--;
+ if (_length == 0) {
+ clear();
+ }
+ }
+ return removed;
+}
+
+bool G1CodeRootSet::contains(nmethod* method) {
+ CodeRootSetTable* table = load_acquire_table();
+ if (table != NULL) {
+ return table->contains(method);
}
- _num_chunks_handed_out++;
- result->reset();
- return result;
+ return false;
+}
+
+void G1CodeRootSet::clear() {
+ delete _table;
+ _table = NULL;
+ _length = 0;
+}
+
+size_t G1CodeRootSet::mem_size() {
+ return sizeof(*this) +
+ (_table != NULL ? sizeof(CodeRootSetTable) + _table->entry_size() * _length : 0);
+}
+
+void G1CodeRootSet::nmethods_do(CodeBlobClosure* blk) const {
+ if (_table != NULL) {
+ _table->nmethods_do(blk);
+ }
+}
+
+class CleanCallback : public StackObj {
+ class PointsIntoHRDetectionClosure : public OopClosure {
+ HeapRegion* _hr;
+ public:
+ bool _points_into;
+ PointsIntoHRDetectionClosure(HeapRegion* hr) : _hr(hr), _points_into(false) {}
+
+ void do_oop(narrowOop* o) {
+ do_oop_work(o);
+ }
+
+ void do_oop(oop* o) {
+ do_oop_work(o);
+ }
+
+ template <typename T>
+ void do_oop_work(T* p) {
+ if (_hr->is_in(oopDesc::load_decode_heap_oop(p))) {
+ _points_into = true;
+ }
+ }
+ };
+
+ PointsIntoHRDetectionClosure _detector;
+ CodeBlobToOopClosure _blobs;
+
+ public:
+ CleanCallback(HeapRegion* hr) : _detector(hr), _blobs(&_detector, !CodeBlobToOopClosure::FixRelocations) {}
+
+ bool operator() (nmethod* nm) {
+ _detector._points_into = false;
+ _blobs.do_code_blob(nm);
+ return _detector._points_into;
+ }
+};
+
+void G1CodeRootSet::clean(HeapRegion* owner) {
+ CleanCallback should_clean(owner);
+ if (_table != NULL) {
+ _table->remove_if(should_clean);
+ }
}
#ifndef PRODUCT
-size_t G1CodeRootChunkManager::num_chunks_handed_out() const {
- return _num_chunks_handed_out;
-}
+class G1CodeRootSetTest {
+ public:
+ static void test() {
+ {
+ G1CodeRootSet set1;
+ assert(set1.is_empty(), "Code root set must be initially empty but is not.");
+
+ assert(G1CodeRootSet::static_mem_size() == sizeof(void*),
+ err_msg("The code root set's static memory usage is incorrect, "SIZE_FORMAT" bytes", G1CodeRootSet::static_mem_size()));
+
+ set1.add((nmethod*)1);
+ assert(set1.length() == 1, err_msg("Added exactly one element, but set contains "
+ SIZE_FORMAT" elements", set1.length()));
+
+ const size_t num_to_add = (size_t)G1CodeRootSet::Threshold + 1;
+
+ for (size_t i = 1; i <= num_to_add; i++) {
+ set1.add((nmethod*)1);
+ }
+ assert(set1.length() == 1,
+ err_msg("Duplicate detection should not have increased the set size but "
+ "is "SIZE_FORMAT, set1.length()));
-size_t G1CodeRootChunkManager::num_free_chunks() const {
- return (size_t)_free_list.count();
+ for (size_t i = 2; i <= num_to_add; i++) {
+ set1.add((nmethod*)(uintptr_t)(i));
+ }
+ assert(set1.length() == num_to_add,
+ err_msg("After adding in total "SIZE_FORMAT" distinct code roots, they "
+ "need to be in the set, but there are only "SIZE_FORMAT,
+ num_to_add, set1.length()));
+
+ assert(CodeRootSetTable::_purge_list != NULL, "should have grown to large hashtable");
+
+ size_t num_popped = 0;
+ for (size_t i = 1; i <= num_to_add; i++) {
+ bool removed = set1.remove((nmethod*)i);
+ if (removed) {
+ num_popped += 1;
+ } else {
+ break;
+ }
+ }
+ assert(num_popped == num_to_add,
+ err_msg("Managed to pop "SIZE_FORMAT" code roots, but only "SIZE_FORMAT" "
+ "were added", num_popped, num_to_add));
+ assert(CodeRootSetTable::_purge_list != NULL, "should have grown to large hashtable");
+
+ G1CodeRootSet::purge();
+
+ assert(CodeRootSetTable::_purge_list == NULL, "should have purged old small tables");
+
+ }
+
+ }
+};
+
+void TestCodeCacheRemSet_test() {
+ G1CodeRootSetTest::test();
}
#endif
-
-G1CodeRootChunkManager G1CodeRootSet::_default_chunk_manager;
-
-void G1CodeRootSet::purge_chunks(size_t keep_ratio) {
- _default_chunk_manager.purge_chunks(keep_ratio);
-}
-
-size_t G1CodeRootSet::free_chunks_static_mem_size() {
- return _default_chunk_manager.static_mem_size();
-}
-
-size_t G1CodeRootSet::free_chunks_mem_size() {
- return _default_chunk_manager.fl_mem_size();
-}
-
-G1CodeRootSet::G1CodeRootSet(G1CodeRootChunkManager* manager) : _manager(manager), _list(), _length(0) {
- if (_manager == NULL) {
- _manager = &_default_chunk_manager;
- }
- _list.initialize();
- _list.set_size(G1CodeRootChunk::word_size());
-}
-
-G1CodeRootSet::~G1CodeRootSet() {
- clear();
-}
-
-void G1CodeRootSet::add(nmethod* method) {
- if (!contains(method)) {
- // Find the first chunk that isn't full.
- G1CodeRootChunk* cur = _list.head();
- while (cur != NULL) {
- if (!cur->is_full()) {
- break;
- }
- cur = cur->next();
- }
-
- // All chunks are full, get a new chunk.
- if (cur == NULL) {
- cur = new_chunk();
- _list.return_chunk_at_head(cur);
- }
-
- // Add the nmethod.
- bool result = cur->add(method);
-
- guarantee(result, err_msg("Not able to add nmethod "PTR_FORMAT" to newly allocated chunk.", method));
-
- _length++;
- }
-}
-
-void G1CodeRootSet::remove_lock_free(nmethod* method) {
- G1CodeRootChunk* found = find(method);
- if (found != NULL) {
- bool result = found->remove_lock_free(method);
- if (result) {
- Atomic::dec_ptr((volatile intptr_t*)&_length);
- }
- }
- assert(!contains(method), err_msg(PTR_FORMAT" still contains nmethod "PTR_FORMAT, this, method));
-}
-
-nmethod* G1CodeRootSet::pop() {
- while (true) {
- G1CodeRootChunk* cur = _list.head();
- if (cur == NULL) {
- assert(_length == 0, "when there are no chunks, there should be no elements");
- return NULL;
- }
- nmethod* result = cur->pop();
- if (result != NULL) {
- _length--;
- return result;
- } else {
- free(_list.get_chunk_at_head());
- }
- }
-}
-
-G1CodeRootChunk* G1CodeRootSet::find(nmethod* method) {
- G1CodeRootChunk* cur = _list.head();
- while (cur != NULL) {
- if (cur->contains(method)) {
- return cur;
- }
- cur = (G1CodeRootChunk*)cur->next();
- }
- return NULL;
-}
-
-void G1CodeRootSet::free(G1CodeRootChunk* chunk) {
- free_chunk(chunk);
-}
-
-bool G1CodeRootSet::contains(nmethod* method) {
- return find(method) != NULL;
-}
-
-void G1CodeRootSet::clear() {
- free_all_chunks(&_list);
- _length = 0;
-}
-
-void G1CodeRootSet::nmethods_do(CodeBlobClosure* blk) const {
- G1CodeRootChunk* cur = _list.head();
- while (cur != NULL) {
- cur->nmethods_do(blk);
- cur = (G1CodeRootChunk*)cur->next();
- }
-}
-
-size_t G1CodeRootSet::static_mem_size() {
- return sizeof(G1CodeRootSet);
-}
-
-size_t G1CodeRootSet::mem_size() {
- return G1CodeRootSet::static_mem_size() + _list.count() * _list.size();
-}
-
-#ifndef PRODUCT
-
-void G1CodeRootSet::test() {
- G1CodeRootChunkManager mgr;
-
- assert(mgr.num_chunks_handed_out() == 0, "Must not have handed out chunks yet");
-
- assert(G1CodeRootChunkManager::static_mem_size() > sizeof(void*),
- err_msg("The chunk manager's static memory usage seems too small, is only "SIZE_FORMAT" bytes.", G1CodeRootChunkManager::static_mem_size()));
-
- // The number of chunks that we allocate for purge testing.
- size_t const num_chunks = 10;
-
- {
- G1CodeRootSet set1(&mgr);
- assert(set1.is_empty(), "Code root set must be initially empty but is not.");
-
- assert(G1CodeRootSet::static_mem_size() > sizeof(void*),
- err_msg("The code root set's static memory usage seems too small, is only "SIZE_FORMAT" bytes", G1CodeRootSet::static_mem_size()));
-
- set1.add((nmethod*)1);
- assert(mgr.num_chunks_handed_out() == 1,
- err_msg("Must have allocated and handed out one chunk, but handed out "
- SIZE_FORMAT" chunks", mgr.num_chunks_handed_out()));
- assert(set1.length() == 1, err_msg("Added exactly one element, but set contains "
- SIZE_FORMAT" elements", set1.length()));
-
- // G1CodeRootChunk::word_size() is larger than G1CodeRootChunk::num_entries which
- // we cannot access.
- for (uint i = 0; i < G1CodeRootChunk::word_size() + 1; i++) {
- set1.add((nmethod*)1);
- }
- assert(mgr.num_chunks_handed_out() == 1,
- err_msg("Duplicate detection must have prevented allocation of further "
- "chunks but allocated "SIZE_FORMAT, mgr.num_chunks_handed_out()));
- assert(set1.length() == 1,
- err_msg("Duplicate detection should not have increased the set size but "
- "is "SIZE_FORMAT, set1.length()));
-
- size_t num_total_after_add = G1CodeRootChunk::word_size() + 1;
- for (size_t i = 0; i < num_total_after_add - 1; i++) {
- set1.add((nmethod*)(uintptr_t)(2 + i));
- }
- assert(mgr.num_chunks_handed_out() > 1,
- "After adding more code roots, more than one additional chunk should have been handed out");
- assert(set1.length() == num_total_after_add,
- err_msg("After adding in total "SIZE_FORMAT" distinct code roots, they "
- "need to be in the set, but there are only "SIZE_FORMAT,
- num_total_after_add, set1.length()));
-
- size_t num_popped = 0;
- while (set1.pop() != NULL) {
- num_popped++;
- }
- assert(num_popped == num_total_after_add,
- err_msg("Managed to pop "SIZE_FORMAT" code roots, but only "SIZE_FORMAT" "
- "were added", num_popped, num_total_after_add));
- assert(mgr.num_chunks_handed_out() == 0,
- err_msg("After popping all elements, all chunks must have been returned "
- "but there are still "SIZE_FORMAT" additional", mgr.num_chunks_handed_out()));
-
- mgr.purge_chunks(0);
- assert(mgr.num_free_chunks() == 0,
- err_msg("After purging everything, the free list must be empty but still "
- "contains "SIZE_FORMAT" chunks", mgr.num_free_chunks()));
-
- // Add some more handed out chunks.
- size_t i = 0;
- while (mgr.num_chunks_handed_out() < num_chunks) {
- set1.add((nmethod*)i);
- i++;
- }
-
- {
- // Generate chunks on the free list.
- G1CodeRootSet set2(&mgr);
- size_t i = 0;
- while (mgr.num_chunks_handed_out() < (num_chunks * 2)) {
- set2.add((nmethod*)i);
- i++;
- }
- // Exit of the scope of the set2 object will call the destructor that generates
- // num_chunks elements on the free list.
- }
-
- assert(mgr.num_chunks_handed_out() == num_chunks,
- err_msg("Deletion of the second set must have resulted in giving back "
- "those, but there are still "SIZE_FORMAT" additional handed out, expecting "
- SIZE_FORMAT, mgr.num_chunks_handed_out(), num_chunks));
- assert(mgr.num_free_chunks() == num_chunks,
- err_msg("After freeing "SIZE_FORMAT" chunks, they must be on the free list "
- "but there are only "SIZE_FORMAT, num_chunks, mgr.num_free_chunks()));
-
- size_t const test_percentage = 50;
- mgr.purge_chunks(test_percentage);
- assert(mgr.num_chunks_handed_out() == num_chunks,
- err_msg("Purging must not hand out chunks but there are "SIZE_FORMAT,
- mgr.num_chunks_handed_out()));
- assert(mgr.num_free_chunks() == (size_t)(mgr.num_chunks_handed_out() * test_percentage / 100),
- err_msg("Must have purged "SIZE_FORMAT" percent of "SIZE_FORMAT" chunks"
- "but there are "SIZE_FORMAT, test_percentage, num_chunks,
- mgr.num_free_chunks()));
- // Purge the remainder of the chunks on the free list.
- mgr.purge_chunks(0);
- assert(mgr.num_free_chunks() == 0, "Free List must be empty");
- assert(mgr.num_chunks_handed_out() == num_chunks,
- err_msg("Expected to be "SIZE_FORMAT" chunks handed out from the first set "
- "but there are "SIZE_FORMAT, num_chunks, mgr.num_chunks_handed_out()));
-
- // Exit of the scope of the set1 object will call the destructor that generates
- // num_chunks additional elements on the free list.
- }
-
- assert(mgr.num_chunks_handed_out() == 0,
- err_msg("Deletion of the only set must have resulted in no chunks handed "
- "out, but there is still "SIZE_FORMAT" handed out", mgr.num_chunks_handed_out()));
- assert(mgr.num_free_chunks() == num_chunks,
- err_msg("After freeing "SIZE_FORMAT" chunks, they must be on the free list "
- "but there are only "SIZE_FORMAT, num_chunks, mgr.num_free_chunks()));
-
- // Restore initial state.
- mgr.purge_chunks(0);
- assert(mgr.num_free_chunks() == 0, "Free List must be empty");
- assert(mgr.num_chunks_handed_out() == 0, "No additional elements must have been handed out yet");
-}
-
-void TestCodeCacheRemSet_test() {
- G1CodeRootSet::test();
-}
-#endif
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -26,222 +26,64 @@
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1CODECACHEREMSET_HPP
#include "memory/allocation.hpp"
-#include "memory/freeList.hpp"
-#include "runtime/globals.hpp"
class CodeBlobClosure;
-
-// The elements of the G1CodeRootChunk is either:
-// 1) nmethod pointers
-// 2) nodes in an internally chained free list
-typedef union {
- nmethod* _nmethod;
- void* _link;
-} NmethodOrLink;
-
-class G1CodeRootChunk : public CHeapObj<mtGC> {
- private:
- static const int NUM_ENTRIES = 32;
- public:
- G1CodeRootChunk* _next;
- G1CodeRootChunk* _prev;
-
- NmethodOrLink* _top;
- // First free position within the chunk.
- volatile NmethodOrLink* _free;
-
- NmethodOrLink _data[NUM_ENTRIES];
-
- NmethodOrLink* bottom() const {
- return (NmethodOrLink*) &(_data[0]);
- }
-
- NmethodOrLink* end() const {
- return (NmethodOrLink*) &(_data[NUM_ENTRIES]);
- }
-
- bool is_link(NmethodOrLink* nmethod_or_link) {
- return nmethod_or_link->_link == NULL ||
- (bottom() <= nmethod_or_link->_link
- && nmethod_or_link->_link < end());
- }
-
- bool is_nmethod(NmethodOrLink* nmethod_or_link) {
- return !is_link(nmethod_or_link);
- }
-
- public:
- G1CodeRootChunk();
- ~G1CodeRootChunk() {}
-
- static size_t word_size() { return (size_t)(align_size_up_(sizeof(G1CodeRootChunk), HeapWordSize) / HeapWordSize); }
-
- // FreeList "interface" methods
-
- G1CodeRootChunk* next() const { return _next; }
- G1CodeRootChunk* prev() const { return _prev; }
- void set_next(G1CodeRootChunk* v) { _next = v; assert(v != this, "Boom");}
- void set_prev(G1CodeRootChunk* v) { _prev = v; assert(v != this, "Boom");}
- void clear_next() { set_next(NULL); }
- void clear_prev() { set_prev(NULL); }
-
- size_t size() const { return word_size(); }
-
- void link_next(G1CodeRootChunk* ptr) { set_next(ptr); }
- void link_prev(G1CodeRootChunk* ptr) { set_prev(ptr); }
- void link_after(G1CodeRootChunk* ptr) {
- link_next(ptr);
- if (ptr != NULL) ptr->link_prev((G1CodeRootChunk*)this);
- }
-
- bool is_free() { return true; }
-
- // New G1CodeRootChunk routines
-
- void reset();
-
- bool is_empty() const {
- return _top == bottom();
- }
-
- bool is_full() const {
- return _top == end() && _free == NULL;
- }
-
- bool contains(nmethod* method) {
- NmethodOrLink* cur = bottom();
- while (cur != _top) {
- if (cur->_nmethod == method) return true;
- cur++;
- }
- return false;
- }
-
- bool add(nmethod* method) {
- if (is_full()) {
- return false;
- }
-
- if (_free != NULL) {
- // Take from internally chained free list
- NmethodOrLink* first_free = (NmethodOrLink*)_free;
- _free = (NmethodOrLink*)_free->_link;
- first_free->_nmethod = method;
- } else {
- // Take from top.
- _top->_nmethod = method;
- _top++;
- }
-
- return true;
- }
-
- bool remove_lock_free(nmethod* method);
-
- void nmethods_do(CodeBlobClosure* blk);
-
- nmethod* pop() {
- if (_free != NULL) {
- // Kill the free list.
- _free = NULL;
- }
-
- while (!is_empty()) {
- _top--;
- if (is_nmethod(_top)) {
- return _top->_nmethod;
- }
- }
-
- return NULL;
- }
-};
-
-// Manages free chunks.
-class G1CodeRootChunkManager VALUE_OBJ_CLASS_SPEC {
- private:
- // Global free chunk list management
- FreeList<G1CodeRootChunk> _free_list;
- // Total number of chunks handed out
- size_t _num_chunks_handed_out;
-
- public:
- G1CodeRootChunkManager();
-
- G1CodeRootChunk* new_chunk();
- void free_chunk(G1CodeRootChunk* chunk);
- // Free all elements of the given list.
- void free_all_chunks(FreeList<G1CodeRootChunk>* list);
-
- void initialize();
- void purge_chunks(size_t keep_ratio);
-
- static size_t static_mem_size();
- size_t fl_mem_size();
-
-#ifndef PRODUCT
- size_t num_chunks_handed_out() const;
- size_t num_free_chunks() const;
-#endif
-};
+class CodeRootSetTable;
+class HeapRegion;
+class nmethod;
// Implements storage for a set of code roots.
// All methods that modify the set are not thread-safe except if otherwise noted.
class G1CodeRootSet VALUE_OBJ_CLASS_SPEC {
+ friend class G1CodeRootSetTest;
private:
- // Global default free chunk manager instance.
- static G1CodeRootChunkManager _default_chunk_manager;
- G1CodeRootChunk* new_chunk() { return _manager->new_chunk(); }
- void free_chunk(G1CodeRootChunk* chunk) { _manager->free_chunk(chunk); }
- // Free all elements of the given list.
- void free_all_chunks(FreeList<G1CodeRootChunk>* list) { _manager->free_all_chunks(list); }
+ const static size_t SmallSize = 32;
+ const static size_t Threshold = 24;
+ const static size_t LargeSize = 512;
- // Return the chunk that contains the given nmethod, NULL otherwise.
- // Scans the list of chunks backwards, as this method is used to add new
- // entries, which are typically added in bulk for a single nmethod.
- G1CodeRootChunk* find(nmethod* method);
- void free(G1CodeRootChunk* chunk);
+ CodeRootSetTable* _table;
+ CodeRootSetTable* load_acquire_table();
size_t _length;
- FreeList<G1CodeRootChunk> _list;
- G1CodeRootChunkManager* _manager;
+
+ void move_to_large();
+ void allocate_small_table();
public:
- // If an instance is initialized with a chunk manager of NULL, use the global
- // default one.
- G1CodeRootSet(G1CodeRootChunkManager* manager = NULL);
+ G1CodeRootSet() : _table(NULL), _length(0) {}
~G1CodeRootSet();
- static void purge_chunks(size_t keep_ratio);
+ static void purge();
- static size_t free_chunks_static_mem_size();
- static size_t free_chunks_mem_size();
+ static size_t static_mem_size();
- // Search for the code blob from the recently allocated ones to find duplicates more quickly, as this
- // method is likely to be repeatedly called with the same nmethod.
void add(nmethod* method);
- void remove_lock_free(nmethod* method);
- nmethod* pop();
+ bool remove(nmethod* method);
+ // Safe to call without synchronization, but may return false negatives.
bool contains(nmethod* method);
void clear();
void nmethods_do(CodeBlobClosure* blk) const;
- bool is_empty() { return length() == 0; }
+ // Remove all nmethods which no longer contain pointers into our "owner" region
+ void clean(HeapRegion* owner);
+
+ bool is_empty() {
+ bool empty = length() == 0;
+ assert(empty == (_table == NULL), "is empty only if table is deallocated");
+ return empty;
+ }
// Length in elements
size_t length() const { return _length; }
- // Static data memory size in bytes of this set.
- static size_t static_mem_size();
// Memory size in bytes taken by this set.
size_t mem_size();
- static void test() PRODUCT_RETURN;
};
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1CODECACHEREMSET_HPP
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -4670,6 +4670,56 @@
}
};
+class G1CodeBlobClosure : public CodeBlobClosure {
+ class HeapRegionGatheringOopClosure : public OopClosure {
+ G1CollectedHeap* _g1h;
+ OopClosure* _work;
+ nmethod* _nm;
+
+ template <typename T>
+ void do_oop_work(T* p) {
+ _work->do_oop(p);
+ T oop_or_narrowoop = oopDesc::load_heap_oop(p);
+ if (!oopDesc::is_null(oop_or_narrowoop)) {
+ oop o = oopDesc::decode_heap_oop_not_null(oop_or_narrowoop);
+ HeapRegion* hr = _g1h->heap_region_containing_raw(o);
+ assert(!_g1h->obj_in_cs(o) || hr->rem_set()->strong_code_roots_list_contains(_nm), "if o still in CS then evacuation failed and nm must already be in the remset");
+ hr->add_strong_code_root(_nm);
+ }
+ }
+
+ public:
+ HeapRegionGatheringOopClosure(OopClosure* oc) : _g1h(G1CollectedHeap::heap()), _work(oc), _nm(NULL) {}
+
+ void do_oop(oop* o) {
+ do_oop_work(o);
+ }
+
+ void do_oop(narrowOop* o) {
+ do_oop_work(o);
+ }
+
+ void set_nm(nmethod* nm) {
+ _nm = nm;
+ }
+ };
+
+ HeapRegionGatheringOopClosure _oc;
+public:
+ G1CodeBlobClosure(OopClosure* oc) : _oc(oc) {}
+
+ void do_code_blob(CodeBlob* cb) {
+ nmethod* nm = cb->as_nmethod_or_null();
+ if (nm != NULL) {
+ if (!nm->test_set_oops_do_mark()) {
+ _oc.set_nm(nm);
+ nm->oops_do(&_oc);
+ nm->fix_oop_relocations();
+ }
+ }
+ }
+};
+
class G1ParTask : public AbstractGangTask {
protected:
G1CollectedHeap* _g1h;
@@ -4738,22 +4788,6 @@
}
};
- class G1CodeBlobClosure: public CodeBlobClosure {
- OopClosure* _f;
-
- public:
- G1CodeBlobClosure(OopClosure* f) : _f(f) {}
- void do_code_blob(CodeBlob* blob) {
- nmethod* that = blob->as_nmethod_or_null();
- if (that != NULL) {
- if (!that->test_set_oops_do_mark()) {
- that->oops_do(_f);
- that->fix_oop_relocations();
- }
- }
- }
- };
-
void work(uint worker_id) {
if (worker_id >= _n_workers) return; // no work needed this round
@@ -4944,7 +4978,7 @@
g1_policy()->phase_times()->record_satb_filtering_time(worker_i, satb_filtering_ms);
// Now scan the complement of the collection set.
- MarkingCodeBlobClosure scavenge_cs_nmethods(scan_non_heap_weak_roots, CodeBlobToOopClosure::FixRelocations);
+ G1CodeBlobClosure scavenge_cs_nmethods(scan_non_heap_weak_roots);
g1_rem_set()->oops_into_collection_set_do(scan_rs, &scavenge_cs_nmethods, worker_i);
@@ -5991,12 +6025,6 @@
hot_card_cache->reset_hot_cache();
hot_card_cache->set_use_cache(true);
- // Migrate the strong code roots attached to each region in
- // the collection set. Ideally we would like to do this
- // after we have finished the scanning/evacuation of the
- // strong code roots for a particular heap region.
- migrate_strong_code_roots();
-
purge_code_root_memory();
if (g1_policy()->during_initial_mark_pause()) {
@@ -7049,13 +7077,8 @@
" starting at "HR_FORMAT,
_nm, HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
- // HeapRegion::add_strong_code_root() avoids adding duplicate
- // entries but having duplicates is OK since we "mark" nmethods
- // as visited when we scan the strong code root lists during the GC.
- hr->add_strong_code_root(_nm);
- assert(hr->rem_set()->strong_code_roots_list_contains(_nm),
- err_msg("failed to add code root "PTR_FORMAT" to remembered set of region "HR_FORMAT,
- _nm, HR_FORMAT_PARAMS(hr)));
+ // HeapRegion::add_strong_code_root_locked() avoids adding duplicate entries.
+ hr->add_strong_code_root_locked(_nm);
}
}
@@ -7082,9 +7105,6 @@
_nm, HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
hr->remove_strong_code_root(_nm);
- assert(!hr->rem_set()->strong_code_roots_list_contains(_nm),
- err_msg("failed to remove code root "PTR_FORMAT" of region "HR_FORMAT,
- _nm, HR_FORMAT_PARAMS(hr)));
}
}
@@ -7112,28 +7132,9 @@
nm->oops_do(®_cl, true);
}
-class MigrateCodeRootsHeapRegionClosure: public HeapRegionClosure {
-public:
- bool doHeapRegion(HeapRegion *hr) {
- assert(!hr->isHumongous(),
- err_msg("humongous region "HR_FORMAT" should not have been added to collection set",
- HR_FORMAT_PARAMS(hr)));
- hr->migrate_strong_code_roots();
- return false;
- }
-};
-
-void G1CollectedHeap::migrate_strong_code_roots() {
- MigrateCodeRootsHeapRegionClosure cl;
- double migrate_start = os::elapsedTime();
- collection_set_iterate(&cl);
- double migration_time_ms = (os::elapsedTime() - migrate_start) * 1000.0;
- g1_policy()->phase_times()->record_strong_code_root_migration_time(migration_time_ms);
-}
-
void G1CollectedHeap::purge_code_root_memory() {
double purge_start = os::elapsedTime();
- G1CodeRootSet::purge_chunks(G1CodeRootsChunkCacheKeepPercent);
+ G1CodeRootSet::purge();
double purge_time_ms = (os::elapsedTime() - purge_start) * 1000.0;
g1_policy()->phase_times()->record_strong_code_root_purge_time(purge_time_ms);
}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -1662,12 +1662,6 @@
// Unregister the given nmethod from the G1 heap.
virtual void unregister_nmethod(nmethod* nm);
- // Migrate the nmethods in the code root lists of the regions
- // in the collection set to regions in to-space. In the event
- // of an evacuation failure, nmethods that reference objects
- // that were not successfully evacuated are not migrated.
- void migrate_strong_code_roots();
-
// Free up superfluous code root memory.
void purge_code_root_memory();
--- a/hotspot/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -217,6 +217,8 @@
_update_rset_cl->set_region(hr);
hr->object_iterate(&rspc);
+ hr->rem_set()->clean_strong_code_roots(hr);
+
hr->note_self_forwarding_removal_end(during_initial_mark,
during_conc_mark,
rspc.marked_bytes());
--- a/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -275,9 +275,6 @@
// Now subtract the time taken to fix up roots in generated code
misc_time_ms += _cur_collection_code_root_fixup_time_ms;
- // Strong code root migration time
- misc_time_ms += _cur_strong_code_root_migration_time_ms;
-
// Strong code root purge time
misc_time_ms += _cur_strong_code_root_purge_time_ms;
@@ -328,7 +325,6 @@
_last_obj_copy_times_ms.print(1, "Object Copy (ms)");
}
print_stats(1, "Code Root Fixup", _cur_collection_code_root_fixup_time_ms);
- print_stats(1, "Code Root Migration", _cur_strong_code_root_migration_time_ms);
print_stats(1, "Code Root Purge", _cur_strong_code_root_purge_time_ms);
if (G1StringDedup::is_enabled()) {
print_stats(1, "String Dedup Fixup", _cur_string_dedup_fixup_time_ms, _active_gc_threads);
--- a/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -129,7 +129,6 @@
double _cur_collection_par_time_ms;
double _cur_collection_code_root_fixup_time_ms;
- double _cur_strong_code_root_migration_time_ms;
double _cur_strong_code_root_purge_time_ms;
double _cur_evac_fail_recalc_used;
@@ -233,10 +232,6 @@
_cur_collection_code_root_fixup_time_ms = ms;
}
- void record_strong_code_root_migration_time(double ms) {
- _cur_strong_code_root_migration_time_ms = ms;
- }
-
void record_strong_code_root_purge_time(double ms) {
_cur_strong_code_root_purge_time_ms = ms;
}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -110,7 +110,7 @@
G1CollectedHeap* _g1h;
OopsInHeapRegionClosure* _oc;
- CodeBlobToOopClosure* _code_root_cl;
+ CodeBlobClosure* _code_root_cl;
G1BlockOffsetSharedArray* _bot_shared;
G1SATBCardTableModRefBS *_ct_bs;
@@ -122,7 +122,7 @@
public:
ScanRSClosure(OopsInHeapRegionClosure* oc,
- CodeBlobToOopClosure* code_root_cl,
+ CodeBlobClosure* code_root_cl,
uint worker_i) :
_oc(oc),
_code_root_cl(code_root_cl),
@@ -242,7 +242,7 @@
};
void G1RemSet::scanRS(OopsInHeapRegionClosure* oc,
- CodeBlobToOopClosure* code_root_cl,
+ CodeBlobClosure* code_root_cl,
uint worker_i) {
double rs_time_start = os::elapsedTime();
HeapRegion *startRegion = _g1->start_cset_region_for_worker(worker_i);
@@ -321,7 +321,7 @@
}
void G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc,
- CodeBlobToOopClosure* code_root_cl,
+ CodeBlobClosure* code_root_cl,
uint worker_i) {
#if CARD_REPEAT_HISTO
ct_freq_update_histo_and_reset();
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -96,7 +96,7 @@
// the "i" passed to the calling thread's work(i) function.
// In the sequential case this param will be ignored.
void oops_into_collection_set_do(OopsInHeapRegionClosure* blk,
- CodeBlobToOopClosure* code_root_cl,
+ CodeBlobClosure* code_root_cl,
uint worker_i);
// Prepare for and cleanup after an oops_into_collection_set_do
@@ -108,7 +108,7 @@
void cleanup_after_oops_into_collection_set_do();
void scanRS(OopsInHeapRegionClosure* oc,
- CodeBlobToOopClosure* code_root_cl,
+ CodeBlobClosure* code_root_cl,
uint worker_i);
void updateRS(DirtyCardQueue* into_cset_dcq, uint worker_i);
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -253,6 +253,7 @@
size_t occupied_cards = hrrs->occupied();
size_t code_root_mem_sz = hrrs->strong_code_roots_mem_size();
if (code_root_mem_sz > max_code_root_mem_sz()) {
+ _max_code_root_mem_sz = code_root_mem_sz;
_max_code_root_mem_sz_region = r;
}
size_t code_root_elems = hrrs->strong_code_roots_list_length();
--- a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -277,10 +277,6 @@
product(uintx, G1MixedGCCountTarget, 8, \
"The target number of mixed GCs after a marking cycle.") \
\
- experimental(uintx, G1CodeRootsChunkCacheKeepPercent, 10, \
- "The amount of code root chunks that should be kept at most " \
- "as percentage of already allocated.") \
- \
experimental(bool, G1ReclaimDeadHumongousObjectsAtYoungGC, true, \
"Try to reclaim dead large objects at every young GC.") \
\
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -540,21 +540,17 @@
hrrs->add_strong_code_root(nm);
}
+void HeapRegion::add_strong_code_root_locked(nmethod* nm) {
+ assert_locked_or_safepoint(CodeCache_lock);
+ HeapRegionRemSet* hrrs = rem_set();
+ hrrs->add_strong_code_root_locked(nm);
+}
+
void HeapRegion::remove_strong_code_root(nmethod* nm) {
HeapRegionRemSet* hrrs = rem_set();
hrrs->remove_strong_code_root(nm);
}
-void HeapRegion::migrate_strong_code_roots() {
- assert(in_collection_set(), "only collection set regions");
- assert(!isHumongous(),
- err_msg("humongous region "HR_FORMAT" should not have been added to collection set",
- HR_FORMAT_PARAMS(this)));
-
- HeapRegionRemSet* hrrs = rem_set();
- hrrs->migrate_strong_code_roots();
-}
-
void HeapRegion::strong_code_roots_do(CodeBlobClosure* blk) const {
HeapRegionRemSet* hrrs = rem_set();
hrrs->strong_code_roots_do(blk);
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -756,14 +756,9 @@
// Routines for managing a list of code roots (attached to the
// this region's RSet) that point into this heap region.
void add_strong_code_root(nmethod* nm);
+ void add_strong_code_root_locked(nmethod* nm);
void remove_strong_code_root(nmethod* nm);
- // During a collection, migrate the successfully evacuated
- // strong code roots that referenced into this region to the
- // new regions that they now point into. Unsuccessfully
- // evacuated code roots are not migrated.
- void migrate_strong_code_roots();
-
// Applies blk->do_code_blob() to each of the entries in
// the strong code roots list for this region
void strong_code_roots_do(CodeBlobClosure* blk) const;
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -448,10 +448,10 @@
// Note that this may be a continued H region.
HeapRegion* from_hr = _g1h->heap_region_containing_raw(from);
- RegionIdx_t from_hrs_ind = (RegionIdx_t) from_hr->hrm_index();
+ RegionIdx_t from_hrm_ind = (RegionIdx_t) from_hr->hrm_index();
// If the region is already coarsened, return.
- if (_coarse_map.at(from_hrs_ind)) {
+ if (_coarse_map.at(from_hrm_ind)) {
if (G1TraceHeapRegionRememberedSet) {
gclog_or_tty->print_cr(" coarse map hit.");
}
@@ -460,7 +460,7 @@
}
// Otherwise find a per-region table to add it to.
- size_t ind = from_hrs_ind & _mod_max_fine_entries_mask;
+ size_t ind = from_hrm_ind & _mod_max_fine_entries_mask;
PerRegionTable* prt = find_region_table(ind, from_hr);
if (prt == NULL) {
MutexLockerEx x(_m, Mutex::_no_safepoint_check_flag);
@@ -475,7 +475,7 @@
assert(0 <= card_index && (size_t)card_index < HeapRegion::CardsPerRegion,
"Must be in range.");
if (G1HRRSUseSparseTable &&
- _sparse_table.add_card(from_hrs_ind, card_index)) {
+ _sparse_table.add_card(from_hrm_ind, card_index)) {
if (G1RecordHRRSOops) {
HeapRegionRemSet::record(hr(), from);
if (G1TraceHeapRegionRememberedSet) {
@@ -495,7 +495,7 @@
if (G1TraceHeapRegionRememberedSet) {
gclog_or_tty->print_cr(" [tid %d] sparse table entry "
"overflow(f: %d, t: %u)",
- tid, from_hrs_ind, cur_hrm_ind);
+ tid, from_hrm_ind, cur_hrm_ind);
}
}
@@ -516,7 +516,7 @@
if (G1HRRSUseSparseTable) {
// Transfer from sparse to fine-grain.
- SparsePRTEntry *sprt_entry = _sparse_table.get_entry(from_hrs_ind);
+ SparsePRTEntry *sprt_entry = _sparse_table.get_entry(from_hrm_ind);
assert(sprt_entry != NULL, "There should have been an entry");
for (int i = 0; i < SparsePRTEntry::cards_num(); i++) {
CardIdx_t c = sprt_entry->card(i);
@@ -525,7 +525,7 @@
}
}
// Now we can delete the sparse entry.
- bool res = _sparse_table.delete_entry(from_hrs_ind);
+ bool res = _sparse_table.delete_entry(from_hrm_ind);
assert(res, "It should have been there.");
}
}
@@ -926,9 +926,25 @@
}
// Code roots support
+//
+// The code root set is protected by two separate locking schemes
+// When at safepoint the per-hrrs lock must be held during modifications
+// except when doing a full gc.
+// When not at safepoint the CodeCache_lock must be held during modifications.
+// When concurrent readers access the contains() function
+// (during the evacuation phase) no removals are allowed.
void HeapRegionRemSet::add_strong_code_root(nmethod* nm) {
assert(nm != NULL, "sanity");
+ // Optimistic unlocked contains-check
+ if (!_code_roots.contains(nm)) {
+ MutexLockerEx ml(&_m, Mutex::_no_safepoint_check_flag);
+ add_strong_code_root_locked(nm);
+ }
+}
+
+void HeapRegionRemSet::add_strong_code_root_locked(nmethod* nm) {
+ assert(nm != NULL, "sanity");
_code_roots.add(nm);
}
@@ -936,96 +952,19 @@
assert(nm != NULL, "sanity");
assert_locked_or_safepoint(CodeCache_lock);
- _code_roots.remove_lock_free(nm);
+ MutexLockerEx ml(CodeCache_lock->owned_by_self() ? NULL : &_m, Mutex::_no_safepoint_check_flag);
+ _code_roots.remove(nm);
// Check that there were no duplicates
guarantee(!_code_roots.contains(nm), "duplicate entry found");
}
-class NMethodMigrationOopClosure : public OopClosure {
- G1CollectedHeap* _g1h;
- HeapRegion* _from;
- nmethod* _nm;
-
- uint _num_self_forwarded;
-
- template <class T> void do_oop_work(T* p) {
- T heap_oop = oopDesc::load_heap_oop(p);
- if (!oopDesc::is_null(heap_oop)) {
- oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
- if (_from->is_in(obj)) {
- // Reference still points into the source region.
- // Since roots are immediately evacuated this means that
- // we must have self forwarded the object
- assert(obj->is_forwarded(),
- err_msg("code roots should be immediately evacuated. "
- "Ref: "PTR_FORMAT", "
- "Obj: "PTR_FORMAT", "
- "Region: "HR_FORMAT,
- p, (void*) obj, HR_FORMAT_PARAMS(_from)));
- assert(obj->forwardee() == obj,
- err_msg("not self forwarded? obj = "PTR_FORMAT, (void*)obj));
-
- // The object has been self forwarded.
- // Note, if we're during an initial mark pause, there is
- // no need to explicitly mark object. It will be marked
- // during the regular evacuation failure handling code.
- _num_self_forwarded++;
- } else {
- // The reference points into a promotion or to-space region
- HeapRegion* to = _g1h->heap_region_containing(obj);
- to->rem_set()->add_strong_code_root(_nm);
- }
- }
- }
-
-public:
- NMethodMigrationOopClosure(G1CollectedHeap* g1h, HeapRegion* from, nmethod* nm):
- _g1h(g1h), _from(from), _nm(nm), _num_self_forwarded(0) {}
-
- void do_oop(narrowOop* p) { do_oop_work(p); }
- void do_oop(oop* p) { do_oop_work(p); }
-
- uint retain() { return _num_self_forwarded > 0; }
-};
-
-void HeapRegionRemSet::migrate_strong_code_roots() {
- assert(hr()->in_collection_set(), "only collection set regions");
- assert(!hr()->isHumongous(),
- err_msg("humongous region "HR_FORMAT" should not have been added to the collection set",
- HR_FORMAT_PARAMS(hr())));
-
- ResourceMark rm;
-
- // List of code blobs to retain for this region
- GrowableArray<nmethod*> to_be_retained(10);
- G1CollectedHeap* g1h = G1CollectedHeap::heap();
-
- while (!_code_roots.is_empty()) {
- nmethod *nm = _code_roots.pop();
- if (nm != NULL) {
- NMethodMigrationOopClosure oop_cl(g1h, hr(), nm);
- nm->oops_do(&oop_cl);
- if (oop_cl.retain()) {
- to_be_retained.push(nm);
- }
- }
- }
-
- // Now push any code roots we need to retain
- assert(to_be_retained.is_empty() || hr()->evacuation_failed(),
- "Retained nmethod list must be empty or "
- "evacuation of this region failed");
-
- while (to_be_retained.is_nonempty()) {
- nmethod* nm = to_be_retained.pop();
- assert(nm != NULL, "sanity");
- add_strong_code_root(nm);
- }
+void HeapRegionRemSet::strong_code_roots_do(CodeBlobClosure* blk) const {
+ _code_roots.nmethods_do(blk);
}
-void HeapRegionRemSet::strong_code_roots_do(CodeBlobClosure* blk) const {
- _code_roots.nmethods_do(blk);
+void HeapRegionRemSet::clean_strong_code_roots(HeapRegion* hr) {
+ _code_roots.clean(hr);
}
size_t HeapRegionRemSet::strong_code_roots_mem_size() {
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -349,13 +349,13 @@
// Returns the memory occupancy of all static data structures associated
// with remembered sets.
static size_t static_mem_size() {
- return OtherRegionsTable::static_mem_size() + G1CodeRootSet::free_chunks_static_mem_size();
+ return OtherRegionsTable::static_mem_size() + G1CodeRootSet::static_mem_size();
}
// Returns the memory occupancy of all free_list data structures associated
// with remembered sets.
static size_t fl_mem_size() {
- return OtherRegionsTable::fl_mem_size() + G1CodeRootSet::free_chunks_mem_size();
+ return OtherRegionsTable::fl_mem_size();
}
bool contains_reference(OopOrNarrowOopStar from) const {
@@ -365,18 +365,15 @@
// Routines for managing the list of code roots that point into
// the heap region that owns this RSet.
void add_strong_code_root(nmethod* nm);
+ void add_strong_code_root_locked(nmethod* nm);
void remove_strong_code_root(nmethod* nm);
- // During a collection, migrate the successfully evacuated strong
- // code roots that referenced into the region that owns this RSet
- // to the RSets of the new regions that they now point into.
- // Unsuccessfully evacuated code roots are not migrated.
- void migrate_strong_code_roots();
-
// Applies blk->do_code_blob() to each of the entries in
// the strong code roots list
void strong_code_roots_do(CodeBlobClosure* blk) const;
+ void clean_strong_code_roots(HeapRegion* hr);
+
// Returns the number of elements in the strong code roots list
size_t strong_code_roots_list_length() const {
return _code_roots.length();
--- a/hotspot/src/share/vm/interpreter/interpreter.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/interpreter/interpreter.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -55,7 +55,9 @@
public:
// Initialization/finalization
void initialize(int size,
- CodeStrings& strings) { _size = size; DEBUG_ONLY(_strings.assign(strings);) }
+ CodeStrings& strings) { _size = size;
+ DEBUG_ONLY(::new(&_strings) CodeStrings();)
+ DEBUG_ONLY(_strings.assign(strings);) }
void finalize() { ShouldNotCallThis(); }
// General info/converters
--- a/hotspot/src/share/vm/memory/freeList.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/memory/freeList.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -34,7 +34,6 @@
#if INCLUDE_ALL_GCS
#include "gc_implementation/concurrentMarkSweep/freeChunk.hpp"
-#include "gc_implementation/g1/g1CodeCacheRemSet.hpp"
#endif // INCLUDE_ALL_GCS
// Free list. A FreeList is used to access a linked list of chunks
@@ -333,5 +332,4 @@
template class FreeList<Metachunk>;
#if INCLUDE_ALL_GCS
template class FreeList<FreeChunk>;
-template class FreeList<G1CodeRootChunk>;
#endif // INCLUDE_ALL_GCS
--- a/hotspot/src/share/vm/memory/metaspaceShared.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/memory/metaspaceShared.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -41,7 +41,7 @@
#define SET_ESTIMATED_SIZE(type, region) \
Shared ##region## Size = FLAG_IS_DEFAULT(Shared ##region## Size) ? \
- (type ## SharedArchiveSize * region ## RegionPercentage) : Shared ## region ## Size
+ (uintx)(type ## SharedArchiveSize * region ## RegionPercentage) : Shared ## region ## Size
class FileMapInfo;
--- a/hotspot/src/share/vm/oops/arrayKlass.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/oops/arrayKlass.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -78,7 +78,6 @@
set_dimension(1);
set_higher_dimension(NULL);
set_lower_dimension(NULL);
- set_component_mirror(NULL);
// Arrays don't add any new methods, so their vtable is the same size as
// the vtable of klass Object.
int vtable_size = Universe::base_vtable_size();
@@ -160,14 +159,6 @@
}
}
-// GC support
-
-void ArrayKlass::oops_do(OopClosure* cl) {
- Klass::oops_do(cl);
-
- cl->do_oop(adr_component_mirror());
-}
-
// JVM support
jint ArrayKlass::compute_modifier_flags(TRAPS) const {
@@ -182,8 +173,6 @@
void ArrayKlass::remove_unshareable_info() {
Klass::remove_unshareable_info();
- // Clear the java mirror
- set_component_mirror(NULL);
}
void ArrayKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
@@ -217,10 +206,6 @@
void ArrayKlass::verify_on(outputStream* st) {
Klass::verify_on(st);
-
- if (component_mirror() != NULL) {
- guarantee(component_mirror()->klass() != NULL, "should have a class");
- }
}
void ArrayKlass::oop_verify_on(oop obj, outputStream* st) {
--- a/hotspot/src/share/vm/oops/arrayKlass.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/oops/arrayKlass.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -39,7 +39,6 @@
Klass* volatile _higher_dimension; // Refers the (n+1)'th-dimensional array (if present).
Klass* volatile _lower_dimension; // Refers the (n-1)'th-dimensional array (if present).
int _vtable_len; // size of vtable for this klass
- oop _component_mirror; // component type, as a java/lang/Class
protected:
// Constructors
@@ -70,13 +69,6 @@
// type of elements (T_OBJECT for both oop arrays and array-arrays)
BasicType element_type() const { return layout_helper_element_type(layout_helper()); }
- oop component_mirror() const { return _component_mirror; }
- void set_component_mirror(oop m) { klass_oop_store(&_component_mirror, m); }
- oop* adr_component_mirror() { return (oop*)&this->_component_mirror;}
-
- // Compiler/Interpreter offset
- static ByteSize component_mirror_offset() { return in_ByteSize(offset_of(ArrayKlass, _component_mirror)); }
-
virtual Klass* java_super() const;//{ return SystemDictionary::Object_klass(); }
// Allocation
@@ -122,9 +114,6 @@
void array_klasses_do(void f(Klass* k));
void array_klasses_do(void f(Klass* k, TRAPS), TRAPS);
- // GC support
- virtual void oops_do(OopClosure* cl);
-
// Return a handle.
static void complete_create_array_klass(ArrayKlass* k, KlassHandle super_klass, TRAPS);
--- a/hotspot/src/share/vm/oops/instanceKlass.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/oops/instanceKlass.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -460,6 +460,8 @@
oop InstanceKlass::init_lock() const {
// return the init lock from the mirror
oop lock = java_lang_Class::init_lock(java_mirror());
+ // Prevent reordering with any access of initialization state
+ OrderAccess::loadload();
assert((oop)lock != NULL || !is_not_initialized(), // initialized or in_error state
"only fully initialized state can have a null lock");
return lock;
@@ -2437,16 +2439,6 @@
assert(breakpoints() == 0x0, "should have cleared breakpoints");
}
- // deallocate information about previous versions
- if (_previous_versions != NULL) {
- for (int i = _previous_versions->length() - 1; i >= 0; i--) {
- PreviousVersionNode * pv_node = _previous_versions->at(i);
- delete pv_node;
- }
- delete _previous_versions;
- _previous_versions = NULL;
- }
-
// deallocate the cached class file
if (_cached_class_file != NULL) {
os::free(_cached_class_file, mtClass);
@@ -3020,16 +3012,17 @@
st->print(BULLET"field type annotations: "); fields_type_annotations()->print_value_on(st); st->cr();
{
bool have_pv = false;
- PreviousVersionWalker pvw(Thread::current(), (InstanceKlass*)this);
- for (PreviousVersionNode * pv_node = pvw.next_previous_version();
- pv_node != NULL; pv_node = pvw.next_previous_version()) {
+ // previous versions are linked together through the InstanceKlass
+ for (InstanceKlass* pv_node = _previous_versions;
+ pv_node != NULL;
+ pv_node = pv_node->previous_versions()) {
if (!have_pv)
st->print(BULLET"previous version: ");
have_pv = true;
- pv_node->prev_constant_pool()->print_value_on(st);
+ pv_node->constants()->print_value_on(st);
}
if (have_pv) st->cr();
- } // pvw is cleaned up
+ }
if (generic_signature() != NULL) {
st->print(BULLET"generic signature: ");
@@ -3443,92 +3436,92 @@
// RedefineClasses() support for previous versions:
// Purge previous versions
-static void purge_previous_versions_internal(InstanceKlass* ik, int emcp_method_count) {
+void InstanceKlass::purge_previous_versions(InstanceKlass* ik) {
if (ik->previous_versions() != NULL) {
// This klass has previous versions so see what we can cleanup
// while it is safe to do so.
int deleted_count = 0; // leave debugging breadcrumbs
int live_count = 0;
- ClassLoaderData* loader_data = ik->class_loader_data() == NULL ?
- ClassLoaderData::the_null_class_loader_data() :
- ik->class_loader_data();
+ ClassLoaderData* loader_data = ik->class_loader_data();
+ assert(loader_data != NULL, "should never be null");
// RC_TRACE macro has an embedded ResourceMark
- RC_TRACE(0x00000200, ("purge: %s: previous version length=%d",
- ik->external_name(), ik->previous_versions()->length()));
-
- for (int i = ik->previous_versions()->length() - 1; i >= 0; i--) {
- // check the previous versions array
- PreviousVersionNode * pv_node = ik->previous_versions()->at(i);
- ConstantPool* cp_ref = pv_node->prev_constant_pool();
- assert(cp_ref != NULL, "cp ref was unexpectedly cleared");
-
- ConstantPool* pvcp = cp_ref;
+ RC_TRACE(0x00000200, ("purge: %s: previous versions", ik->external_name()));
+
+ // previous versions are linked together through the InstanceKlass
+ InstanceKlass* pv_node = ik->previous_versions();
+ InstanceKlass* last = ik;
+ int version = 0;
+
+ // check the previous versions list
+ for (; pv_node != NULL; ) {
+
+ ConstantPool* pvcp = pv_node->constants();
+ assert(pvcp != NULL, "cp ref was unexpectedly cleared");
+
if (!pvcp->on_stack()) {
// If the constant pool isn't on stack, none of the methods
- // are executing. Delete all the methods, the constant pool and
- // and this previous version node.
- GrowableArray<Method*>* method_refs = pv_node->prev_EMCP_methods();
- if (method_refs != NULL) {
- for (int j = method_refs->length() - 1; j >= 0; j--) {
- Method* method = method_refs->at(j);
- assert(method != NULL, "method ref was unexpectedly cleared");
- method_refs->remove_at(j);
- // method will be freed with associated class.
- }
- }
- // Remove the constant pool
- delete pv_node;
- // Since we are traversing the array backwards, we don't have to
- // do anything special with the index.
- ik->previous_versions()->remove_at(i);
+ // are executing. Unlink this previous_version.
+ // The previous version InstanceKlass is on the ClassLoaderData deallocate list
+ // so will be deallocated during the next phase of class unloading.
+ pv_node = pv_node->previous_versions();
+ last->link_previous_versions(pv_node);
deleted_count++;
+ version++;
continue;
} else {
- RC_TRACE(0x00000200, ("purge: previous version @%d is alive", i));
+ RC_TRACE(0x00000200, ("purge: previous version " INTPTR_FORMAT " is alive",
+ pv_node));
assert(pvcp->pool_holder() != NULL, "Constant pool with no holder");
guarantee (!loader_data->is_unloading(), "unloaded classes can't be on the stack");
live_count++;
}
- // At least one method is live in this previous version, clean out
- // the others or mark them as obsolete.
- GrowableArray<Method*>* method_refs = pv_node->prev_EMCP_methods();
+ // At least one method is live in this previous version so clean its MethodData.
+ // Reset dead EMCP methods not to get breakpoints.
+ // All methods are deallocated when all of the methods for this class are no
+ // longer running.
+ Array<Method*>* method_refs = pv_node->methods();
if (method_refs != NULL) {
RC_TRACE(0x00000200, ("purge: previous methods length=%d",
method_refs->length()));
- for (int j = method_refs->length() - 1; j >= 0; j--) {
+ for (int j = 0; j < method_refs->length(); j++) {
Method* method = method_refs->at(j);
- assert(method != NULL, "method ref was unexpectedly cleared");
-
- // Remove the emcp method if it's not executing
- // If it's been made obsolete by a redefinition of a non-emcp
- // method, mark it as obsolete but leave it to clean up later.
+
if (!method->on_stack()) {
- method_refs->remove_at(j);
- } else if (emcp_method_count == 0) {
- method->set_is_obsolete();
+ // no breakpoints for non-running methods
+ if (method->is_running_emcp()) {
+ method->set_running_emcp(false);
+ }
} else {
+ assert (method->is_obsolete() || method->is_running_emcp(),
+ "emcp method cannot run after emcp bit is cleared");
// RC_TRACE macro has an embedded ResourceMark
RC_TRACE(0x00000200,
("purge: %s(%s): prev method @%d in version @%d is alive",
method->name()->as_C_string(),
- method->signature()->as_C_string(), j, i));
+ method->signature()->as_C_string(), j, version));
if (method->method_data() != NULL) {
- // Clean out any weak method links
+ // Clean out any weak method links for running methods
+ // (also should include not EMCP methods)
method->method_data()->clean_weak_method_links();
}
}
}
}
+ // next previous version
+ last = pv_node;
+ pv_node = pv_node->previous_versions();
+ version++;
}
- assert(ik->previous_versions()->length() == live_count, "sanity check");
RC_TRACE(0x00000200,
("purge: previous version stats: live=%d, deleted=%d", live_count,
deleted_count));
}
+ // Clean MethodData of this class's methods so they don't refer to
+ // old methods that are no longer running.
Array<Method*>* methods = ik->methods();
int num_methods = methods->length();
for (int index2 = 0; index2 < num_methods; ++index2) {
@@ -3538,122 +3531,30 @@
}
}
-// External interface for use during class unloading.
-void InstanceKlass::purge_previous_versions(InstanceKlass* ik) {
- // Call with >0 emcp methods since they are not currently being redefined.
- purge_previous_versions_internal(ik, 1);
-}
-
-
-// Potentially add an information node that contains pointers to the
-// interesting parts of the previous version of the_class.
-// This is also where we clean out any unused references.
-// Note that while we delete nodes from the _previous_versions
-// array, we never delete the array itself until the klass is
-// unloaded. The has_been_redefined() query depends on that fact.
-//
-void InstanceKlass::add_previous_version(instanceKlassHandle ikh,
- BitMap* emcp_methods, int emcp_method_count) {
- assert(Thread::current()->is_VM_thread(),
- "only VMThread can add previous versions");
-
- if (_previous_versions == NULL) {
- // This is the first previous version so make some space.
- // Start with 2 elements under the assumption that the class
- // won't be redefined much.
- _previous_versions = new (ResourceObj::C_HEAP, mtClass)
- GrowableArray<PreviousVersionNode *>(2, true);
- }
-
- ConstantPool* cp_ref = ikh->constants();
-
- // RC_TRACE macro has an embedded ResourceMark
- RC_TRACE(0x00000400, ("adding previous version ref for %s @%d, EMCP_cnt=%d "
- "on_stack=%d",
- ikh->external_name(), _previous_versions->length(), emcp_method_count,
- cp_ref->on_stack()));
-
- // If the constant pool for this previous version of the class
- // is not marked as being on the stack, then none of the methods
- // in this previous version of the class are on the stack so
- // we don't need to create a new PreviousVersionNode. However,
- // we still need to examine older previous versions below.
- Array<Method*>* old_methods = ikh->methods();
-
- if (cp_ref->on_stack()) {
- PreviousVersionNode * pv_node = NULL;
- if (emcp_method_count == 0) {
- // non-shared ConstantPool gets a reference
- pv_node = new PreviousVersionNode(cp_ref, NULL);
- RC_TRACE(0x00000400,
- ("add: all methods are obsolete; flushing any EMCP refs"));
- } else {
- int local_count = 0;
- GrowableArray<Method*>* method_refs = new (ResourceObj::C_HEAP, mtClass)
- GrowableArray<Method*>(emcp_method_count, true);
- for (int i = 0; i < old_methods->length(); i++) {
- if (emcp_methods->at(i)) {
- // this old method is EMCP. Save it only if it's on the stack
- Method* old_method = old_methods->at(i);
- if (old_method->on_stack()) {
- method_refs->append(old_method);
- }
- if (++local_count >= emcp_method_count) {
- // no more EMCP methods so bail out now
- break;
- }
- }
- }
- // non-shared ConstantPool gets a reference
- pv_node = new PreviousVersionNode(cp_ref, method_refs);
- }
- // append new previous version.
- _previous_versions->append(pv_node);
- }
-
- // Since the caller is the VMThread and we are at a safepoint, this
- // is a good time to clear out unused references.
-
- RC_TRACE(0x00000400, ("add: previous version length=%d",
- _previous_versions->length()));
-
- // Purge previous versions not executing on the stack
- purge_previous_versions_internal(this, emcp_method_count);
-
+void InstanceKlass::mark_newly_obsolete_methods(Array<Method*>* old_methods,
+ int emcp_method_count) {
int obsolete_method_count = old_methods->length() - emcp_method_count;
if (emcp_method_count != 0 && obsolete_method_count != 0 &&
- _previous_versions->length() > 0) {
+ _previous_versions != NULL) {
// We have a mix of obsolete and EMCP methods so we have to
// clear out any matching EMCP method entries the hard way.
int local_count = 0;
for (int i = 0; i < old_methods->length(); i++) {
- if (!emcp_methods->at(i)) {
+ Method* old_method = old_methods->at(i);
+ if (old_method->is_obsolete()) {
// only obsolete methods are interesting
- Method* old_method = old_methods->at(i);
Symbol* m_name = old_method->name();
Symbol* m_signature = old_method->signature();
- // we might not have added the last entry
- for (int j = _previous_versions->length() - 1; j >= 0; j--) {
- // check the previous versions array for non executing obsolete methods
- PreviousVersionNode * pv_node = _previous_versions->at(j);
-
- GrowableArray<Method*>* method_refs = pv_node->prev_EMCP_methods();
- if (method_refs == NULL) {
- // We have run into a PreviousVersion generation where
- // all methods were made obsolete during that generation's
- // RedefineClasses() operation. At the time of that
- // operation, all EMCP methods were flushed so we don't
- // have to go back any further.
- //
- // A NULL method_refs is different than an empty method_refs.
- // We cannot infer any optimizations about older generations
- // from an empty method_refs for the current generation.
- break;
- }
-
- for (int k = method_refs->length() - 1; k >= 0; k--) {
+ // previous versions are linked together through the InstanceKlass
+ int j = 0;
+ for (InstanceKlass* prev_version = _previous_versions;
+ prev_version != NULL;
+ prev_version = prev_version->previous_versions(), j++) {
+
+ Array<Method*>* method_refs = prev_version->methods();
+ for (int k = 0; k < method_refs->length(); k++) {
Method* method = method_refs->at(k);
if (!method->is_obsolete() &&
@@ -3661,14 +3562,11 @@
method->signature() == m_signature) {
// The current RedefineClasses() call has made all EMCP
// versions of this method obsolete so mark it as obsolete
- // and remove the reference.
RC_TRACE(0x00000400,
("add: %s(%s): flush obsolete method @%d in version @%d",
m_name->as_C_string(), m_signature->as_C_string(), k, j));
method->set_is_obsolete();
- // Leave obsolete methods on the previous version list to
- // clean up later.
break;
}
}
@@ -3676,9 +3574,9 @@
// The previous loop may not find a matching EMCP method, but
// that doesn't mean that we can optimize and not go any
// further back in the PreviousVersion generations. The EMCP
- // method for this generation could have already been deleted,
+ // method for this generation could have already been made obsolete,
// but there still may be an older EMCP method that has not
- // been deleted.
+ // been made obsolete.
}
if (++local_count >= obsolete_method_count) {
@@ -3688,15 +3586,69 @@
}
}
}
+}
+
+// Save the scratch_class as the previous version if any of the methods are running.
+// The previous_versions are used to set breakpoints in EMCP methods and they are
+// also used to clean MethodData links to redefined methods that are no longer running.
+void InstanceKlass::add_previous_version(instanceKlassHandle scratch_class,
+ int emcp_method_count) {
+ assert(Thread::current()->is_VM_thread(),
+ "only VMThread can add previous versions");
+
+ // RC_TRACE macro has an embedded ResourceMark
+ RC_TRACE(0x00000400, ("adding previous version ref for %s, EMCP_cnt=%d",
+ scratch_class->external_name(), emcp_method_count));
+
+ // Clean out old previous versions
+ purge_previous_versions(this);
+
+ // Mark newly obsolete methods in remaining previous versions. An EMCP method from
+ // a previous redefinition may be made obsolete by this redefinition.
+ Array<Method*>* old_methods = scratch_class->methods();
+ mark_newly_obsolete_methods(old_methods, emcp_method_count);
+
+ // If the constant pool for this previous version of the class
+ // is not marked as being on the stack, then none of the methods
+ // in this previous version of the class are on the stack so
+ // we don't need to add this as a previous version.
+ ConstantPool* cp_ref = scratch_class->constants();
+ if (!cp_ref->on_stack()) {
+ RC_TRACE(0x00000400, ("add: scratch class not added; no methods are running"));
+ return;
+ }
+
+ if (emcp_method_count != 0) {
+ // At least one method is still running, check for EMCP methods
+ for (int i = 0; i < old_methods->length(); i++) {
+ Method* old_method = old_methods->at(i);
+ if (!old_method->is_obsolete() && old_method->on_stack()) {
+ // if EMCP method (not obsolete) is on the stack, mark as EMCP so that
+ // we can add breakpoints for it.
+
+ // We set the method->on_stack bit during safepoints for class redefinition and
+ // class unloading and use this bit to set the is_running_emcp bit.
+ // After the safepoint, the on_stack bit is cleared and the running emcp
+ // method may exit. If so, we would set a breakpoint in a method that
+ // is never reached, but this won't be noticeable to the programmer.
+ old_method->set_running_emcp(true);
+ RC_TRACE(0x00000400, ("add: EMCP method %s is on_stack " INTPTR_FORMAT,
+ old_method->name_and_sig_as_C_string(), old_method));
+ } else if (!old_method->is_obsolete()) {
+ RC_TRACE(0x00000400, ("add: EMCP method %s is NOT on_stack " INTPTR_FORMAT,
+ old_method->name_and_sig_as_C_string(), old_method));
+ }
+ }
+ }
+
+ // Add previous version if any methods are still running.
+ RC_TRACE(0x00000400, ("add: scratch class added; one of its methods is on_stack"));
+ assert(scratch_class->previous_versions() == NULL, "shouldn't have a previous version");
+ scratch_class->link_previous_versions(previous_versions());
+ link_previous_versions(scratch_class());
} // end add_previous_version()
-// Determine if InstanceKlass has a previous version.
-bool InstanceKlass::has_previous_version() const {
- return (_previous_versions != NULL && _previous_versions->length() > 0);
-} // end has_previous_version()
-
-
Method* InstanceKlass::method_with_idnum(int idnum) {
Method* m = NULL;
if (idnum < methods()->length()) {
@@ -3722,61 +3674,3 @@
unsigned char * InstanceKlass::get_cached_class_file_bytes() {
return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
}
-
-
-// Construct a PreviousVersionNode entry for the array hung off
-// the InstanceKlass.
-PreviousVersionNode::PreviousVersionNode(ConstantPool* prev_constant_pool,
- GrowableArray<Method*>* prev_EMCP_methods) {
-
- _prev_constant_pool = prev_constant_pool;
- _prev_EMCP_methods = prev_EMCP_methods;
-}
-
-
-// Destroy a PreviousVersionNode
-PreviousVersionNode::~PreviousVersionNode() {
- if (_prev_constant_pool != NULL) {
- _prev_constant_pool = NULL;
- }
-
- if (_prev_EMCP_methods != NULL) {
- delete _prev_EMCP_methods;
- }
-}
-
-// Construct a helper for walking the previous versions array
-PreviousVersionWalker::PreviousVersionWalker(Thread* thread, InstanceKlass *ik) {
- _thread = thread;
- _previous_versions = ik->previous_versions();
- _current_index = 0;
- _current_p = NULL;
- _current_constant_pool_handle = constantPoolHandle(thread, ik->constants());
-}
-
-
-// Return the interesting information for the next previous version
-// of the klass. Returns NULL if there are no more previous versions.
-PreviousVersionNode* PreviousVersionWalker::next_previous_version() {
- if (_previous_versions == NULL) {
- // no previous versions so nothing to return
- return NULL;
- }
-
- _current_p = NULL; // reset to NULL
- _current_constant_pool_handle = NULL;
-
- int length = _previous_versions->length();
-
- while (_current_index < length) {
- PreviousVersionNode * pv_node = _previous_versions->at(_current_index++);
-
- // Save a handle to the constant pool for this previous version,
- // which keeps all the methods from being deallocated.
- _current_constant_pool_handle = constantPoolHandle(_thread, pv_node->prev_constant_pool());
- _current_p = pv_node;
- return pv_node;
- }
-
- return NULL;
-} // end next_previous_version()
--- a/hotspot/src/share/vm/oops/instanceKlass.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/oops/instanceKlass.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -59,7 +59,6 @@
class fieldDescriptor;
class DepChange;
class nmethodBucket;
-class PreviousVersionNode;
class JvmtiCachedClassFieldMap;
class MemberNameTable;
@@ -205,7 +204,8 @@
_misc_should_verify_class = 1 << 2, // allow caching of preverification
_misc_is_anonymous = 1 << 3, // has embedded _host_klass field
_misc_is_contended = 1 << 4, // marked with contended annotation
- _misc_has_default_methods = 1 << 5 // class/superclass/implemented interfaces has default methods
+ _misc_has_default_methods = 1 << 5, // class/superclass/implemented interfaces has default methods
+ _misc_has_been_redefined = 1 << 6 // class has been redefined
};
u2 _misc_flags;
u2 _minor_version; // minor version number of class file
@@ -220,9 +220,8 @@
nmethodBucket* _dependencies; // list of dependent nmethods
nmethod* _osr_nmethods_head; // Head of list of on-stack replacement nmethods for this class
BreakpointInfo* _breakpoints; // bpt lists, managed by Method*
- // Array of interesting part(s) of the previous version(s) of this
- // InstanceKlass. See PreviousVersionWalker below.
- GrowableArray<PreviousVersionNode *>* _previous_versions;
+ // Linked instanceKlasses of previous versions
+ InstanceKlass* _previous_versions;
// JVMTI fields can be moved to their own structure - see 6315920
// JVMTI: cached class file, before retransformable agent modified it in CFLH
JvmtiCachedClassFileData* _cached_class_file;
@@ -608,19 +607,20 @@
}
// RedefineClasses() support for previous versions:
- void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods,
- int emcp_method_count);
- // If the _previous_versions array is non-NULL, then this klass
- // has been redefined at least once even if we aren't currently
- // tracking a previous version.
- bool has_been_redefined() const { return _previous_versions != NULL; }
- bool has_previous_version() const;
+ void add_previous_version(instanceKlassHandle ikh, int emcp_method_count);
+
+ InstanceKlass* previous_versions() const { return _previous_versions; }
+
+ bool has_been_redefined() const {
+ return (_misc_flags & _misc_has_been_redefined) != 0;
+ }
+ void set_has_been_redefined() {
+ _misc_flags |= _misc_has_been_redefined;
+ }
+
void init_previous_versions() {
_previous_versions = NULL;
}
- GrowableArray<PreviousVersionNode *>* previous_versions() const {
- return _previous_versions;
- }
static void purge_previous_versions(InstanceKlass* ik);
@@ -1042,6 +1042,10 @@
// Free CHeap allocated fields.
void release_C_heap_structures();
+
+ // RedefineClasses support
+ void link_previous_versions(InstanceKlass* pv) { _previous_versions = pv; }
+ void mark_newly_obsolete_methods(Array<Method*>* old_methods, int emcp_method_count);
public:
// CDS support - remove and restore oops from metadata. Oops are not shared.
virtual void remove_unshareable_info();
@@ -1141,62 +1145,6 @@
};
-// If breakpoints are more numerous than just JVMTI breakpoints,
-// consider compressing this data structure.
-// It is currently a simple linked list defined in method.hpp.
-
-class BreakpointInfo;
-
-
-// A collection point for interesting information about the previous
-// version(s) of an InstanceKlass. A GrowableArray of PreviousVersionNodes
-// is attached to the InstanceKlass as needed. See PreviousVersionWalker below.
-class PreviousVersionNode : public CHeapObj<mtClass> {
- private:
- ConstantPool* _prev_constant_pool;
-
- // If the previous version of the InstanceKlass doesn't have any
- // EMCP methods, then _prev_EMCP_methods will be NULL. If all the
- // EMCP methods have been collected, then _prev_EMCP_methods can
- // have a length of zero.
- GrowableArray<Method*>* _prev_EMCP_methods;
-
-public:
- PreviousVersionNode(ConstantPool* prev_constant_pool,
- GrowableArray<Method*>* prev_EMCP_methods);
- ~PreviousVersionNode();
- ConstantPool* prev_constant_pool() const {
- return _prev_constant_pool;
- }
- GrowableArray<Method*>* prev_EMCP_methods() const {
- return _prev_EMCP_methods;
- }
-};
-
-
-// Helper object for walking previous versions.
-class PreviousVersionWalker : public StackObj {
- private:
- Thread* _thread;
- GrowableArray<PreviousVersionNode *>* _previous_versions;
- int _current_index;
-
- // A pointer to the current node object so we can handle the deletes.
- PreviousVersionNode* _current_p;
-
- // The constant pool handle keeps all the methods in this class from being
- // deallocated from the metaspace during class unloading.
- constantPoolHandle _current_constant_pool_handle;
-
- public:
- PreviousVersionWalker(Thread* thread, InstanceKlass *ik);
-
- // Return the interesting information for the next previous version
- // of the klass. Returns NULL if there are no more previous versions.
- PreviousVersionNode* next_previous_version();
-};
-
-
//
// nmethodBucket is used to record dependent nmethods for
// deoptimization. nmethod dependencies are actually <klass, method>
--- a/hotspot/src/share/vm/oops/klass.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/oops/klass.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -565,7 +565,7 @@
TRACE_DEFINE_KLASS_METHODS;
// garbage collection support
- virtual void oops_do(OopClosure* cl);
+ void oops_do(OopClosure* cl);
// Iff the class loader (or mirror for anonymous classes) is alive the
// Klass is considered alive.
--- a/hotspot/src/share/vm/oops/method.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/oops/method.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -80,7 +80,8 @@
_caller_sensitive = 1 << 1,
_force_inline = 1 << 2,
_dont_inline = 1 << 3,
- _hidden = 1 << 4
+ _hidden = 1 << 4,
+ _running_emcp = 1 << 5
};
u1 _flags;
@@ -688,6 +689,21 @@
void set_is_obsolete() { _access_flags.set_is_obsolete(); }
bool is_deleted() const { return access_flags().is_deleted(); }
void set_is_deleted() { _access_flags.set_is_deleted(); }
+
+ bool is_running_emcp() const {
+ // EMCP methods are old but not obsolete or deleted. Equivalent
+ // Modulo Constant Pool means the method is equivalent except
+ // the constant pool and instructions that access the constant
+ // pool might be different.
+ // If a breakpoint is set in a redefined method, its EMCP methods that are
+ // still running must have a breakpoint also.
+ return (_flags & _running_emcp) != 0;
+ }
+
+ void set_running_emcp(bool x) {
+ _flags = x ? (_flags | _running_emcp) : (_flags & ~_running_emcp);
+ }
+
bool on_stack() const { return access_flags().on_stack(); }
void set_on_stack(const bool value);
--- a/hotspot/src/share/vm/oops/methodData.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/oops/methodData.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -86,7 +86,7 @@
char* ProfileData::print_data_on_helper(const MethodData* md) const {
DataLayout* dp = md->extra_data_base();
- DataLayout* end = md->extra_data_limit();
+ DataLayout* end = md->args_data_limit();
stringStream ss;
for (;; dp = MethodData::next_extra(dp)) {
assert(dp < end, "moved past end of extra data");
@@ -1048,14 +1048,15 @@
stream->next();
data->post_initialize(stream, this);
}
- if (_parameters_type_data_di != -1) {
+ if (_parameters_type_data_di != no_parameters) {
parameters_type_data()->post_initialize(NULL, this);
}
}
// Initialize the MethodData* corresponding to a given method.
MethodData::MethodData(methodHandle method, int size, TRAPS)
- : _extra_data_lock(Monitor::leaf, "MDO extra data lock") {
+ : _extra_data_lock(Monitor::leaf, "MDO extra data lock"),
+ _parameters_type_data_di(parameters_uninitialized) {
No_Safepoint_Verifier no_safepoint; // init function atomic wrt GC
ResourceMark rm;
// Set the method back-pointer.
@@ -1111,7 +1112,7 @@
DataLayout *dp = data_layout_at(data_size + extra_size + arg_data_size);
dp->initialize(DataLayout::parameters_type_data_tag, 0, parms_cell);
} else {
- _parameters_type_data_di = -1;
+ _parameters_type_data_di = no_parameters;
}
// Set an initial hint. Don't use set_hint_di() because
@@ -1236,7 +1237,7 @@
}
ProfileData* MethodData::bci_to_extra_data_helper(int bci, Method* m, DataLayout*& dp, bool concurrent) {
- DataLayout* end = extra_data_limit();
+ DataLayout* end = args_data_limit();
for (;; dp = next_extra(dp)) {
assert(dp < end, "moved past end of extra data");
@@ -1285,7 +1286,7 @@
"code needs to be adjusted");
DataLayout* dp = extra_data_base();
- DataLayout* end = extra_data_limit();
+ DataLayout* end = args_data_limit();
// Allocation in the extra data space has to be atomic because not
// all entries have the same size and non atomic concurrent
@@ -1330,7 +1331,7 @@
ArgInfoData *MethodData::arg_info() {
DataLayout* dp = extra_data_base();
- DataLayout* end = extra_data_limit();
+ DataLayout* end = args_data_limit();
for (; dp < end; dp = next_extra(dp)) {
if (dp->tag() == DataLayout::arg_info_data_tag)
return new ArgInfoData(dp);
@@ -1357,7 +1358,7 @@
void MethodData::print_data_on(outputStream* st) const {
ResourceMark rm;
ProfileData* data = first_data();
- if (_parameters_type_data_di != -1) {
+ if (_parameters_type_data_di != no_parameters) {
parameters_type_data()->print_data_on(st);
}
for ( ; is_valid(data); data = next_data(data)) {
@@ -1367,7 +1368,7 @@
}
st->print_cr("--- Extra data:");
DataLayout* dp = extra_data_base();
- DataLayout* end = extra_data_limit();
+ DataLayout* end = args_data_limit();
for (;; dp = next_extra(dp)) {
assert(dp < end, "moved past end of extra data");
// No need for "OrderAccess::load_acquire" ops,
@@ -1565,7 +1566,7 @@
// redefined method
void MethodData::clean_extra_data(CleanExtraDataClosure* cl) {
DataLayout* dp = extra_data_base();
- DataLayout* end = extra_data_limit();
+ DataLayout* end = args_data_limit();
int shift = 0;
for (; dp < end; dp = next_extra(dp)) {
@@ -1610,7 +1611,7 @@
void MethodData::verify_extra_data_clean(CleanExtraDataClosure* cl) {
#ifdef ASSERT
DataLayout* dp = extra_data_base();
- DataLayout* end = extra_data_limit();
+ DataLayout* end = args_data_limit();
for (; dp < end; dp = next_extra(dp)) {
switch(dp->tag()) {
--- a/hotspot/src/share/vm/oops/methodData.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/oops/methodData.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -2107,7 +2107,12 @@
// data index for the area dedicated to parameters. -1 if no
// parameter profiling.
+ enum { no_parameters = -2, parameters_uninitialized = -1 };
int _parameters_type_data_di;
+ int parameters_size_in_bytes() const {
+ ParametersTypeData* param = parameters_type_data();
+ return param == NULL ? 0 : param->size_in_bytes();
+ }
// Beginning of the data entries
intptr_t _data[1];
@@ -2130,7 +2135,7 @@
// Helper for data_at
DataLayout* limit_data_position() const {
- return (DataLayout*)((address)data_base() + _data_size);
+ return data_layout_at(_data_size);
}
bool out_of_bounds(int data_index) const {
return data_index >= data_size();
@@ -2371,10 +2376,11 @@
}
// Add a handful of extra data records, for trap tracking.
- DataLayout* extra_data_base() const { return limit_data_position(); }
+ DataLayout* extra_data_base() const { return limit_data_position(); }
DataLayout* extra_data_limit() const { return (DataLayout*)((address)this + size_in_bytes()); }
- int extra_data_size() const { return (address)extra_data_limit()
- - (address)extra_data_base(); }
+ DataLayout* args_data_limit() const { return (DataLayout*)((address)this + size_in_bytes() -
+ parameters_size_in_bytes()); }
+ int extra_data_size() const { return (address)extra_data_limit() - (address)extra_data_base(); }
static DataLayout* next_extra(DataLayout* dp);
// Return (uint)-1 for overflow.
@@ -2429,11 +2435,12 @@
// Return pointer to area dedicated to parameters in MDO
ParametersTypeData* parameters_type_data() const {
- return _parameters_type_data_di != -1 ? data_layout_at(_parameters_type_data_di)->data_in()->as_ParametersTypeData() : NULL;
+ assert(_parameters_type_data_di != parameters_uninitialized, "called too early");
+ return _parameters_type_data_di != no_parameters ? data_layout_at(_parameters_type_data_di)->data_in()->as_ParametersTypeData() : NULL;
}
int parameters_type_data_di() const {
- assert(_parameters_type_data_di != -1, "no args type data");
+ assert(_parameters_type_data_di != parameters_uninitialized && _parameters_type_data_di != no_parameters, "no args type data");
return _parameters_type_data_di;
}
@@ -2480,8 +2487,8 @@
static bool profile_return_jsr292_only();
void clean_method_data(BoolObjectClosure* is_alive);
-
void clean_weak_method_links();
+ Mutex* extra_data_lock() { return &_extra_data_lock; }
};
#endif // SHARE_VM_OOPS_METHODDATAOOP_HPP
--- a/hotspot/src/share/vm/opto/c2_globals.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/c2_globals.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -650,6 +650,9 @@
product(bool, UseMathExactIntrinsics, true, \
"Enables intrinsification of various java.lang.Math functions") \
\
+ product(bool, UseMultiplyToLenIntrinsic, false, \
+ "Enables intrinsification of BigInteger.multiplyToLen()") \
+ \
product(bool, UseTypeSpeculation, true, \
"Speculatively propagate types from profiles") \
\
--- a/hotspot/src/share/vm/opto/callnode.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/callnode.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -1830,8 +1830,8 @@
Node* dest, Node* dest_offset,
Node* length,
bool alloc_tightly_coupled,
- Node* src_length, Node* dest_length,
- Node* src_klass, Node* dest_klass) {
+ Node* src_klass, Node* dest_klass,
+ Node* src_length, Node* dest_length) {
ArrayCopyNode* ac = new ArrayCopyNode(kit->C, alloc_tightly_coupled);
Node* prev_mem = kit->set_predefined_input_for_runtime_call(ac);
--- a/hotspot/src/share/vm/opto/callnode.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/callnode.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -1138,8 +1138,8 @@
Node* dest, Node* dest_offset,
Node* length,
bool alloc_tightly_coupled,
- Node* src_length = NULL, Node* dest_length = NULL,
- Node* src_klass = NULL, Node* dest_klass = NULL);
+ Node* src_klass = NULL, Node* dest_klass = NULL,
+ Node* src_length = NULL, Node* dest_length = NULL);
void connect_outputs(GraphKit* kit);
--- a/hotspot/src/share/vm/opto/compile.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/compile.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -601,6 +601,10 @@
bool method_has_option(const char * option) {
return method() != NULL && method()->has_option(option);
}
+ template<typename T>
+ bool method_has_option_value(const char * option, T& value) {
+ return method() != NULL && method()->has_option_value(option, value);
+ }
#ifndef PRODUCT
bool trace_opto_output() const { return _trace_opto_output; }
bool parsed_irreducible_loop() const { return _parsed_irreducible_loop; }
--- a/hotspot/src/share/vm/opto/escape.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/escape.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -945,7 +945,8 @@
strcmp(call->as_CallLeaf()->_name, "sha256_implCompress") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha256_implCompressMB") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha512_implCompress") == 0 ||
- strcmp(call->as_CallLeaf()->_name, "sha512_implCompressMB") == 0)
+ strcmp(call->as_CallLeaf()->_name, "sha512_implCompressMB") == 0 ||
+ strcmp(call->as_CallLeaf()->_name, "multiplyToLen") == 0)
))) {
call->dump();
fatal(err_msg_res("EA unexpected CallLeaf %s", call->as_CallLeaf()->_name));
--- a/hotspot/src/share/vm/opto/library_call.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/library_call.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -285,6 +285,7 @@
bool inline_updateCRC32();
bool inline_updateBytesCRC32();
bool inline_updateByteBufferCRC32();
+ bool inline_multiplyToLen();
};
@@ -293,8 +294,12 @@
vmIntrinsics::ID id = m->intrinsic_id();
assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
- if (DisableIntrinsic[0] != '\0'
- && strstr(DisableIntrinsic, vmIntrinsics::name_at(id)) != NULL) {
+ ccstr disable_intr = NULL;
+
+ if ((DisableIntrinsic[0] != '\0'
+ && strstr(DisableIntrinsic, vmIntrinsics::name_at(id)) != NULL) ||
+ (method_has_option_value("DisableIntrinsic", disable_intr)
+ && strstr(disable_intr, vmIntrinsics::name_at(id)) != NULL)) {
// disabled by a user request on the command line:
// example: -XX:DisableIntrinsic=_hashCode,_getClass
return NULL;
@@ -477,6 +482,10 @@
if (!UseAESIntrinsics) return NULL;
break;
+ case vmIntrinsics::_multiplyToLen:
+ if (!UseMultiplyToLenIntrinsic) return NULL;
+ break;
+
case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
if (!UseAESIntrinsics) return NULL;
@@ -836,7 +845,6 @@
case vmIntrinsics::_isArray:
case vmIntrinsics::_isPrimitive:
case vmIntrinsics::_getSuperclass:
- case vmIntrinsics::_getComponentType:
case vmIntrinsics::_getClassAccessFlags: return inline_native_Class_query(intrinsic_id());
case vmIntrinsics::_floatToRawIntBits:
@@ -876,6 +884,9 @@
case vmIntrinsics::_digestBase_implCompressMB:
return inline_digestBase_implCompressMB(predicate);
+ case vmIntrinsics::_multiplyToLen:
+ return inline_multiplyToLen();
+
case vmIntrinsics::_encodeISOArray:
return inline_encodeISOArray();
@@ -3400,10 +3411,6 @@
prim_return_value = null();
return_type = TypeInstPtr::MIRROR->cast_to_ptr_type(TypePtr::BotPTR);
break;
- case vmIntrinsics::_getComponentType:
- prim_return_value = null();
- return_type = TypeInstPtr::MIRROR->cast_to_ptr_type(TypePtr::BotPTR);
- break;
case vmIntrinsics::_getClassAccessFlags:
prim_return_value = intcon(JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC);
return_type = TypeInt::INT; // not bool! 6297094
@@ -3520,17 +3527,6 @@
}
break;
- case vmIntrinsics::_getComponentType:
- if (generate_array_guard(kls, region) != NULL) {
- // Be sure to pin the oop load to the guard edge just created:
- Node* is_array_ctrl = region->in(region->req()-1);
- Node* cma = basic_plus_adr(kls, in_bytes(ArrayKlass::component_mirror_offset()));
- Node* cmo = make_load(is_array_ctrl, cma, TypeInstPtr::MIRROR, T_OBJECT, MemNode::unordered);
- phi->add_req(cmo);
- }
- query_value = null(); // non-array case is null
- break;
-
case vmIntrinsics::_getClassAccessFlags:
p = basic_plus_adr(kls, in_bytes(Klass::access_flags_offset()));
query_value = make_load(NULL, p, TypeInt::INT, T_INT, MemNode::unordered);
@@ -3859,7 +3855,7 @@
Node* orig_tail = _gvn.transform(new SubINode(orig_length, start));
Node* moved = generate_min_max(vmIntrinsics::_min, orig_tail, length);
- newcopy = new_array(klass_node, length, 0); // no argments to push
+ newcopy = new_array(klass_node, length, 0); // no arguments to push
// Generate a direct call to the right arraycopy function(s).
// We know the copy is disjoint but we might not know if the
@@ -3869,7 +3865,8 @@
Node* alloc = tightly_coupled_allocation(newcopy, NULL);
- ArrayCopyNode* ac = ArrayCopyNode::make(this, true, original, start, newcopy, intcon(0), moved, alloc != NULL);
+ ArrayCopyNode* ac = ArrayCopyNode::make(this, true, original, start, newcopy, intcon(0), moved, alloc != NULL,
+ load_object_klass(original), klass_node);
if (!is_copyOfRange) {
ac->set_copyof();
} else {
@@ -4792,8 +4789,8 @@
// Create LoadRange and LoadKlass nodes for use during macro expansion here
// so the compiler has a chance to eliminate them: during macro expansion,
// we have to set their control (CastPP nodes are eliminated).
- load_array_length(src), load_array_length(dest),
- load_object_klass(src), load_object_klass(dest));
+ load_object_klass(src), load_object_klass(dest),
+ load_array_length(src), load_array_length(dest));
if (notest) {
ac->set_arraycopy_notest();
@@ -4924,6 +4921,106 @@
return true;
}
+//-------------inline_multiplyToLen-----------------------------------
+bool LibraryCallKit::inline_multiplyToLen() {
+ assert(UseMultiplyToLenIntrinsic, "not implementated on this platform");
+
+ address stubAddr = StubRoutines::multiplyToLen();
+ if (stubAddr == NULL) {
+ return false; // Intrinsic's stub is not implemented on this platform
+ }
+ const char* stubName = "multiplyToLen";
+
+ assert(callee()->signature()->size() == 5, "multiplyToLen has 5 parameters");
+
+ Node* x = argument(1);
+ Node* xlen = argument(2);
+ Node* y = argument(3);
+ Node* ylen = argument(4);
+ Node* z = argument(5);
+
+ const Type* x_type = x->Value(&_gvn);
+ const Type* y_type = y->Value(&_gvn);
+ const TypeAryPtr* top_x = x_type->isa_aryptr();
+ const TypeAryPtr* top_y = y_type->isa_aryptr();
+ if (top_x == NULL || top_x->klass() == NULL ||
+ top_y == NULL || top_y->klass() == NULL) {
+ // failed array check
+ return false;
+ }
+
+ BasicType x_elem = x_type->isa_aryptr()->klass()->as_array_klass()->element_type()->basic_type();
+ BasicType y_elem = y_type->isa_aryptr()->klass()->as_array_klass()->element_type()->basic_type();
+ if (x_elem != T_INT || y_elem != T_INT) {
+ return false;
+ }
+
+ // Set the original stack and the reexecute bit for the interpreter to reexecute
+ // the bytecode that invokes BigInteger.multiplyToLen() if deoptimization happens
+ // on the return from z array allocation in runtime.
+ { PreserveReexecuteState preexecs(this);
+ jvms()->set_should_reexecute(true);
+
+ Node* x_start = array_element_address(x, intcon(0), x_elem);
+ Node* y_start = array_element_address(y, intcon(0), y_elem);
+ // 'x_start' points to x array + scaled xlen
+ // 'y_start' points to y array + scaled ylen
+
+ // Allocate the result array
+ Node* zlen = _gvn.transform(new AddINode(xlen, ylen));
+ Node* klass_node = makecon(TypeKlassPtr::make(ciTypeArrayKlass::make(T_INT)));
+
+ IdealKit ideal(this);
+
+#define __ ideal.
+ Node* one = __ ConI(1);
+ Node* zero = __ ConI(0);
+ IdealVariable need_alloc(ideal), z_alloc(ideal); __ declarations_done();
+ __ set(need_alloc, zero);
+ __ set(z_alloc, z);
+ __ if_then(z, BoolTest::eq, null()); {
+ __ increment (need_alloc, one);
+ } __ else_(); {
+ // Update graphKit memory and control from IdealKit.
+ sync_kit(ideal);
+ Node* zlen_arg = load_array_length(z);
+ // Update IdealKit memory and control from graphKit.
+ __ sync_kit(this);
+ __ if_then(zlen_arg, BoolTest::lt, zlen); {
+ __ increment (need_alloc, one);
+ } __ end_if();
+ } __ end_if();
+
+ __ if_then(__ value(need_alloc), BoolTest::ne, zero); {
+ // Update graphKit memory and control from IdealKit.
+ sync_kit(ideal);
+ Node * narr = new_array(klass_node, zlen, 1);
+ // Update IdealKit memory and control from graphKit.
+ __ sync_kit(this);
+ __ set(z_alloc, narr);
+ } __ end_if();
+
+ sync_kit(ideal);
+ z = __ value(z_alloc);
+ _gvn.set_type(z, TypeAryPtr::INTS);
+ // Final sync IdealKit and GraphKit.
+ final_sync(ideal);
+#undef __
+
+ Node* z_start = array_element_address(z, intcon(0), T_INT);
+
+ Node* call = make_runtime_call(RC_LEAF|RC_NO_FP,
+ OptoRuntime::multiplyToLen_Type(),
+ stubAddr, stubName, TypePtr::BOTTOM,
+ x_start, xlen, y_start, ylen, z_start, zlen);
+ } // original reexecute is set back here
+
+ C->set_has_split_ifs(true); // Has chance for split-if optimization
+ set_result(z);
+ return true;
+}
+
+
/**
* Calculate CRC32 for byte.
* int java.util.zip.CRC32.update(int crc, int b)
--- a/hotspot/src/share/vm/opto/macroArrayCopy.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/macroArrayCopy.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -506,6 +506,8 @@
Node* src_klass = ac->in(ArrayCopyNode::SrcKlass);
Node* dest_klass = ac->in(ArrayCopyNode::DestKlass);
+ assert(src_klass != NULL && dest_klass != NULL, "should have klasses");
+
// Generate the subtype check.
// This might fold up statically, or then again it might not.
//
@@ -1209,6 +1211,7 @@
// (7) src_offset + length must not exceed length of src.
Node* alen = ac->in(ArrayCopyNode::SrcLen);
+ assert(alen != NULL, "need src len");
generate_limit_guard(&ctrl,
src_offset, length,
alen,
@@ -1216,6 +1219,7 @@
// (8) dest_offset + length must not exceed length of dest.
alen = ac->in(ArrayCopyNode::DestLen);
+ assert(alen != NULL, "need dest len");
generate_limit_guard(&ctrl,
dest_offset, length,
alen,
--- a/hotspot/src/share/vm/opto/memnode.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/memnode.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -1799,13 +1799,6 @@
}
const Type* aift = load_array_final_field(tkls, klass);
if (aift != NULL) return aift;
- if (tkls->offset() == in_bytes(ArrayKlass::component_mirror_offset())
- && klass->is_array_klass()) {
- // The field is ArrayKlass::_component_mirror. Return its (constant) value.
- // (Folds up aClassConstant.getComponentType, common in Arrays.copyOf.)
- assert(Opcode() == Op_LoadP, "must load an oop from _component_mirror");
- return TypeInstPtr::make(klass->as_array_klass()->component_mirror());
- }
if (tkls->offset() == in_bytes(Klass::java_mirror_offset())) {
// The field is Klass::_java_mirror. Return its (constant) value.
// (Folds up the 2nd indirection in anObjConstant.getClass().)
@@ -2200,18 +2193,15 @@
}
// Simplify k.java_mirror.as_klass to plain k, where k is a Klass*.
- // Simplify ak.component_mirror.array_klass to plain ak, ak an ArrayKlass.
// See inline_native_Class_query for occurrences of these patterns.
// Java Example: x.getClass().isAssignableFrom(y)
- // Java Example: Array.newInstance(x.getClass().getComponentType(), n)
//
// This improves reflective code, often making the Class
// mirror go completely dead. (Current exception: Class
// mirrors may appear in debug info, but we could clean them out by
// introducing a new debug info operator for Klass*.java_mirror).
if (toop->isa_instptr() && toop->klass() == phase->C->env()->Class_klass()
- && (offset == java_lang_Class::klass_offset_in_bytes() ||
- offset == java_lang_Class::array_klass_offset_in_bytes())) {
+ && offset == java_lang_Class::klass_offset_in_bytes()) {
// We are loading a special hidden field from a Class mirror,
// the field which points to its Klass or ArrayKlass metaobject.
if (base->is_Load()) {
@@ -2223,9 +2213,6 @@
&& adr2->is_AddP()
) {
int mirror_field = in_bytes(Klass::java_mirror_offset());
- if (offset == java_lang_Class::array_klass_offset_in_bytes()) {
- mirror_field = in_bytes(ArrayKlass::component_mirror_offset());
- }
if (tkls->offset() == mirror_field) {
return adr2->in(AddPNode::Base);
}
@@ -2799,9 +2786,10 @@
assert(n->is_ClearArray(), "sanity");
intptr_t offset;
AllocateNode* alloc = AllocateNode::Ideal_allocation(n->in(3), phase, offset);
- // This method is called only before Allocate nodes are expanded during
- // macro nodes expansion. Before that ClearArray nodes are only generated
- // in LibraryCallKit::generate_arraycopy() which follows allocations.
+ // This method is called only before Allocate nodes are expanded
+ // during macro nodes expansion. Before that ClearArray nodes are
+ // only generated in PhaseMacroExpand::generate_arraycopy() (before
+ // Allocate nodes are expanded) which follows allocations.
assert(alloc != NULL, "should have allocation");
if (alloc->_idx == instance_id) {
// Can not bypass initialization of the instance we are looking for.
--- a/hotspot/src/share/vm/opto/phaseX.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/phaseX.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -42,10 +42,14 @@
_max( round_up(est_max_size < NODE_HASH_MINIMUM_SIZE ? NODE_HASH_MINIMUM_SIZE : est_max_size) ),
_a(Thread::current()->resource_area()),
_table( NEW_ARENA_ARRAY( _a , Node* , _max ) ), // (Node**)_a->Amalloc(_max * sizeof(Node*)) ),
- _inserts(0), _insert_limit( insert_limit() ),
- _look_probes(0), _lookup_hits(0), _lookup_misses(0),
+ _inserts(0), _insert_limit( insert_limit() )
+#ifndef PRODUCT
+ ,_look_probes(0), _lookup_hits(0), _lookup_misses(0),
+ _delete_probes(0), _delete_hits(0), _delete_misses(0),
_total_insert_probes(0), _total_inserts(0),
- _insert_probes(0), _grows(0) {
+ _insert_probes(0), _grows(0)
+#endif
+{
// _sentinel must be in the current node space
_sentinel = new ProjNode(NULL, TypeFunc::Control);
memset(_table,0,sizeof(Node*)*_max);
@@ -56,11 +60,14 @@
_max( round_up(est_max_size < NODE_HASH_MINIMUM_SIZE ? NODE_HASH_MINIMUM_SIZE : est_max_size) ),
_a(arena),
_table( NEW_ARENA_ARRAY( _a , Node* , _max ) ),
- _inserts(0), _insert_limit( insert_limit() ),
- _look_probes(0), _lookup_hits(0), _lookup_misses(0),
+ _inserts(0), _insert_limit( insert_limit() )
+#ifndef PRODUCT
+ ,_look_probes(0), _lookup_hits(0), _lookup_misses(0),
_delete_probes(0), _delete_hits(0), _delete_misses(0),
_total_insert_probes(0), _total_inserts(0),
- _insert_probes(0), _grows(0) {
+ _insert_probes(0), _grows(0)
+#endif
+{
// _sentinel must be in the current node space
_sentinel = new ProjNode(NULL, TypeFunc::Control);
memset(_table,0,sizeof(Node*)*_max);
@@ -87,15 +94,15 @@
// ((Node*)n)->set_hash( n->hash() );
uint hash = n->hash();
if (hash == Node::NO_HASH) {
- debug_only( _lookup_misses++ );
+ NOT_PRODUCT( _lookup_misses++ );
return NULL;
}
uint key = hash & (_max-1);
uint stride = key | 0x01;
- debug_only( _look_probes++ );
+ NOT_PRODUCT( _look_probes++ );
Node *k = _table[key]; // Get hashed value
if( !k ) { // ?Miss?
- debug_only( _lookup_misses++ );
+ NOT_PRODUCT( _lookup_misses++ );
return NULL; // Miss!
}
@@ -108,16 +115,16 @@
if( n->in(i)!=k->in(i)) // Different inputs?
goto collision; // "goto" is a speed hack...
if( n->cmp(*k) ) { // Check for any special bits
- debug_only( _lookup_hits++ );
+ NOT_PRODUCT( _lookup_hits++ );
return k; // Hit!
}
}
collision:
- debug_only( _look_probes++ );
+ NOT_PRODUCT( _look_probes++ );
key = (key + stride/*7*/) & (_max-1); // Stride through table with relative prime
k = _table[key]; // Get hashed value
if( !k ) { // ?Miss?
- debug_only( _lookup_misses++ );
+ NOT_PRODUCT( _lookup_misses++ );
return NULL; // Miss!
}
}
@@ -132,16 +139,16 @@
// n->set_hash( );
uint hash = n->hash();
if (hash == Node::NO_HASH) {
- debug_only( _lookup_misses++ );
+ NOT_PRODUCT( _lookup_misses++ );
return NULL;
}
uint key = hash & (_max-1);
uint stride = key | 0x01; // stride must be relatively prime to table siz
uint first_sentinel = 0; // replace a sentinel if seen.
- debug_only( _look_probes++ );
+ NOT_PRODUCT( _look_probes++ );
Node *k = _table[key]; // Get hashed value
if( !k ) { // ?Miss?
- debug_only( _lookup_misses++ );
+ NOT_PRODUCT( _lookup_misses++ );
_table[key] = n; // Insert into table!
debug_only(n->enter_hash_lock()); // Lock down the node while in the table.
check_grow(); // Grow table if insert hit limit
@@ -160,16 +167,16 @@
if( n->in(i)!=k->in(i)) // Different inputs?
goto collision; // "goto" is a speed hack...
if( n->cmp(*k) ) { // Check for any special bits
- debug_only( _lookup_hits++ );
+ NOT_PRODUCT( _lookup_hits++ );
return k; // Hit!
}
}
collision:
- debug_only( _look_probes++ );
+ NOT_PRODUCT( _look_probes++ );
key = (key + stride) & (_max-1); // Stride through table w/ relative prime
k = _table[key]; // Get hashed value
if( !k ) { // ?Miss?
- debug_only( _lookup_misses++ );
+ NOT_PRODUCT( _lookup_misses++ );
key = (first_sentinel == 0) ? key : first_sentinel; // ?saw sentinel?
_table[key] = n; // Insert into table!
debug_only(n->enter_hash_lock()); // Lock down the node while in the table.
@@ -200,7 +207,7 @@
uint stride = key | 0x01;
while( 1 ) { // While probing hash table
- debug_only( _insert_probes++ );
+ NOT_PRODUCT( _insert_probes++ );
Node *k = _table[key]; // Get hashed value
if( !k || (k == _sentinel) ) break; // Found a slot
assert( k != n, "already inserted" );
@@ -218,7 +225,7 @@
Node *k;
uint hash = n->hash();
if (hash == Node::NO_HASH) {
- debug_only( _delete_misses++ );
+ NOT_PRODUCT( _delete_misses++ );
return false;
}
uint key = hash & (_max-1);
@@ -226,10 +233,10 @@
debug_only( uint counter = 0; );
for( ; /* (k != NULL) && (k != _sentinel) */; ) {
debug_only( counter++ );
- debug_only( _delete_probes++ );
+ NOT_PRODUCT( _delete_probes++ );
k = _table[key]; // Get hashed value
if( !k ) { // Miss?
- debug_only( _delete_misses++ );
+ NOT_PRODUCT( _delete_misses++ );
#ifdef ASSERT
if( VerifyOpto ) {
for( uint i=0; i < _max; i++ )
@@ -239,7 +246,7 @@
return false; // Miss! Not in chain
}
else if( n == k ) {
- debug_only( _delete_hits++ );
+ NOT_PRODUCT( _delete_hits++ );
_table[key] = _sentinel; // Hit! Label as deleted entry
debug_only(((Node*)n)->exit_hash_lock()); // Unlock the node upon removal from table.
return true;
@@ -271,11 +278,13 @@
uint old_max = _max;
Node **old_table = _table;
// Construct new table with twice the space
+#ifndef PRODUCT
_grows++;
_total_inserts += _inserts;
_total_insert_probes += _insert_probes;
+ _insert_probes = 0;
+#endif
_inserts = 0;
- _insert_probes = 0;
_max = _max << 1;
_table = NEW_ARENA_ARRAY( _a , Node* , _max ); // (Node**)_a->Amalloc( _max * sizeof(Node*) );
memset(_table,0,sizeof(Node*)*_max);
--- a/hotspot/src/share/vm/opto/phaseX.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/phaseX.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -100,7 +100,6 @@
#ifndef PRODUCT
Node *find_index(uint idx); // For debugging
void dump(); // For debugging, dump statistics
-#endif
uint _grows; // For debugging, count of table grow()s
uint _look_probes; // For debugging, count of hash probes
uint _lookup_hits; // For debugging, count of hash_finds
@@ -111,6 +110,7 @@
uint _delete_misses; // For debugging, count of hash probes for deletes
uint _total_inserts; // For debugging, total inserts into hash table
uint _total_insert_probes; // For debugging, total probes while inserting
+#endif
};
--- a/hotspot/src/share/vm/opto/runtime.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/runtime.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -922,6 +922,30 @@
return TypeFunc::make(domain, range);
}
+const TypeFunc* OptoRuntime::multiplyToLen_Type() {
+ // create input type (domain)
+ int num_args = 6;
+ int argcnt = num_args;
+ const Type** fields = TypeTuple::fields(argcnt);
+ int argp = TypeFunc::Parms;
+ fields[argp++] = TypePtr::NOTNULL; // x
+ fields[argp++] = TypeInt::INT; // xlen
+ fields[argp++] = TypePtr::NOTNULL; // y
+ fields[argp++] = TypeInt::INT; // ylen
+ fields[argp++] = TypePtr::NOTNULL; // z
+ fields[argp++] = TypeInt::INT; // zlen
+ assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
+ const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
+
+ // no result type needed
+ fields = TypeTuple::fields(1);
+ fields[TypeFunc::Parms+0] = NULL;
+ const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
+ return TypeFunc::make(domain, range);
+}
+
+
+
//------------- Interpreter state access for on stack replacement
const TypeFunc* OptoRuntime::osr_end_Type() {
// create input type (domain)
--- a/hotspot/src/share/vm/opto/runtime.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/opto/runtime.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -310,6 +310,8 @@
static const TypeFunc* sha_implCompress_Type();
static const TypeFunc* digestBase_implCompressMB_Type();
+ static const TypeFunc* multiplyToLen_Type();
+
static const TypeFunc* updateBytesCRC32_Type();
// leaf on stack replacement interpreter accessor types
--- a/hotspot/src/share/vm/prims/jvm.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/prims/jvm.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -1403,14 +1403,6 @@
JVM_END
-JVM_ENTRY(jclass, JVM_GetComponentType(JNIEnv *env, jclass cls))
- JVMWrapper("JVM_GetComponentType");
- oop mirror = JNIHandles::resolve_non_null(cls);
- oop result = Reflection::array_component_type(mirror, CHECK_NULL);
- return (jclass) JNIHandles::make_local(env, result);
-JVM_END
-
-
JVM_ENTRY(jint, JVM_GetClassModifiers(JNIEnv *env, jclass cls))
JVMWrapper("JVM_GetClassModifiers");
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
--- a/hotspot/src/share/vm/prims/jvm.h Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/prims/jvm.h Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 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
@@ -483,9 +483,6 @@
JNIEXPORT jboolean JNICALL
JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);
-JNIEXPORT jclass JNICALL
-JVM_GetComponentType(JNIEnv *env, jclass cls);
-
JNIEXPORT jint JNICALL
JVM_GetClassModifiers(JNIEnv *env, jclass cls);
--- a/hotspot/src/share/vm/prims/jvmtiImpl.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/prims/jvmtiImpl.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -282,39 +282,22 @@
void JvmtiBreakpoint::each_method_version_do(method_action meth_act) {
((Method*)_method->*meth_act)(_bci);
- // add/remove breakpoint to/from versions of the method that
- // are EMCP. Directly or transitively obsolete methods are
- // not saved in the PreviousVersionNodes.
+ // add/remove breakpoint to/from versions of the method that are EMCP.
Thread *thread = Thread::current();
instanceKlassHandle ikh = instanceKlassHandle(thread, _method->method_holder());
Symbol* m_name = _method->name();
Symbol* m_signature = _method->signature();
// search previous versions if they exist
- PreviousVersionWalker pvw(thread, (InstanceKlass *)ikh());
- for (PreviousVersionNode * pv_node = pvw.next_previous_version();
- pv_node != NULL; pv_node = pvw.next_previous_version()) {
- GrowableArray<Method*>* methods = pv_node->prev_EMCP_methods();
-
- if (methods == NULL) {
- // We have run into a PreviousVersion generation where
- // all methods were made obsolete during that generation's
- // RedefineClasses() operation. At the time of that
- // operation, all EMCP methods were flushed so we don't
- // have to go back any further.
- //
- // A NULL methods array is different than an empty methods
- // array. We cannot infer any optimizations about older
- // generations from an empty methods array for the current
- // generation.
- break;
- }
+ for (InstanceKlass* pv_node = ikh->previous_versions();
+ pv_node != NULL;
+ pv_node = pv_node->previous_versions()) {
+ Array<Method*>* methods = pv_node->methods();
for (int i = methods->length() - 1; i >= 0; i--) {
Method* method = methods->at(i);
- // obsolete methods that are running are not deleted from
- // previous version array, but they are skipped here.
- if (!method->is_obsolete() &&
+ // Only set breakpoints in running EMCP methods.
+ if (method->is_running_emcp() &&
method->name() == m_name &&
method->signature() == m_signature) {
RC_TRACE(0x00000800, ("%sing breakpoint in %s(%s)",
--- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -135,7 +135,7 @@
// Mark methods seen on stack and everywhere else so old methods are not
// cleaned up if they're on the stack.
- MetadataOnStackMark md_on_stack;
+ MetadataOnStackMark md_on_stack(true);
HandleMark hm(thread); // make sure any handles created are deleted
// before the stack walk again.
@@ -2826,11 +2826,10 @@
}
// the previous versions' constant pool caches may need adjustment
- PreviousVersionWalker pvw(_thread, ik);
- for (PreviousVersionNode * pv_node = pvw.next_previous_version();
- pv_node != NULL; pv_node = pvw.next_previous_version()) {
- other_cp = pv_node->prev_constant_pool();
- cp_cache = other_cp->cache();
+ for (InstanceKlass* pv_node = ik->previous_versions();
+ pv_node != NULL;
+ pv_node = pv_node->previous_versions()) {
+ cp_cache = pv_node->constants()->cache();
if (cp_cache != NULL) {
cp_cache->adjust_method_entries(_matching_old_methods,
_matching_new_methods,
@@ -2855,9 +2854,8 @@
}
}
-void VM_RedefineClasses::check_methods_and_mark_as_obsolete(
- BitMap *emcp_methods, int * emcp_method_count_p) {
- *emcp_method_count_p = 0;
+int VM_RedefineClasses::check_methods_and_mark_as_obsolete() {
+ int emcp_method_count = 0;
int obsolete_count = 0;
int old_index = 0;
for (int j = 0; j < _matching_methods_length; ++j, ++old_index) {
@@ -2931,9 +2929,9 @@
// that we get from effectively overwriting the old methods
// when the new methods are attached to the_class.
- // track which methods are EMCP for add_previous_version() call
- emcp_methods->set_bit(old_index);
- (*emcp_method_count_p)++;
+ // Count number of methods that are EMCP. The method will be marked
+ // old but not obsolete if it is EMCP.
+ emcp_method_count++;
// An EMCP method is _not_ obsolete. An obsolete method has a
// different jmethodID than the current method. An EMCP method
@@ -2982,10 +2980,11 @@
old_method->name()->as_C_string(),
old_method->signature()->as_C_string()));
}
- assert((*emcp_method_count_p + obsolete_count) == _old_methods->length(),
+ assert((emcp_method_count + obsolete_count) == _old_methods->length(),
"sanity check");
- RC_TRACE(0x00000100, ("EMCP_cnt=%d, obsolete_cnt=%d", *emcp_method_count_p,
+ RC_TRACE(0x00000100, ("EMCP_cnt=%d, obsolete_cnt=%d", emcp_method_count,
obsolete_count));
+ return emcp_method_count;
}
// This internal class transfers the native function registration from old methods
@@ -3379,11 +3378,8 @@
old_constants->set_pool_holder(scratch_class());
#endif
- // track which methods are EMCP for add_previous_version() call below
- BitMap emcp_methods(_old_methods->length());
- int emcp_method_count = 0;
- emcp_methods.clear(); // clears 0..(length() - 1)
- check_methods_and_mark_as_obsolete(&emcp_methods, &emcp_method_count);
+ // track number of methods that are EMCP for add_previous_version() call below
+ int emcp_method_count = check_methods_and_mark_as_obsolete();
transfer_old_native_function_registrations(the_class);
// The class file bytes from before any retransformable agents mucked
@@ -3471,9 +3467,10 @@
scratch_class->enclosing_method_method_index());
scratch_class->set_enclosing_method_indices(old_class_idx, old_method_idx);
+ the_class->set_has_been_redefined();
+
// keep track of previous versions of this class
- the_class->add_previous_version(scratch_class, &emcp_methods,
- emcp_method_count);
+ the_class->add_previous_version(scratch_class, emcp_method_count);
RC_TIMER_STOP(_timer_rsc_phase1);
RC_TIMER_START(_timer_rsc_phase2);
--- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 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
@@ -403,14 +403,9 @@
// Change jmethodIDs to point to the new methods
void update_jmethod_ids();
- // In addition to marking methods as obsolete, this routine
- // records which methods are EMCP (Equivalent Module Constant
- // Pool) in the emcp_methods BitMap and returns the number of
- // EMCP methods via emcp_method_count_p. This information is
- // used when information about the previous version of the_class
- // is squirreled away.
- void check_methods_and_mark_as_obsolete(BitMap *emcp_methods,
- int * emcp_method_count_p);
+ // In addition to marking methods as old and/or obsolete, this routine
+ // counts the number of methods that are EMCP (Equivalent Module Constant Pool).
+ int check_methods_and_mark_as_obsolete();
void transfer_old_native_function_registrations(instanceKlassHandle the_class);
// Install the redefinition of a class
--- a/hotspot/src/share/vm/runtime/deoptimization.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/runtime/deoptimization.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -191,7 +191,8 @@
// It is not guaranteed that we can get such information here only
// by analyzing bytecode in deoptimized frames. This is why this flag
// is set during method compilation (see Compile::Process_OopMap_Node()).
- bool save_oop_result = chunk->at(0)->scope()->return_oop();
+ // If the previous frame was popped, we don't have a result.
+ bool save_oop_result = chunk->at(0)->scope()->return_oop() && !thread->popframe_forcing_deopt_reexecution();
Handle return_value;
if (save_oop_result) {
// Reallocation may trigger GC. If deoptimization happened on return from
--- a/hotspot/src/share/vm/runtime/java.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/runtime/java.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -430,8 +430,6 @@
}
}
-jint volatile vm_getting_terminated = 0;
-
// 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.
@@ -462,8 +460,6 @@
}
}
- OrderAccess::release_store(&vm_getting_terminated, 1);
-
// The only difference between this and Win32's _onexit procs is that
// this version is invoked before any threads get killed.
ExitProc* current = exit_procs;
@@ -587,7 +583,7 @@
void vm_direct_exit(int code) {
notify_vm_shutdown();
os::wait_for_keypress_at_exit();
- ::exit(code);
+ os::exit(code);
}
void vm_perform_shutdown_actions() {
--- a/hotspot/src/share/vm/runtime/os.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/runtime/os.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -53,6 +53,7 @@
#include "runtime/vm_version.hpp"
#include "services/attachListener.hpp"
#include "services/nmtCommon.hpp"
+#include "services/mallocTracker.hpp"
#include "services/memTracker.hpp"
#include "services/threadService.hpp"
#include "utilities/defaultStream.hpp"
@@ -570,6 +571,17 @@
NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
+#if INCLUDE_NMT
+ // NMT can not track malloc allocation size > MAX_MALLOC_SIZE, which is
+ // (1GB - 1) on 32-bit system. It is not an issue on 64-bit system, where
+ // MAX_MALLOC_SIZE = ((1 << 62) - 1).
+ // VM code does not have such large malloc allocation. However, it can come
+ // Unsafe call.
+ if (MemTracker::tracking_level() >= NMT_summary && size > MAX_MALLOC_SIZE) {
+ return NULL;
+ }
+#endif
+
#ifdef ASSERT
// checking for the WatcherThread and crash_protection first
// since os::malloc can be called when the libjvm.{dll,so} is
@@ -640,6 +652,13 @@
}
void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, const NativeCallStack& stack) {
+#if INCLUDE_NMT
+ // See comments in os::malloc() above
+ if (MemTracker::tracking_level() >= NMT_summary && size > MAX_MALLOC_SIZE) {
+ return NULL;
+ }
+#endif
+
#ifndef ASSERT
NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
--- a/hotspot/src/share/vm/runtime/os.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/runtime/os.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -214,13 +214,14 @@
// Interface for detecting multiprocessor system
static inline bool is_MP() {
-#if !INCLUDE_NMT
- assert(_processor_count > 0, "invalid processor count");
- return _processor_count > 1 || AssumeMP;
-#else
- // NMT needs atomic operations before this initialization.
- return true;
-#endif
+ // During bootstrap if _processor_count is not yet initialized
+ // we claim to be MP as that is safest. If any platform has a
+ // stub generator that might be triggered in this phase and for
+ // which being declared MP when in fact not, is a problem - then
+ // the bootstrap routine for the stub generator needs to check
+ // the processor count directly and leave the bootstrap routine
+ // in place until called after initialization has ocurred.
+ return (_processor_count != 1) || AssumeMP;
}
static julong available_memory();
static julong physical_memory();
@@ -481,8 +482,8 @@
// run cmd in a separate process and return its exit code; or -1 on failures
static int fork_and_exec(char *cmd);
- // os::exit() is merged with vm_exit()
- // static void exit(int num);
+ // Call ::exit() on all platforms but Windows
+ static void exit(int num);
// Terminate the VM, but don't exit the process
static void shutdown();
@@ -557,6 +558,16 @@
// Unload library
static void dll_unload(void *lib);
+ // Callback for loaded module information
+ // Input parameters:
+ // char* module_file_name,
+ // address module_base_addr,
+ // address module_top_addr,
+ // void* param
+ typedef int (*LoadedModulesCallbackFunc)(const char *, address, address, void *);
+
+ static int get_loaded_modules_info(LoadedModulesCallbackFunc callback, void *param);
+
// Return the handle of this process
static void* get_default_process_handle();
--- a/hotspot/src/share/vm/runtime/reflection.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/runtime/reflection.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -390,7 +390,7 @@
return NULL;
}
- oop result = ArrayKlass::cast(klass)->component_mirror();
+ oop result = java_lang_Class::component_mirror(mirror);
#ifdef ASSERT
oop result2 = NULL;
if (ArrayKlass::cast(klass)->dimension() == 1) {
--- a/hotspot/src/share/vm/runtime/stubRoutines.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/runtime/stubRoutines.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -135,6 +135,8 @@
address StubRoutines::_updateBytesCRC32 = NULL;
address StubRoutines::_crc_table_adr = NULL;
+address StubRoutines::_multiplyToLen = NULL;
+
double (* StubRoutines::_intrinsic_log )(double) = NULL;
double (* StubRoutines::_intrinsic_log10 )(double) = NULL;
double (* StubRoutines::_intrinsic_exp )(double) = NULL;
--- a/hotspot/src/share/vm/runtime/stubRoutines.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/runtime/stubRoutines.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -202,6 +202,8 @@
static address _updateBytesCRC32;
static address _crc_table_adr;
+ static address _multiplyToLen;
+
// These are versions of the java.lang.Math methods which perform
// the same operations as the intrinsic version. They are used for
// constant folding in the compiler to ensure equivalence. If the
@@ -358,6 +360,8 @@
static address updateBytesCRC32() { return _updateBytesCRC32; }
static address crc_table_addr() { return _crc_table_adr; }
+ static address multiplyToLen() {return _multiplyToLen; }
+
static address select_fill_function(BasicType t, bool aligned, const char* &name);
static address zero_aligned_words() { return _zero_aligned_words; }
--- a/hotspot/src/share/vm/runtime/vmStructs.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/runtime/vmStructs.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -274,7 +274,6 @@
volatile_nonstatic_field(ArrayKlass, _higher_dimension, Klass*) \
volatile_nonstatic_field(ArrayKlass, _lower_dimension, Klass*) \
nonstatic_field(ArrayKlass, _vtable_len, int) \
- nonstatic_field(ArrayKlass, _component_mirror, oop) \
nonstatic_field(CompiledICHolder, _holder_method, Method*) \
nonstatic_field(CompiledICHolder, _holder_klass, Klass*) \
nonstatic_field(ConstantPool, _tags, Array<u1>*) \
@@ -811,6 +810,7 @@
static_field(StubRoutines, _cipherBlockChaining_decryptAESCrypt, address) \
static_field(StubRoutines, _updateBytesCRC32, address) \
static_field(StubRoutines, _crc_table_adr, address) \
+ static_field(StubRoutines, _multiplyToLen, address) \
\
/*****************/ \
/* SharedRuntime */ \
--- a/hotspot/src/share/vm/utilities/hashtable.cpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/utilities/hashtable.cpp Wed Sep 10 17:06:36 2014 -0700
@@ -37,21 +37,22 @@
#include "utilities/numberSeq.hpp"
-// This is a generic hashtable, designed to be used for the symbol
-// and string tables.
-//
-// It is implemented as an open hash table with a fixed number of buckets.
-//
-// %note:
-// - HashtableEntrys are allocated in blocks to reduce the space overhead.
+// This hashtable is implemented as an open hash table with a fixed number of buckets.
-template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry(unsigned int hashValue) {
- BasicHashtableEntry<F>* entry;
-
- if (_free_list) {
+template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry_free_list() {
+ BasicHashtableEntry<F>* entry = NULL;
+ if (_free_list != NULL) {
entry = _free_list;
_free_list = _free_list->next();
- } else {
+ }
+ return entry;
+}
+
+// HashtableEntrys are allocated in blocks to reduce the space overhead.
+template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry(unsigned int hashValue) {
+ BasicHashtableEntry<F>* entry = new_entry_free_list();
+
+ if (entry == NULL) {
if (_first_free_entry + _entry_size >= _end_block) {
int block_size = MIN2(512, MAX2((int)_table_size / 2, (int)_number_of_entries));
int len = _entry_size * block_size;
@@ -84,9 +85,9 @@
// This is somewhat an arbitrary heuristic but if one bucket gets to
// rehash_count which is currently 100, there's probably something wrong.
-template <MEMFLAGS F> bool BasicHashtable<F>::check_rehash_table(int count) {
- assert(table_size() != 0, "underflow");
- if (count > (((double)number_of_entries()/(double)table_size())*rehash_multiple)) {
+template <class T, MEMFLAGS F> bool RehashableHashtable<T, F>::check_rehash_table(int count) {
+ assert(this->table_size() != 0, "underflow");
+ if (count > (((double)this->number_of_entries()/(double)this->table_size())*rehash_multiple)) {
// Set a flag for the next safepoint, which should be at some guaranteed
// safepoint interval.
return true;
@@ -94,13 +95,13 @@
return false;
}
-template <class T, MEMFLAGS F> juint Hashtable<T, F>::_seed = 0;
+template <class T, MEMFLAGS F> juint RehashableHashtable<T, F>::_seed = 0;
// Create a new table and using alternate hash code, populate the new table
// with the existing elements. This can be used to change the hash code
// and could in the future change the size of the table.
-template <class T, MEMFLAGS F> void Hashtable<T, F>::move_to(Hashtable<T, F>* new_table) {
+template <class T, MEMFLAGS F> void RehashableHashtable<T, F>::move_to(RehashableHashtable<T, F>* new_table) {
// Initialize the global seed for hashing.
_seed = AltHashing::compute_seed();
@@ -110,7 +111,7 @@
// Iterate through the table and create a new entry for the new table
for (int i = 0; i < new_table->table_size(); ++i) {
- for (HashtableEntry<T, F>* p = bucket(i); p != NULL; ) {
+ for (HashtableEntry<T, F>* p = this->bucket(i); p != NULL; ) {
HashtableEntry<T, F>* next = p->next();
T string = p->literal();
// Use alternate hashing algorithm on the symbol in the first table
@@ -239,11 +240,11 @@
}
}
-template <class T, MEMFLAGS F> int Hashtable<T, F>::literal_size(Symbol *symbol) {
+template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(Symbol *symbol) {
return symbol->size() * HeapWordSize;
}
-template <class T, MEMFLAGS F> int Hashtable<T, F>::literal_size(oop oop) {
+template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(oop oop) {
// NOTE: this would over-count if (pre-JDK8) java_lang_Class::has_offset_field() is true,
// and the String.value array is shared by several Strings. However, starting from JDK8,
// the String.value array is not shared anymore.
@@ -256,12 +257,12 @@
// Note: if you create a new subclass of Hashtable<MyNewType, F>, you will need to
// add a new function Hashtable<T, F>::literal_size(MyNewType lit)
-template <class T, MEMFLAGS F> void Hashtable<T, F>::dump_table(outputStream* st, const char *table_name) {
+template <class T, MEMFLAGS F> void RehashableHashtable<T, F>::dump_table(outputStream* st, const char *table_name) {
NumberSeq summary;
int literal_bytes = 0;
for (int i = 0; i < this->table_size(); ++i) {
int count = 0;
- for (HashtableEntry<T, F>* e = bucket(i);
+ for (HashtableEntry<T, F>* e = this->bucket(i);
e != NULL; e = e->next()) {
count++;
literal_bytes += literal_size(e->literal());
@@ -271,7 +272,7 @@
double num_buckets = summary.num();
double num_entries = summary.sum();
- int bucket_bytes = (int)num_buckets * sizeof(bucket(0));
+ int bucket_bytes = (int)num_buckets * sizeof(HashtableBucket<F>);
int entry_bytes = (int)num_entries * sizeof(HashtableEntry<T, F>);
int total_bytes = literal_bytes + bucket_bytes + entry_bytes;
@@ -354,12 +355,20 @@
// Explicitly instantiate these types
+#if INCLUDE_ALL_GCS
+template class Hashtable<nmethod*, mtGC>;
+template class HashtableEntry<nmethod*, mtGC>;
+template class BasicHashtable<mtGC>;
+#endif
template class Hashtable<ConstantPool*, mtClass>;
+template class RehashableHashtable<Symbol*, mtSymbol>;
+template class RehashableHashtable<oopDesc*, mtSymbol>;
template class Hashtable<Symbol*, mtSymbol>;
template class Hashtable<Klass*, mtClass>;
template class Hashtable<oop, mtClass>;
#if defined(SOLARIS) || defined(CHECK_UNHANDLED_OOPS)
template class Hashtable<oop, mtSymbol>;
+template class RehashableHashtable<oop, mtSymbol>;
#endif // SOLARIS || CHECK_UNHANDLED_OOPS
template class Hashtable<oopDesc*, mtSymbol>;
template class Hashtable<Symbol*, mtClass>;
--- a/hotspot/src/share/vm/utilities/hashtable.hpp Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/src/share/vm/utilities/hashtable.hpp Wed Sep 10 17:06:36 2014 -0700
@@ -178,11 +178,6 @@
void verify_lookup_length(double load);
#endif
- enum {
- rehash_count = 100,
- rehash_multiple = 60
- };
-
void initialize(int table_size, int entry_size, int number_of_entries);
// Accessor
@@ -194,12 +189,12 @@
// The following method is not MT-safe and must be done under lock.
BasicHashtableEntry<F>** bucket_addr(int i) { return _buckets[i].entry_addr(); }
+ // Attempt to get an entry from the free list
+ BasicHashtableEntry<F>* new_entry_free_list();
+
// Table entry management
BasicHashtableEntry<F>* new_entry(unsigned int hashValue);
- // Check that the table is unbalanced
- bool check_rehash_table(int count);
-
// Used when moving the entry to another table
// Clean up links, but do not add to free_list
void unlink_entry(BasicHashtableEntry<F>* entry) {
@@ -277,8 +272,30 @@
return (HashtableEntry<T, F>**)BasicHashtable<F>::bucket_addr(i);
}
+};
+
+template <class T, MEMFLAGS F> class RehashableHashtable : public Hashtable<T, F> {
+ protected:
+
+ enum {
+ rehash_count = 100,
+ rehash_multiple = 60
+ };
+
+ // Check that the table is unbalanced
+ bool check_rehash_table(int count);
+
+ public:
+ RehashableHashtable(int table_size, int entry_size)
+ : Hashtable<T, F>(table_size, entry_size) { }
+
+ RehashableHashtable(int table_size, int entry_size,
+ HashtableBucket<F>* buckets, int number_of_entries)
+ : Hashtable<T, F>(table_size, entry_size, buckets, number_of_entries) { }
+
+
// Function to move these elements into the new table.
- void move_to(Hashtable<T, F>* new_table);
+ void move_to(RehashableHashtable<T, F>* new_table);
static bool use_alternate_hashcode() { return _seed != 0; }
static juint seed() { return _seed; }
@@ -292,7 +309,6 @@
static int literal_size(ConstantPool *cp) {Unimplemented(); return 0;}
static int literal_size(Klass *k) {Unimplemented(); return 0;}
-public:
void dump_table(outputStream* st, const char *table_name);
private:
--- a/hotspot/test/TEST.groups Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/TEST.groups Wed Sep 10 17:06:36 2014 -0700
@@ -80,6 +80,7 @@
runtime/NMT/MallocSiteHashOverflow.java \
runtime/NMT/MallocStressTest.java \
runtime/NMT/MallocTestType.java \
+ runtime/NMT/MallocTrackingVerify.java \
runtime/NMT/ReleaseCommittedMemory.java \
runtime/NMT/ReleaseNoCommit.java \
runtime/NMT/ShutdownTwice.java \
@@ -87,6 +88,7 @@
runtime/NMT/SummarySanityCheck.java \
runtime/NMT/ThreadedMallocTestType.java \
runtime/NMT/ThreadedVirtualAllocTestType.java \
+ runtime/NMT/UnsafeMallocLimit.java \
runtime/NMT/VirtualAllocCommitUncommitRecommit.java \
runtime/NMT/VirtualAllocTestType.java \
runtime/RedefineObject/TestRedefineObject.java \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/arraycopy/TestArrayOfNoTypeCheck.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,63 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8055910
+ * @summary Arrays.copyOf doesn't perform subtype check
+ * @run main/othervm -XX:-BackgroundCompilation -XX:-UseOnStackReplacement TestArrayOfNoTypeCheck
+ *
+ */
+
+import java.util.Arrays;
+
+public class TestArrayOfNoTypeCheck {
+
+ static class A {
+ }
+
+ static class B extends A {
+ }
+
+ static B[] test(A[] arr) {
+ return Arrays.copyOf(arr, 10, B[].class);
+ }
+
+ static public void main(String[] args) {
+ A[] arr = new A[20];
+ for (int i = 0; i < 20000; i++) {
+ test(arr);
+ }
+ A[] arr2 = new A[20];
+ arr2[0] = new A();
+ boolean exception = false;
+ try {
+ test(arr2);
+ } catch (ArrayStoreException ase) {
+ exception = true;
+ }
+ if (!exception) {
+ throw new RuntimeException("TEST FAILED: ArrayStoreException not thrown");
+ }
+ }
+}
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/AddExactIntTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/AddExactIntTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build AddExactIntTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics AddExactIntTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class AddExactIntTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/AddExactLongTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/AddExactLongTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build AddExactLongTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics AddExactLongTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class AddExactLongTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/DecrementExactIntTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/DecrementExactIntTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build DecrementExactIntTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics DecrementExactIntTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class DecrementExactIntTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/DecrementExactLongTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/DecrementExactLongTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build DecrementExactLongTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics DecrementExactLongTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class DecrementExactLongTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/IncrementExactIntTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/IncrementExactIntTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build IncrementExactIntTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics IncrementExactIntTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class IncrementExactIntTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/IncrementExactLongTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/IncrementExactLongTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build IncrementExactLongTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics IncrementExactLongTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class IncrementExactLongTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/IntrinsicBase.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/IntrinsicBase.java Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 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
@@ -22,6 +22,7 @@
*/
import com.oracle.java.testlibrary.Platform;
+import intrinsics.Verifier;
import java.io.FileOutputStream;
import java.lang.reflect.Executable;
@@ -79,10 +80,10 @@
System.out.println("Expected intrinsic count is " + expectedIntrinsicCount + " name " + getIntrinsicId());
- final FileOutputStream out = new FileOutputStream(getVMOption("LogFile") + ".verify.properties");
+ final FileOutputStream out = new FileOutputStream(getVMOption("LogFile") + Verifier.PROPERTY_FILE_SUFFIX);
Properties expectedProps = new Properties();
- expectedProps.setProperty("intrinsic.name", getIntrinsicId());
- expectedProps.setProperty("intrinsic.expectedCount", String.valueOf(expectedIntrinsicCount));
+ expectedProps.setProperty(Verifier.INTRINSIC_NAME_PROPERTY, getIntrinsicId());
+ expectedProps.setProperty(Verifier.INTRINSIC_EXPECTED_COUNT_PROPERTY, String.valueOf(expectedIntrinsicCount));
expectedProps.store(out, null);
out.close();
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/MultiplyExactIntTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/MultiplyExactIntTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build MultiplyExactIntTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics MultiplyExactIntTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class MultiplyExactIntTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/MultiplyExactLongTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/MultiplyExactLongTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build MultiplyExactLongTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics MultiplyExactLongTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class MultiplyExactLongTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/NegateExactIntTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/NegateExactIntTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build NegateExactIntTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics NegateExactIntTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class NegateExactIntTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/NegateExactLongTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/NegateExactLongTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build NegateExactLongTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics NegateExactLongTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class NegateExactLongTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/SubtractExactIntTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/SubtractExactIntTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build SubtractExactIntTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics SubtractExactIntTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/SubtractExactLongTest.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/compiler/intrinsics/mathexact/sanity/SubtractExactLongTest.java Wed Sep 10 17:06:36 2014 -0700
@@ -24,6 +24,7 @@
/*
* @test
* @library /testlibrary /testlibrary/whitebox /compiler/whitebox
+ * /compiler/testlibrary
* @build SubtractExactLongTest
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
@@ -35,7 +36,7 @@
* -XX:+IgnoreUnrecognizedVMOptions -XX:+WhiteBoxAPI -XX:+LogCompilation
* -XX:CompileCommand=compileonly,MathIntrinsic*::execMathMethod
* -XX:LogFile=hs.log -XX:+UseMathExactIntrinsics SubtractExactLongTest
- * @run main Verifier hs_neg.log hs.log
+ * @run main intrinsics.Verifier hs_neg.log hs.log
*/
public class SubtractExactLongTest {
--- a/hotspot/test/compiler/intrinsics/mathexact/sanity/Verifier.java Wed Sep 10 11:52:16 2014 -0600
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,71 +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.
- */
-
-import java.io.BufferedReader;
-import java.io.FileReader;
-import java.util.Properties;
-
-public class Verifier {
-
- public static void main(String[] args) throws Exception {
- if (args.length == 0)
- throw new RuntimeException("Test bug, nothing to verify");
- for (String hsLogFile : args) {
- verify(hsLogFile);
- }
- }
-
- private static void verify(String hsLogFile) throws Exception {
- System.out.println("Verifying " + hsLogFile);
-
- final Properties expectedProperties = new Properties();
- final FileReader reader = new FileReader(hsLogFile + ".verify.properties");
- expectedProperties.load(reader);
- reader.close();
-
- int fullMatchCnt = 0;
- int suspectCnt = 0;
- final String intrinsicId = expectedProperties.getProperty("intrinsic.name");
- final String prefix = "<intrinsic id='";
- final String prefixWithId = prefix + intrinsicId + "'";
- final int expectedCount = Integer.parseInt(expectedProperties.getProperty("intrinsic.expectedCount"));
-
- BufferedReader r = new BufferedReader(new FileReader(hsLogFile));
- String s;
- while ((s = r.readLine()) != null) {
- if (s.startsWith(prefix)) {
- if (s.startsWith(prefixWithId)) {
- fullMatchCnt++;
- } else {
- suspectCnt++;
- System.out.println("WARNING: Other intrinsic detected " + s);
- }
- }
- }
- r.close();
-
- System.out.println("Intrinsic " + intrinsicId + " verification, expected: " + expectedCount + ", matched: " + fullMatchCnt + ", suspected: " + suspectCnt);
- if (expectedCount != fullMatchCnt)
- throw new RuntimeException("Unexpected count of intrinsic " + prefixWithId + " expected:" + expectedCount + ", matched: " + fullMatchCnt + ", suspected: " + suspectCnt);
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/multiplytolen/TestMultiplyToLen.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,113 @@
+/*
+ * 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.
+ *
+ */
+
+/**
+ * @test
+ * @bug 8055494
+ * @summary Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
+ *
+ * @run main/othervm/timeout=600 -XX:-TieredCompilation -Xbatch
+ * -XX:CompileCommand=exclude,TestMultiplyToLen::main
+ * -XX:CompileCommand=option,TestMultiplyToLen::base_multiply,ccstr,DisableIntrinsic,_multiplyToLen
+ * -XX:CompileCommand=option,java.math.BigInteger::multiply,ccstr,DisableIntrinsic,_multiplyToLen
+ * -XX:CompileCommand=inline,java.math.BigInteger::multiply TestMultiplyToLen
+ */
+
+import java.util.Random;
+import java.math.*;
+
+public class TestMultiplyToLen {
+
+ // Avoid intrinsic by preventing inlining multiply() and multiplyToLen().
+ public static BigInteger base_multiply(BigInteger op1, BigInteger op2) {
+ return op1.multiply(op2);
+ }
+
+ // Generate multiplyToLen() intrinsic by inlining multiply().
+ public static BigInteger new_multiply(BigInteger op1, BigInteger op2) {
+ return op1.multiply(op2);
+ }
+
+ public static boolean bytecompare(BigInteger b1, BigInteger b2) {
+ byte[] data1 = b1.toByteArray();
+ byte[] data2 = b2.toByteArray();
+ if (data1.length != data2.length)
+ return false;
+ for (int i = 0; i < data1.length; i++) {
+ if (data1[i] != data2[i])
+ return false;
+ }
+ return true;
+ }
+
+ public static String stringify(BigInteger b) {
+ String strout= "";
+ byte [] data = b.toByteArray();
+ for (int i = 0; i < data.length; i++) {
+ strout += (String.format("%02x",data[i]) + " ");
+ }
+ return strout;
+ }
+
+ public static void main(String args[]) throws Exception {
+
+ BigInteger oldsum = new BigInteger("0");
+ BigInteger newsum = new BigInteger("0");
+
+ BigInteger b1, b2, oldres, newres;
+
+ Random rand = new Random();
+ long seed = System.nanoTime();
+ Random rand1 = new Random();
+ long seed1 = System.nanoTime();
+ rand.setSeed(seed);
+ rand1.setSeed(seed1);
+
+ for (int j = 0; j < 1000000; j++) {
+ int rand_int = rand1.nextInt(3136)+32;
+ int rand_int1 = rand1.nextInt(3136)+32;
+ b1 = new BigInteger(rand_int, rand);
+ b2 = new BigInteger(rand_int1, rand);
+
+ oldres = base_multiply(b1,b2);
+ newres = new_multiply(b1,b2);
+
+ oldsum = oldsum.add(oldres);
+ newsum = newsum.add(newres);
+
+ if (!bytecompare(oldres,newres)) {
+ System.out.print("mismatch for:b1:" + stringify(b1) + " :b2:" + stringify(b2) + " :oldres:" + stringify(oldres) + " :newres:" + stringify(newres));
+ System.out.println(b1);
+ System.out.println(b2);
+ throw new Exception("Failed");
+ }
+ }
+ if (!bytecompare(oldsum,newsum)) {
+ System.out.println("Failure: oldsum:" + stringify(oldsum) + " newsum:" + stringify(newsum));
+ throw new Exception("Failed");
+ } else {
+ System.out.println("Success");
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/SHAOptionsBase.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,169 @@
+/*
+ * 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.
+ */
+
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
+import sha.predicate.IntrinsicPredicates;
+
+import java.util.function.BooleanSupplier;
+
+/**
+ * Base class for all CLI tests on SHA-related options.
+ *
+ * Instead of using huge complex tests for each option, each test is constructed
+ * from several test cases shared among different tests.
+ */
+public class SHAOptionsBase extends CommandLineOptionTest {
+ protected static final String USE_SHA_OPTION = "UseSHA";
+ protected static final String USE_SHA1_INTRINSICS_OPTION
+ = "UseSHA1Intrinsics";
+ protected static final String USE_SHA256_INTRINSICS_OPTION
+ = "UseSHA256Intrinsics";
+ protected static final String USE_SHA512_INTRINSICS_OPTION
+ = "UseSHA512Intrinsics";
+
+ // Note that strings below will be passed to
+ // CommandLineOptionTest.verifySameJVMStartup and thus are regular
+ // expressions, not just a plain strings.
+ protected static final String SHA_INSTRUCTIONS_ARE_NOT_AVAILABLE
+ = "SHA instructions are not available on this CPU";
+ protected static final String SHA1_INSTRUCTION_IS_NOT_AVAILABLE
+ = "SHA1 instruction is not available on this CPU\\.";
+ protected static final String SHA256_INSTRUCTION_IS_NOT_AVAILABLE
+ = "SHA256 instruction \\(for SHA-224 and SHA-256\\) "
+ + "is not available on this CPU\\.";
+ protected static final String SHA512_INSTRUCTION_IS_NOT_AVAILABLE
+ = "SHA512 instruction \\(for SHA-384 and SHA-512\\) "
+ + "is not available on this CPU\\.";
+ protected static final String SHA_INTRINSICS_ARE_NOT_AVAILABLE
+ = "SHA intrinsics are not available on this CPU";
+
+ private final TestCase[] testCases;
+
+ /**
+ * Returns warning message that should occur in VM output if an option with
+ * the name {@code optionName} was turned on and CPU does not support
+ * required instructions.
+ *
+ * @param optionName The name of the option for which warning message should
+ * be returned.
+ * @return A warning message that will be printed out to VM output if CPU
+ * instructions required by the option are not supported.
+ */
+ protected static String getWarningForUnsupportedCPU(String optionName) {
+ if (Platform.isSparc()) {
+ switch (optionName) {
+ case SHAOptionsBase.USE_SHA_OPTION:
+ return SHAOptionsBase.SHA_INSTRUCTIONS_ARE_NOT_AVAILABLE;
+ case SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION:
+ return SHAOptionsBase.SHA1_INSTRUCTION_IS_NOT_AVAILABLE;
+ case SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION:
+ return SHAOptionsBase.SHA256_INSTRUCTION_IS_NOT_AVAILABLE;
+ case SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION:
+ return SHAOptionsBase.SHA512_INSTRUCTION_IS_NOT_AVAILABLE;
+ default:
+ throw new Error("Unexpected option " + optionName);
+ }
+ } else if (Platform.isX64() || Platform.isX86()) {
+ switch (optionName) {
+ case SHAOptionsBase.USE_SHA_OPTION:
+ return SHAOptionsBase.SHA_INSTRUCTIONS_ARE_NOT_AVAILABLE;
+ case SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION:
+ case SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION:
+ case SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION:
+ return SHAOptionsBase.SHA_INTRINSICS_ARE_NOT_AVAILABLE;
+ default:
+ throw new Error("Unexpected option " + optionName);
+ }
+ } else {
+ throw new Error("Support for CPUs other then X86 or SPARC is not "
+ + "implemented.");
+ }
+ }
+
+ /**
+ * Returns the predicate indicating whether or not CPU instructions required
+ * by the option with name {@code optionName} are available.
+ *
+ * @param optionName The name of the option for which a predicate should be
+ * returned.
+ * @return The predicate on availability of CPU instructions required by the
+ * option.
+ */
+ protected static BooleanSupplier getPredicateForOption(String optionName) {
+ switch (optionName) {
+ case SHAOptionsBase.USE_SHA_OPTION:
+ return IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE;
+ case SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION:
+ return IntrinsicPredicates.SHA1_INSTRUCTION_AVAILABLE;
+ case SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION:
+ return IntrinsicPredicates.SHA256_INSTRUCTION_AVAILABLE;
+ case SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION:
+ return IntrinsicPredicates.SHA512_INSTRUCTION_AVAILABLE;
+ default:
+ throw new Error("Unexpected option " + optionName);
+ }
+ }
+
+ public SHAOptionsBase(TestCase... testCases) {
+ super(Boolean.TRUE::booleanValue);
+ this.testCases = testCases;
+ }
+
+ @Override
+ protected void runTestCases() throws Throwable {
+ for (TestCase testCase : testCases) {
+ testCase.test();
+ }
+ }
+
+ public static abstract class TestCase {
+ protected final String optionName;
+ private final BooleanSupplier predicate;
+
+ protected TestCase(String optionName, BooleanSupplier predicate) {
+ this.optionName = optionName;
+ this.predicate = predicate;
+ }
+
+ protected final void test() throws Throwable {
+ String testCaseName = this.getClass().getName();
+ if (!predicate.getAsBoolean()) {
+ System.out.println("Skipping " + testCaseName
+ + " due to predicate failure.");
+ return;
+ } else {
+ System.out.println("Running " + testCaseName);
+ }
+
+ verifyWarnings();
+ verifyOptionValues();
+ }
+
+ protected void verifyWarnings() throws Throwable {
+ }
+
+ protected void verifyOptionValues() throws Throwable {
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnSupportedCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify UseSHA1Intrinsics option processing on supported CPU,
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary testcases
+ * @build TestUseSHA1IntrinsicsOptionOnSupportedCPU
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI TestUseSHA1IntrinsicsOptionOnSupportedCPU
+ */
+public class TestUseSHA1IntrinsicsOptionOnSupportedCPU {
+ public static void main(String args[]) throws Throwable {
+ new SHAOptionsBase(new GenericTestCaseForSupportedSparcCPU(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION)).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnUnsupportedCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify UseSHA1Intrinsics option processing on unsupported CPU,
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary testcases
+ * @build TestUseSHA1IntrinsicsOptionOnUnsupportedCPU
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI
+ * TestUseSHA1IntrinsicsOptionOnUnsupportedCPU
+ */
+public class TestUseSHA1IntrinsicsOptionOnUnsupportedCPU {
+ public static void main(String args[]) throws Throwable {
+ new SHAOptionsBase(
+ new GenericTestCaseForUnsupportedSparcCPU(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION),
+ new UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION),
+ new GenericTestCaseForUnsupportedX86CPU(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION),
+ new GenericTestCaseForOtherCPU(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION)).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnSupportedCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify UseSHA256Intrinsics option processing on supported CPU,
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary testcases
+ * @build TestUseSHA256IntrinsicsOptionOnSupportedCPU
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI
+ * TestUseSHA256IntrinsicsOptionOnSupportedCPU
+ */
+public class TestUseSHA256IntrinsicsOptionOnSupportedCPU {
+ public static void main(String args[]) throws Throwable {
+ new SHAOptionsBase(new GenericTestCaseForSupportedSparcCPU(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION)).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnUnsupportedCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify UseSHA256Intrinsics option processing on unsupported CPU,
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary testcases
+ * @build TestUseSHA256IntrinsicsOptionOnUnsupportedCPU
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI
+ * TestUseSHA256IntrinsicsOptionOnUnsupportedCPU
+ */
+public class TestUseSHA256IntrinsicsOptionOnUnsupportedCPU {
+ public static void main(String args[]) throws Throwable {
+ new SHAOptionsBase(
+ new GenericTestCaseForUnsupportedSparcCPU(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION),
+ new UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION),
+ new GenericTestCaseForUnsupportedX86CPU(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION),
+ new GenericTestCaseForOtherCPU(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION)).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnSupportedCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify UseSHA512Intrinsics option processing on supported CPU.
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary testcases
+ * @build TestUseSHA512IntrinsicsOptionOnSupportedCPU
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI
+ * TestUseSHA512IntrinsicsOptionOnSupportedCPU
+ */
+public class TestUseSHA512IntrinsicsOptionOnSupportedCPU {
+ public static void main(String args[]) throws Throwable {
+ new SHAOptionsBase(new GenericTestCaseForSupportedSparcCPU(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION)).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnUnsupportedCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify UseSHA512Intrinsics option processing on unsupported CPU,
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary testcases
+ * @build TestUseSHA512IntrinsicsOptionOnUnsupportedCPU
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI
+ * TestUseSHA512IntrinsicsOptionOnUnsupportedCPU
+ */
+public class TestUseSHA512IntrinsicsOptionOnUnsupportedCPU {
+ public static void main(String args[]) throws Throwable {
+ new SHAOptionsBase(
+ new GenericTestCaseForUnsupportedSparcCPU(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION),
+ new UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION),
+ new GenericTestCaseForUnsupportedX86CPU(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION),
+ new GenericTestCaseForOtherCPU(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION)).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHAOptionOnSupportedCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,43 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify UseSHA option processing on supported CPU,
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary testcases
+ * @build TestUseSHAOptionOnSupportedCPU
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI TestUseSHAOptionOnSupportedCPU
+ */
+public class TestUseSHAOptionOnSupportedCPU {
+ public static void main(String args[]) throws Throwable {
+ new SHAOptionsBase(
+ new GenericTestCaseForSupportedSparcCPU(
+ SHAOptionsBase.USE_SHA_OPTION),
+ new UseSHASpecificTestCaseForSupportedSparcCPU(
+ SHAOptionsBase.USE_SHA_OPTION)).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHAOptionOnUnsupportedCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,47 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify UseSHA option processing on unsupported CPU.
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary testcases
+ * @build TestUseSHAOptionOnUnsupportedCPU
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI TestUseSHAOptionOnUnsupportedCPU
+ */
+public class TestUseSHAOptionOnUnsupportedCPU {
+ public static void main(String args[]) throws Throwable {
+ new SHAOptionsBase(
+ new GenericTestCaseForUnsupportedSparcCPU(
+ SHAOptionsBase.USE_SHA_OPTION),
+ new UseSHASpecificTestCaseForUnsupportedSparcCPU(
+ SHAOptionsBase.USE_SHA_OPTION),
+ new GenericTestCaseForUnsupportedX86CPU(
+ SHAOptionsBase.USE_SHA_OPTION),
+ new GenericTestCaseForOtherCPU(
+ SHAOptionsBase.USE_SHA_OPTION)).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForOtherCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+
+import com.oracle.java.testlibrary.ExitCode;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
+import com.oracle.java.testlibrary.cli.predicate.NotPredicate;
+import com.oracle.java.testlibrary.cli.predicate.OrPredicate;
+
+/**
+ * Generic test case for SHA-related options targeted to non-x86 and
+ * non-SPARC CPUs.
+ */
+public class GenericTestCaseForOtherCPU extends
+ SHAOptionsBase.TestCase {
+ public GenericTestCaseForOtherCPU(String optionName) {
+ // Execute the test case on any CPU except SPARC and X86
+ super(optionName, new NotPredicate(new OrPredicate(Platform::isSparc,
+ new OrPredicate(Platform::isX64, Platform::isX86))));
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ // Verify that on non-x86 and non-SPARC CPU usage of SHA-related
+ // options will not cause any warnings.
+ CommandLineOptionTest.verifySameJVMStartup(null,
+ new String[] { ".*" + optionName + ".*" }, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ CommandLineOptionTest.verifySameJVMStartup(null,
+ new String[] { ".*" + optionName + ".*" }, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that option is disabled by default.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false");
+
+ // Verify that option is disabled even if it was explicitly enabled
+ // using CLI options.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ // Verify that option is disabled when it explicitly disabled
+ // using CLI options.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForSupportedSparcCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,93 @@
+/*
+ * 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.
+ */
+
+import com.oracle.java.testlibrary.ExitCode;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
+import com.oracle.java.testlibrary.cli.predicate.AndPredicate;
+
+/**
+ * Generic test case for SHA-related options targeted to SPARC CPUs which
+ * support instructions required by the tested option.
+ */
+public class GenericTestCaseForSupportedSparcCPU extends
+ SHAOptionsBase.TestCase {
+ public GenericTestCaseForSupportedSparcCPU(String optionName) {
+ super(optionName, new AndPredicate(Platform::isSparc,
+ SHAOptionsBase.getPredicateForOption(optionName)));
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ // Verify that there are no warning when option is explicitly enabled.
+ CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ // Verify that option could be disabled even if +UseSHA was passed to
+ // JVM.
+ CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+
+ // Verify that it is possible to enable the tested option and disable
+ // all SHA intrinsics via -UseSHA without any warnings.
+ CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that on supported CPU option is enabled by default.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "true");
+
+ // Verify that it is possible to explicitly enable the option.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "true",
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ // Verify that it is possible to explicitly disable the option.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+
+ // verify that option is disabled when -UseSHA was passed to JVM.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, false));
+
+ // Verify that it is possible to explicitly disable the tested option
+ // even if +UseSHA was passed to JVM.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForUnsupportedSparcCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+import com.oracle.java.testlibrary.ExitCode;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
+import com.oracle.java.testlibrary.cli.predicate.AndPredicate;
+import com.oracle.java.testlibrary.cli.predicate.NotPredicate;
+
+/**
+ * Generic test case for SHA-related options targeted to SPARC CPUs which don't
+ * support instruction required by the tested option.
+ */
+public class GenericTestCaseForUnsupportedSparcCPU extends
+ SHAOptionsBase.TestCase {
+ public GenericTestCaseForUnsupportedSparcCPU(String optionName) {
+ super(optionName, new AndPredicate(Platform::isSparc,
+ new NotPredicate(SHAOptionsBase.getPredicateForOption(
+ optionName))));
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ //Verify that option could be disabled without any warnings.
+ CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that option is disabled by default.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false");
+
+ // Verify that option is disabled even if it was explicitly enabled
+ // using CLI options.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ // Verify that option is disabled when +UseSHA was passed to JVM.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForUnsupportedX86CPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,71 @@
+/*
+ * 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.
+ */
+
+import com.oracle.java.testlibrary.ExitCode;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
+import com.oracle.java.testlibrary.cli.predicate.OrPredicate;
+
+/**
+ * Generic test case for SHA-related options targeted to X86 CPUs that don't
+ * support SHA-related instructions.
+ */
+public class GenericTestCaseForUnsupportedX86CPU
+ extends SHAOptionsBase.TestCase {
+ public GenericTestCaseForUnsupportedX86CPU(String optionName) {
+ super(optionName, new OrPredicate(Platform::isX64, Platform::isX86));
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ // Verify that when the tested option is explicitly enabled, then
+ // a warning will occur in VM output.
+ CommandLineOptionTest.verifySameJVMStartup(new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, null, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ // Verify that the tested option could be explicitly disabled without
+ // a warning.
+ CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that the tested option is disabled by default.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false");
+
+ // Verify that it is not possible to explicitly enable the option.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ // Verify that the tested option is disabled even if +UseSHA was passed
+ // to JVM.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+
+import com.oracle.java.testlibrary.ExitCode;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
+import com.oracle.java.testlibrary.cli.predicate.AndPredicate;
+import com.oracle.java.testlibrary.cli.predicate.NotPredicate;
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * Test case specific to UseSHA*Intrinsics options targeted to SPARC CPUs which
+ * don't support required instruction, but support other SHA-related
+ * instructions.
+ *
+ * For example, CPU support sha1 instruction, but don't support sha256 or
+ * sha512.
+ */
+public class UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU
+ extends SHAOptionsBase.TestCase {
+ public UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU(
+ String optionName) {
+ // execute test case on SPARC CPU that support any sha* instructions,
+ // but does not support sha* instruction required by the tested option.
+ super(optionName, new AndPredicate(Platform::isSparc,
+ new AndPredicate(
+ IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE,
+ new NotPredicate(SHAOptionsBase.getPredicateForOption(
+ optionName)))));
+ }
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ // Verify that attempt to enable the tested option will cause a warning.
+ CommandLineOptionTest.verifySameJVMStartup(new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, null, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/UseSHASpecificTestCaseForSupportedSparcCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,101 @@
+/*
+ * 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.
+ */
+
+import com.oracle.java.testlibrary.Asserts;
+import com.oracle.java.testlibrary.ExitCode;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
+import com.oracle.java.testlibrary.cli.predicate.AndPredicate;
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * UseSHA specific test case targeted to SPARC CPUs which support any sha*
+ * instruction.
+ */
+public class UseSHASpecificTestCaseForSupportedSparcCPU
+ extends SHAOptionsBase.TestCase {
+ public UseSHASpecificTestCaseForSupportedSparcCPU(String optionName) {
+ super(SHAOptionsBase.USE_SHA_OPTION, new AndPredicate(Platform::isSparc,
+ IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE));
+
+ Asserts.assertEQ(optionName, SHAOptionsBase.USE_SHA_OPTION,
+ "Test case should be used for " + SHAOptionsBase.USE_SHA_OPTION
+ + " option only.");
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ // Verify that there will be no warnings when +UseSHA was passed and
+ // all UseSHA*Intrinsics options were disabled.
+ CommandLineOptionTest.verifySameJVMStartup(
+ null, new String[] { ".*UseSHA.*" }, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, false));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that UseSHA is disabled when all UseSHA*Intrinscs are
+ // disabled.
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ SHAOptionsBase.USE_SHA_OPTION, "false",
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, false));
+
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ // Verify that UseSHA is disabled when all UseSHA*Intrinscs are
+ // disabled even if it was explicitly enabled.
+ SHAOptionsBase.USE_SHA_OPTION, "false",
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, false));
+
+ // Verify that explicitly disabled UseSHA option remains disabled even
+ // if all UseSHA*Intrinsics options were enabled.
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ SHAOptionsBase.USE_SHA_OPTION, "false",
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, true));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/UseSHASpecificTestCaseForUnsupportedSparcCPU.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,83 @@
+/*
+ * 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.
+ */
+
+import com.oracle.java.testlibrary.Asserts;
+import com.oracle.java.testlibrary.ExitCode;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
+import com.oracle.java.testlibrary.cli.predicate.AndPredicate;
+import com.oracle.java.testlibrary.cli.predicate.NotPredicate;
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * UseSHA specific test case targeted to SPARC CPUs which don't support all sha*
+ * instructions.
+ */
+public class UseSHASpecificTestCaseForUnsupportedSparcCPU
+ extends SHAOptionsBase.TestCase {
+ public UseSHASpecificTestCaseForUnsupportedSparcCPU(String optionName) {
+ super(SHAOptionsBase.USE_SHA_OPTION, new AndPredicate(Platform::isSparc,
+ new NotPredicate(
+ IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE)));
+
+ Asserts.assertEQ(optionName, SHAOptionsBase.USE_SHA_OPTION,
+ "Test case should be used for " + SHAOptionsBase.USE_SHA_OPTION
+ + " option only.");
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ // Verify that attempt to use UseSHA option will cause a warning.
+ CommandLineOptionTest.verifySameJVMStartup(new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, null, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that UseSHA option remains disabled even if all
+ // UseSHA*Intrincs options were enabled.
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ SHAOptionsBase.USE_SHA_OPTION, "false",
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, true));
+
+ // Verify that UseSHA option remains disabled even if all
+ // UseSHA*Intrincs options were enabled and UseSHA was enabled as well.
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ SHAOptionsBase.USE_SHA_OPTION, "false",
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, true));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/sanity/SHASanityTestBase.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,109 @@
+/*
+ * 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.
+ */
+
+import intrinsics.Verifier;
+import sun.hotspot.WhiteBox;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Objects;
+import java.util.Properties;
+import java.util.function.BooleanSupplier;
+
+/**
+ * Base class for sanity tests on SHA intrinsics support.
+ */
+public class SHASanityTestBase {
+ protected static final String SHA1_INTRINSIC_ID
+ = "_sha_implCompress";
+ protected static final String SHA256_INTRINSIC_ID
+ = "_sha2_implCompress";
+ protected static final String SHA512_INTRINSIC_ID
+ = "_sha5_implCompress";
+ protected static final String MB_INTRINSIC_ID
+ = "_digestBase_implCompressMB";
+
+ private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
+ private static final int MSG_SIZE = 1024;
+ private static final int OFFSET = 0;
+ private static final int ITERATIONS = 10000;
+ private static final int WARMUP_ITERATIONS = 1;
+ private static final String PROVIDER = "SUN";
+
+ private final BooleanSupplier predicate;
+ private final String intrinsicID;
+
+ /**
+ * Construct the new test on intrinsic with ID {@code intrinsicID},
+ * which is expected to be emitted if {@code predicate} is evaluated to
+ * {@code true}.
+ *
+ * @param predicate The predicate indicating if the intrinsic is expected to
+ * be used.
+ * @param intrinsicID The ID of the intrinsic to be tested.
+ */
+ protected SHASanityTestBase(BooleanSupplier predicate, String intrinsicID) {
+ this.predicate = predicate;
+ this.intrinsicID = intrinsicID;
+ }
+
+ /**
+ * Run the test and dump properties to file.
+ *
+ * @throws Exception when something went wrong.
+ */
+ public final void test() throws Exception {
+ String algorithm = Objects.requireNonNull(
+ System.getProperty("algorithm"),
+ "Algorithm name should be specified.");
+
+ dumpProperties();
+
+ TestSHA.testSHA(SHASanityTestBase.PROVIDER, algorithm,
+ SHASanityTestBase.MSG_SIZE, SHASanityTestBase.OFFSET,
+ SHASanityTestBase.ITERATIONS,
+ SHASanityTestBase.WARMUP_ITERATIONS);
+ }
+
+ /**
+ * Dump properties containing information about the tested intrinsic name
+ * and whether or not is should be used to the file
+ * <LogFile value>.verify.properties.
+ *
+ * @throws IOException when something went wrong during dumping to file.
+ */
+ private void dumpProperties() throws IOException {
+ Properties properties = new Properties();
+ properties.setProperty(Verifier.INTRINSIC_NAME_PROPERTY, intrinsicID);
+ properties.setProperty(Verifier.INTRINSIC_IS_EXPECTED_PROPERTY,
+ String.valueOf(predicate.getAsBoolean()));
+
+ String logFileName
+ = SHASanityTestBase.WHITE_BOX.getStringVMFlag("LogFile");
+ FileOutputStream fileOutputStream = new FileOutputStream(logFileName
+ + Verifier.PROPERTY_FILE_SUFFIX);
+
+ properties.store(fileOutputStream, null);
+ fileOutputStream.close();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/sanity/TestSHA1Intrinsics.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify that SHA-1 intrinsic is actually used.
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary ../
+ * @build TestSHA intrinsics.Verifier TestSHA1Intrinsics
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA1Intrinsics
+ * -Dalgorithm=SHA-1 TestSHA1Intrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:-UseSHA1Intrinsics
+ * -Dalgorithm=SHA-1 TestSHA1Intrinsics
+ * @run main/othervm -DverificationStrategy=VERIFY_INTRINSIC_USAGE
+ * intrinsics.Verifier positive.log negative.log
+ */
+import sha.predicate.IntrinsicPredicates;
+
+public class TestSHA1Intrinsics {
+ public static void main(String args[]) throws Exception {
+ new SHASanityTestBase(IntrinsicPredicates.SHA1_INTRINSICS_AVAILABLE,
+ SHASanityTestBase.SHA1_INTRINSIC_ID).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/sanity/TestSHA1MultiBlockIntrinsics.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify that SHA-1 multi block intrinsic is actually used.
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary ../
+ * @build TestSHA intrinsics.Verifier TestSHA1MultiBlockIntrinsics
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA1Intrinsics -XX:-UseSHA256Intrinsics
+ * -XX:-UseSHA512Intrinsics
+ * -Dalgorithm=SHA-1 TestSHA1MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_def.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA1Intrinsics -Dalgorithm=SHA-1
+ * TestSHA1MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA -XX:-UseSHA
+ * -Dalgorithm=SHA-1 TestSHA1MultiBlockIntrinsics
+ * @run main/othervm -DverificationStrategy=VERIFY_INTRINSIC_USAGE
+ * intrinsics.Verifier positive.log positive_def.log
+ * negative.log
+ */
+public class TestSHA1MultiBlockIntrinsics {
+ public static void main(String args[]) throws Exception {
+ new SHASanityTestBase(IntrinsicPredicates.SHA1_INTRINSICS_AVAILABLE,
+ SHASanityTestBase.MB_INTRINSIC_ID).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/sanity/TestSHA256Intrinsics.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify that SHA-256 intrinsic is actually used.
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary ../
+ * @build TestSHA intrinsics.Verifier TestSHA256Intrinsics
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_224.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA256Intrinsics
+ * -Dalgorithm=SHA-224 TestSHA256Intrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative_224.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:-UseSHA256Intrinsics
+ * -Dalgorithm=SHA-224 TestSHA256Intrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_256.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA256Intrinsics
+ * -Dalgorithm=SHA-256 TestSHA256Intrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative_256.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:-UseSHA256Intrinsics
+ * -Dalgorithm=SHA-256 TestSHA256Intrinsics
+ * @run main/othervm -DverificationStrategy=VERIFY_INTRINSIC_USAGE
+ * intrinsics.Verifier positive_224.log positive_256.log
+ * negative_224.log negative_256.log
+ */
+public class TestSHA256Intrinsics {
+ public static void main(String args[]) throws Exception {
+ new SHASanityTestBase(IntrinsicPredicates.SHA256_INTRINSICS_AVAILABLE,
+ SHASanityTestBase.SHA256_INTRINSIC_ID).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/sanity/TestSHA256MultiBlockIntrinsics.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,92 @@
+/*
+ * 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.
+ */
+
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify that SHA-256 multi block intrinsic is actually used.
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary ../
+ * @build TestSHA intrinsics.Verifier TestSHA256MultiBlockIntrinsics
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_224.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA256Intrinsics -XX:-UseSHA1Intrinsics
+ * -XX:-UseSHA512Intrinsics
+ * -Dalgorithm=SHA-224 TestSHA256MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_224_def.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA256Intrinsics -Dalgorithm=SHA-224
+ * TestSHA256MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative_224.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA -XX:-UseSHA
+ * -Dalgorithm=SHA-224 TestSHA256MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_256.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA256Intrinsics -XX:-UseSHA1Intrinsics
+ * -XX:-UseSHA512Intrinsics
+ * -Dalgorithm=SHA-256 TestSHA256MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_256_def.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA256Intrinsics -Dalgorithm=SHA-256
+ * TestSHA256MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative_256.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA -XX:-UseSHA
+ * -Dalgorithm=SHA-256 TestSHA256MultiBlockIntrinsics
+ * @run main/othervm -DverificationStrategy=VERIFY_INTRINSIC_USAGE
+ * intrinsics.Verifier positive_224.log positive_256.log
+ * positive_224_def.log positive_256_def.log negative_224.log
+ * negative_256.log
+ */
+public class TestSHA256MultiBlockIntrinsics {
+ public static void main(String args[]) throws Exception {
+ new SHASanityTestBase(IntrinsicPredicates.SHA256_INTRINSICS_AVAILABLE,
+ SHASanityTestBase.MB_INTRINSIC_ID).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/sanity/TestSHA512Intrinsics.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify that SHA-512 intrinsic is actually used.
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary ../
+ * @build TestSHA intrinsics.Verifier TestSHA512Intrinsics
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_384.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA512Intrinsics
+ * -Dalgorithm=SHA-384 TestSHA512Intrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative_384.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:-UseSHA512Intrinsics
+ * -Dalgorithm=SHA-384 TestSHA512Intrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_512.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA512Intrinsics
+ * -Dalgorithm=SHA-512 TestSHA512Intrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative_512.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:-UseSHA512Intrinsics
+ * -Dalgorithm=SHA-512 TestSHA512Intrinsics
+ * @run main/othervm -DverificationStrategy=VERIFY_INTRINSIC_USAGE
+ * intrinsics.Verifier positive_384.log positive_512.log
+ * negative_384.log negative_512.log
+ */
+public class TestSHA512Intrinsics {
+ public static void main(String args[]) throws Exception {
+ new SHASanityTestBase(IntrinsicPredicates.SHA512_INTRINSICS_AVAILABLE,
+ SHASanityTestBase.SHA512_INTRINSIC_ID).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/sanity/TestSHA512MultiBlockIntrinsics.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,92 @@
+/*
+ * 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.
+ */
+
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * @test
+ * @bug 8035968
+ * @summary Verify that SHA-512 multi block intrinsic is actually used.
+ * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary ../
+ * @build TestSHA intrinsics.Verifier TestSHA512MultiBlockIntrinsics
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_384.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA512Intrinsics -XX:-UseSHA1Intrinsics
+ * -XX:-UseSHA256Intrinsics
+ * -Dalgorithm=SHA-384 TestSHA512MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_384_def.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA512Intrinsics -Dalgorithm=SHA-384
+ * TestSHA512MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative_384.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA -XX:-UseSHA
+ * -Dalgorithm=SHA-384 TestSHA1Intrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_512.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA512Intrinsics -XX:-UseSHA1Intrinsics
+ * -XX:-UseSHA256Intrinsics
+ * -Dalgorithm=SHA-512 TestSHA512MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=positive_512_def.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA
+ * -XX:+UseSHA512Intrinsics -Dalgorithm=SHA-512
+ * TestSHA512MultiBlockIntrinsics
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ * -XX:+WhiteBoxAPI -Xbatch -XX:CompileThreshold=500
+ * -XX:Tier4InvocationThreshold=500
+ * -XX:+LogCompilation -XX:LogFile=negative_512.log
+ * -XX:CompileOnly=sun/security/provider/DigestBase
+ * -XX:CompileOnly=sun/security/provider/SHA -XX:-UseSHA
+ * -Dalgorithm=SHA-512 TestSHA512MultiBlockIntrinsics
+ * @run main/othervm -DverificationStrategy=VERIFY_INTRINSIC_USAGE
+ * intrinsics.Verifier positive_384.log positive_512.log
+ * positive_384_def.log positive_512_def.log negative_384.log
+ * negative_512.log
+ */
+public class TestSHA512MultiBlockIntrinsics {
+ public static void main(String args[]) throws Exception {
+ new SHASanityTestBase(IntrinsicPredicates.SHA512_INTRINSICS_AVAILABLE,
+ SHASanityTestBase.MB_INTRINSIC_ID).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/testlibrary/intrinsics/Verifier.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2013, 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 intrinsics;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.util.Properties;
+
+public class Verifier {
+ enum VerificationStrategy {
+ VERIFY_STRONG_EQUALITY {
+ @Override
+ void verify(Properties expectedProperties, int fullMatchCnt,
+ int suspectCnt) {
+ int expectedCount = Integer.parseInt(
+ expectedProperties.getProperty(
+ Verifier.INTRINSIC_EXPECTED_COUNT_PROPERTY));
+ String intrinsicID = expectedProperties.getProperty(
+ Verifier.INTRINSIC_NAME_PROPERTY);
+
+ System.out.println("Intrinsic " + intrinsicID
+ + " verification, expected: " + expectedCount
+ + ", matched: " + fullMatchCnt
+ + ", suspected: " + suspectCnt);
+ if (expectedCount != fullMatchCnt) {
+ throw new RuntimeException(
+ "Unexpected count of intrinsic "
+ + intrinsicID
+ + " expected:" + expectedCount
+ + ", matched: " + fullMatchCnt
+ + ", suspected: " + suspectCnt);
+ }
+ }
+ },
+
+ VERIFY_INTRINSIC_USAGE {
+ @Override
+ void verify(Properties expectedProperties, int fullMatchCnt,
+ int suspectCnt) {
+ boolean isExpected = Boolean.parseBoolean(
+ expectedProperties.getProperty(
+ Verifier.INTRINSIC_IS_EXPECTED_PROPERTY));
+ String intrinsicID = expectedProperties.getProperty(
+ Verifier.INTRINSIC_NAME_PROPERTY);
+
+ System.out.println("Intrinsic " + intrinsicID
+ + " verification, is expected: " + isExpected
+ + ", matched: " + fullMatchCnt
+ + ", suspected: " + suspectCnt);
+ if ((fullMatchCnt == 0 && isExpected)
+ || (fullMatchCnt > 0 && !isExpected)) {
+ throw new RuntimeException(
+ "Unexpected count of intrinsic "
+ + intrinsicID
+ + " is expected:" + isExpected
+ + ", matched: " + fullMatchCnt
+ + ", suspected: " + suspectCnt);
+ }
+ }
+ };
+
+ void verify(Properties expectedProperties, int fullMathCnt,
+ int suspectCnt) {
+ throw new RuntimeException("Default strategy is not implemented.");
+ }
+ }
+
+ public static final String PROPERTY_FILE_SUFFIX = ".verify.properties";
+ public static final String INTRINSIC_NAME_PROPERTY = "intrinsic.name";
+ public static final String INTRINSIC_IS_EXPECTED_PROPERTY
+ = "intrinsic.expected";
+ public static final String INTRINSIC_EXPECTED_COUNT_PROPERTY
+ = "intrinsic.expectedCount";
+ private static final String DEFAULT_STRATEGY
+ = VerificationStrategy.VERIFY_STRONG_EQUALITY.name();
+
+ public static void main(String[] args) throws Exception {
+ if (args.length == 0) {
+ throw new RuntimeException("Test bug, nothing to verify");
+ }
+ for (String hsLogFile : args) {
+ verify(hsLogFile);
+ }
+ }
+
+ private static void verify(String hsLogFile) throws Exception {
+ System.out.println("Verifying " + hsLogFile);
+
+ Properties expectedProperties = new Properties();
+ FileReader reader = new FileReader(hsLogFile
+ + Verifier.PROPERTY_FILE_SUFFIX);
+ expectedProperties.load(reader);
+ reader.close();
+
+ int fullMatchCnt = 0;
+ int suspectCnt = 0;
+ String intrinsicId = expectedProperties.getProperty(
+ Verifier.INTRINSIC_NAME_PROPERTY);
+ String prefix = "<intrinsic id='";
+ String prefixWithId = prefix + intrinsicId + "'";
+
+ try (BufferedReader compLogReader
+ = new BufferedReader(new FileReader(hsLogFile))) {
+ String logLine;
+ while ((logLine = compLogReader.readLine()) != null) {
+ if (logLine.startsWith(prefix)) {
+ if (logLine.startsWith(prefixWithId)) {
+ fullMatchCnt++;
+ } else {
+ suspectCnt++;
+ System.err.println(
+ "WARNING: Other intrinsic detected " + logLine);
+ }
+ }
+ }
+ }
+
+ VerificationStrategy strategy = VerificationStrategy.valueOf(
+ System.getProperty("verificationStrategy",
+ Verifier.DEFAULT_STRATEGY));
+ strategy.verify(expectedProperties, fullMatchCnt, suspectCnt);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/testlibrary/sha/predicate/IntrinsicPredicates.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,103 @@
+/*
+ * 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 sha.predicate;
+
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.cli.predicate.AndPredicate;
+import com.oracle.java.testlibrary.cli.predicate.CPUSpecificPredicate;
+import com.oracle.java.testlibrary.cli.predicate.OrPredicate;
+import sun.hotspot.WhiteBox;
+
+import java.util.function.BooleanSupplier;
+
+/**
+ * Helper class aimed to provide predicates on availability of SHA-related
+ * CPU instructions and intrinsics.
+ */
+public class IntrinsicPredicates {
+ private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
+ private static final long TIERED_MAX_LEVEL = 4L;
+ /**
+ * Boolean supplier that check if any method could be compiled by C2.
+ * Method potentially could be compiled by C2 if Server VM is used and
+ * either tiered compilation is disabled or TIERED_MAX_LEVEL tier is
+ * reachable.
+ *
+ * Please don't place this definition after SHA*_INTRINSICS_AVAILABLE
+ * definitions. Otherwise its value will be {@code null} at the time when
+ * all dependent fields will be initialized.
+ */
+ private static final BooleanSupplier COMPILABLE_BY_C2 = () -> {
+ boolean isTiered = IntrinsicPredicates.WHITE_BOX.getBooleanVMFlag(
+ "TieredCompilation");
+ long tieredMaxLevel = IntrinsicPredicates.WHITE_BOX.getIntxVMFlag(
+ "TieredStopAtLevel");
+ boolean maxLevelIsReachable = (tieredMaxLevel
+ == IntrinsicPredicates.TIERED_MAX_LEVEL);
+ return Platform.isServer() && (!isTiered || maxLevelIsReachable);
+ };
+
+ public static final BooleanSupplier SHA1_INSTRUCTION_AVAILABLE
+ = new CPUSpecificPredicate("sparc.*", new String[] { "sha1" },
+ null);
+
+ public static final BooleanSupplier SHA256_INSTRUCTION_AVAILABLE
+ = new CPUSpecificPredicate("sparc.*", new String[] { "sha256" },
+ null);
+
+ public static final BooleanSupplier SHA512_INSTRUCTION_AVAILABLE
+ = new CPUSpecificPredicate("sparc.*", new String[] { "sha512" },
+ null);
+
+ public static final BooleanSupplier ANY_SHA_INSTRUCTION_AVAILABLE
+ = new OrPredicate(IntrinsicPredicates.SHA1_INSTRUCTION_AVAILABLE,
+ new OrPredicate(
+ IntrinsicPredicates.SHA256_INSTRUCTION_AVAILABLE,
+ IntrinsicPredicates.SHA512_INSTRUCTION_AVAILABLE));
+
+ public static final BooleanSupplier SHA1_INTRINSICS_AVAILABLE
+ = new AndPredicate(new AndPredicate(
+ IntrinsicPredicates.SHA1_INSTRUCTION_AVAILABLE,
+ IntrinsicPredicates.COMPILABLE_BY_C2),
+ IntrinsicPredicates.booleanOptionValue("UseSHA1Intrinsics"));
+
+ public static final BooleanSupplier SHA256_INTRINSICS_AVAILABLE
+ = new AndPredicate(new AndPredicate(
+ IntrinsicPredicates.SHA256_INSTRUCTION_AVAILABLE,
+ IntrinsicPredicates.COMPILABLE_BY_C2),
+ IntrinsicPredicates.booleanOptionValue("UseSHA256Intrinsics"));
+
+ public static final BooleanSupplier SHA512_INTRINSICS_AVAILABLE
+ = new AndPredicate(new AndPredicate(
+ IntrinsicPredicates.SHA512_INSTRUCTION_AVAILABLE,
+ IntrinsicPredicates.COMPILABLE_BY_C2),
+ IntrinsicPredicates.booleanOptionValue("UseSHA512Intrinsics"));
+
+ private static BooleanSupplier booleanOptionValue(String option) {
+ return () -> IntrinsicPredicates.WHITE_BOX.getBooleanVMFlag(option);
+ }
+
+ private IntrinsicPredicates() {
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/NMT/MallocTrackingVerify.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,105 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8054836
+ * @summary Test to verify correctness of malloc tracking
+ * @key nmt jcmd
+ * @library /testlibrary /testlibrary/whitebox
+ * @build MallocTrackingVerify
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:NativeMemoryTracking=detail MallocTrackingVerify
+ *
+ */
+
+import java.util.ArrayList;
+import java.util.Random;
+
+import com.oracle.java.testlibrary.*;
+
+import sun.hotspot.WhiteBox;
+
+public class MallocTrackingVerify {
+ private static int MAX_ALLOC = 4 * 1024;
+
+ static ArrayList<MallocMemory> mallocd_memory = new ArrayList<MallocMemory>();
+ static long mallocd_total = 0;
+ public static WhiteBox wb = WhiteBox.getWhiteBox();
+
+ public static void main(String args[]) throws Exception {
+ OutputAnalyzer output;
+
+ // Grab my own PID
+ String pid = Integer.toString(ProcessTools.getProcessId());
+ ProcessBuilder pb = new ProcessBuilder();
+
+ Random random = new Random();
+ // Allocate small amounts of memory with random pseudo call stack
+ while (mallocd_total < MAX_ALLOC) {
+ int size = random.nextInt(31) + 1;
+ long addr = wb.NMTMallocWithPseudoStack(size, random.nextInt());
+ if (addr != 0) {
+ MallocMemory mem = new MallocMemory(addr, size);
+ mallocd_memory.add(mem);
+ mallocd_total += size;
+ } else {
+ System.out.println("Out of malloc memory");
+ break;
+ }
+ }
+
+ pb.command(new String[] { JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "summary" });
+ output = new OutputAnalyzer(pb.start());
+ output.shouldContain("Test (reserved=4KB, committed=4KB)");
+
+ // Free
+ for (MallocMemory mem : mallocd_memory) {
+ wb.NMTFree(mem.addr());
+ }
+
+ // Run 'jcmd <pid> VM.native_memory summary', check for expected output
+ pb.command(new String[] { JDKToolFinder.getJDKTool("jcmd"), pid,
+ "VM.native_memory", "summary" });
+ output = new OutputAnalyzer(pb.start());
+ output.shouldNotContain("Test (reserved=");
+ }
+
+ static class MallocMemory {
+ private long addr;
+ private int size;
+
+ MallocMemory(long addr, int size) {
+ this.addr = addr;
+ this.size = size;
+ }
+
+ long addr() {
+ return this.addr;
+ }
+
+ int size() {
+ return this.size;
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/NMT/UnsafeMallocLimit.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8055289
+ * @library /testlibrary
+ * @build UnsafeMallocLimit
+ * @run main/othervm -Xmx32m -XX:NativeMemoryTracking=summary UnsafeMallocLimit
+ */
+
+import com.oracle.java.testlibrary.*;
+import sun.misc.Unsafe;
+
+public class UnsafeMallocLimit {
+
+ public static void main(String args[]) throws Exception {
+ if (Platform.is32bit()) {
+ Unsafe unsafe = Utils.getUnsafe();
+ try {
+ unsafe.allocateMemory(1 << 30);
+ throw new RuntimeException("Did not get expected OOME");
+ } catch (OutOfMemoryError e) {
+ // Expected exception
+ }
+ } else {
+ System.out.println("Test only valid on 32-bit platforms");
+ }
+ }
+}
--- a/hotspot/test/runtime/RedefineFinalizer/RedefineFinalizer.java Wed Sep 10 11:52:16 2014 -0600
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,64 +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.
- */
-
-/*
- * @test
- * @bug 6904403
- * @summary Don't assert if we redefine finalize method
- * @library /testlibrary
- * @build RedefineClassHelper
- * @run main RedefineClassHelper
- * @run main/othervm -javaagent:redefineagent.jar RedefineFinalizer
- */
-
-/*
- * Regression test for hitting:
- *
- * assert(f == k->has_finalizer()) failed: inconsistent has_finalizer
- *
- * when redefining finalizer method
- */
-public class RedefineFinalizer {
-
- public static String newB =
- "class RedefineFinalizer$B {" +
- " protected void finalize() { " +
- " System.out.println(\"Finalizer called\");" +
- " }" +
- "}";
-
- public static void main(String[] args) throws Exception {
- RedefineClassHelper.redefineClass(B.class, newB);
-
- A a = new A();
- }
-
- static class A extends B {
- }
-
- static class B {
- protected void finalize() {
- // should be empty
- }
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/RedefineTests/RedefineFinalizer.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,64 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 6904403
+ * @summary Don't assert if we redefine finalize method
+ * @library /testlibrary
+ * @build RedefineClassHelper
+ * @run main RedefineClassHelper
+ * @run main/othervm -javaagent:redefineagent.jar RedefineFinalizer
+ */
+
+/*
+ * Regression test for hitting:
+ *
+ * assert(f == k->has_finalizer()) failed: inconsistent has_finalizer
+ *
+ * when redefining finalizer method
+ */
+public class RedefineFinalizer {
+
+ public static String newB =
+ "class RedefineFinalizer$B {" +
+ " protected void finalize() { " +
+ " System.out.println(\"Finalizer called\");" +
+ " }" +
+ "}";
+
+ public static void main(String[] args) throws Exception {
+ RedefineClassHelper.redefineClass(B.class, newB);
+
+ A a = new A();
+ }
+
+ static class A extends B {
+ }
+
+ static class B {
+ protected void finalize() {
+ // should be empty
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/RedefineTests/RedefineRunningMethods.java Wed Sep 10 17:06:36 2014 -0700
@@ -0,0 +1,143 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8055008
+ * @summary Redefine EMCP and non-EMCP methods that are running in an infinite loop
+ * @library /testlibrary
+ * @build RedefineClassHelper
+ * @run main RedefineClassHelper
+ * @run main/othervm -javaagent:redefineagent.jar -XX:TraceRedefineClasses=0x600 RedefineRunningMethods
+ */
+public class RedefineRunningMethods {
+
+ public static String newB =
+ "class RedefineRunningMethods$B {" +
+ " static int count1 = 0;" +
+ " static int count2 = 0;" +
+ " public static volatile boolean stop = false;" +
+ " static void localSleep() { " +
+ " try{ " +
+ " Thread.currentThread().sleep(10);" +
+ " } catch(InterruptedException ie) { " +
+ " } " +
+ " } " +
+ " public static void infinite() { " +
+ " System.out.println(\"infinite called\");" +
+ " }" +
+ " public static void infinite_emcp() { " +
+ " while (!stop) { count2++; localSleep(); }" +
+ " }" +
+ "}";
+
+ public static String evenNewerB =
+ "class RedefineRunningMethods$B {" +
+ " static int count1 = 0;" +
+ " static int count2 = 0;" +
+ " public static volatile boolean stop = false;" +
+ " static void localSleep() { " +
+ " try{ " +
+ " Thread.currentThread().sleep(1);" +
+ " } catch(InterruptedException ie) { " +
+ " } " +
+ " } " +
+ " public static void infinite() { }" +
+ " public static void infinite_emcp() { " +
+ " System.out.println(\"infinite_emcp now obsolete called\");" +
+ " }" +
+ "}";
+
+ static class B {
+ static int count1 = 0;
+ static int count2 = 0;
+ public static volatile boolean stop = false;
+ static void localSleep() {
+ try{
+ Thread.currentThread().sleep(10);//sleep for 10 ms
+ } catch(InterruptedException ie) {
+ }
+ }
+
+ public static void infinite() {
+ while (!stop) { count1++; localSleep(); }
+ }
+ public static void infinite_emcp() {
+ while (!stop) { count2++; localSleep(); }
+ }
+ }
+
+
+ public static void main(String[] args) throws Exception {
+
+ new Thread() {
+ public void run() {
+ B.infinite();
+ }
+ }.start();
+
+ new Thread() {
+ public void run() {
+ B.infinite_emcp();
+ }
+ }.start();
+
+ RedefineClassHelper.redefineClass(B.class, newB);
+
+ System.gc();
+
+ B.infinite();
+
+ // Start a thread with the second version of infinite_emcp running
+ new Thread() {
+ public void run() {
+ B.infinite_emcp();
+ }
+ }.start();
+
+ for (int i = 0; i < 20 ; i++) {
+ String s = new String("some garbage");
+ System.gc();
+ }
+
+ RedefineClassHelper.redefineClass(B.class, evenNewerB);
+ System.gc();
+
+ for (int i = 0; i < 20 ; i++) {
+ B.infinite();
+ String s = new String("some garbage");
+ System.gc();
+ }
+
+ B.infinite_emcp();
+
+ // purge should clean everything up.
+ B.stop = true;
+
+ for (int i = 0; i < 20 ; i++) {
+ B.infinite();
+ String s = new String("some garbage");
+ System.gc();
+ }
+ }
+}
--- a/hotspot/test/runtime/SharedArchiveFile/ArchiveDoesNotExist.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/runtime/SharedArchiveFile/ArchiveDoesNotExist.java Wed Sep 10 17:06:36 2014 -0700
@@ -61,7 +61,7 @@
"-version");
output = new OutputAnalyzer(pb.start());
- output.shouldContain("java version");
+ output.shouldMatch("(java|openjdk) version");
output.shouldNotContain("sharing");
output.shouldHaveExitValue(0);
}
--- a/hotspot/test/testlibrary/com/oracle/java/testlibrary/Platform.java Wed Sep 10 11:52:16 2014 -0600
+++ b/hotspot/test/testlibrary/com/oracle/java/testlibrary/Platform.java Wed Sep 10 17:06:36 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 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
@@ -27,6 +27,7 @@
private static final String osName = System.getProperty("os.name");
private static final String dataModel = System.getProperty("sun.arch.data.model");
private static final String vmVersion = System.getProperty("java.vm.version");
+ private static final String javaVersion = System.getProperty("java.version");
private static final String osArch = System.getProperty("os.arch");
private static final String vmName = System.getProperty("java.vm.name");
@@ -83,7 +84,8 @@
}
public static boolean isDebugBuild() {
- return vmVersion.toLowerCase().contains("debug");
+ return (vmVersion.toLowerCase().contains("debug") ||
+ javaVersion.toLowerCase().contains("debug"));
}
public static String getVMVersion() {