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

Merge

Browse Source
This commit is contained in:
Coleen Phillimore 2015-10-23 23:06:53 +02:00
commit ed82cd0ee8
71 changed files with 573 additions and 561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hotspot/agent/src/os/linux/symtab.c
View File

@ -545,6 +545,7 @@ uintptr_t search_symbol(struct symtab* symtab, uintptr_t base,
return (uintptr_t)NULL;
item.key = (char*) strdup(sym_name);
item.data = NULL;
hsearch_r(item, FIND, &ret, symtab->hash_table);
if (ret) {
struct elf_symbol * sym = (struct elf_symbol *)(ret->data);

4
hotspot/make/Makefile
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -403,6 +403,8 @@ $(EXPORT_LIB_ARCH_DIR)/%.dSYM: $(C2_BUILD_DIR)/%.dSYM
$(install-dir)
$(EXPORT_SERVER_DIR)/%.dSYM: $(C2_BUILD_DIR)/%.dSYM
$(install-dir)
$(EXPORT_SERVER_DIR)/%.symbols: $(C2_BUILD_DIR)/%.symbols
$(install-file)
endif
# Client (C1)

7
hotspot/make/bsd/makefiles/buildtree.make
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -224,6 +224,11 @@ flags.make: $(BUILDTREE_MAKE) ../shared_dirs.lst
echo "OPENJDK = $(OPENJDK)"; \
echo "$(LP64_SETTING/$(DATA_MODE))"; \
echo; \
echo "STATIC_BUILD = $(STATIC_BUILD)"; \
echo "COMPILER_WARNINGS_FATAL = $(COMPILER_WARNINGS_FATAL)"; \
echo "EXTRA_LDFLAGS = $(EXTRA_LDFLAGS)"; \
echo "LIBRARY_SUFFIX = $(LIBRARY_SUFFIX)"; \
echo; \
echo "# Used for platform dispatching"; \
echo "TARGET_DEFINES = -DTARGET_OS_FAMILY_\$$(Platform_os_family)"; \
echo "TARGET_DEFINES += -DTARGET_ARCH_\$$(Platform_arch)"; \

55
hotspot/make/bsd/makefiles/defs.make
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2006, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -186,13 +186,16 @@ ifeq ($(JDK6_OR_EARLIER),0)
# executed multiple times. We reduce the noise by at least checking that
# BUILD_FLAVOR has been set.
ifneq ($(BUILD_FLAVOR),)
ifeq ($(BUILD_FLAVOR), product)
FULL_DEBUG_SYMBOLS ?= 1
ENABLE_FULL_DEBUG_SYMBOLS = $(FULL_DEBUG_SYMBOLS)
else
# debug variants always get Full Debug Symbols (if available)
ENABLE_FULL_DEBUG_SYMBOLS = 1
endif
# FULL_DEBUG_SYMBOLS not created for individual static libraries
ifeq ($(STATIC_BUILD),false)
ifeq ($(BUILD_FLAVOR), product)
FULL_DEBUG_SYMBOLS ?= 1
ENABLE_FULL_DEBUG_SYMBOLS = $(FULL_DEBUG_SYMBOLS)
else
# debug variants always get Full Debug Symbols (if available)
ENABLE_FULL_DEBUG_SYMBOLS = 1
endif
endif
$(eval $(call print_info, "ENABLE_FULL_DEBUG_SYMBOLS=$(ENABLE_FULL_DEBUG_SYMBOLS)"))
# since objcopy is optional, we set ZIP_DEBUGINFO_FILES later
@ -256,16 +259,24 @@ endif # JDK_6_OR_EARLIER
JDK_INCLUDE_SUBDIR=bsd
# Library suffix
ifeq ($(OS_VENDOR),Darwin)
LIBRARY_SUFFIX=dylib
ifneq ($(STATIC_BUILD),true)
ifeq ($(OS_VENDOR),Darwin)
LIBRARY_SUFFIX=dylib
else
LIBRARY_SUFFIX=so
endif
else
LIBRARY_SUFFIX=so
LIBRARY_SUFFIX=a
endif
EXPORT_LIST += $(EXPORT_DOCS_DIR)/platform/jvmti/jvmti.html
# jsig library not needed for static builds
ifneq ($(STATIC_BUILD),true)
# client and server subdirectories have symbolic links to ../libjsig.so
EXPORT_LIST += $(EXPORT_LIB_ARCH_DIR)/libjsig.$(LIBRARY_SUFFIX)
EXPORT_LIST += $(EXPORT_LIB_ARCH_DIR)/libjsig.$(LIBRARY_SUFFIX)
endif
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
ifeq ($(ZIP_DEBUGINFO_FILES),1)
@ -286,6 +297,9 @@ EXPORT_MINIMAL_DIR = $(EXPORT_LIB_ARCH_DIR)/minimal
ifeq ($(findstring true, $(JVM_VARIANT_SERVER) $(JVM_VARIANT_ZERO) $(JVM_VARIANT_ZEROSHARK)), true)
EXPORT_LIST += $(EXPORT_SERVER_DIR)/Xusage.txt
EXPORT_LIST += $(EXPORT_SERVER_DIR)/libjvm.$(LIBRARY_SUFFIX)
ifeq ($(STATIC_BUILD),true)
EXPORT_LIST += $(EXPORT_SERVER_DIR)/libjvm.symbols
endif
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
ifeq ($(ZIP_DEBUGINFO_FILES),1)
@ -303,6 +317,9 @@ endif
ifeq ($(JVM_VARIANT_CLIENT),true)
EXPORT_LIST += $(EXPORT_CLIENT_DIR)/Xusage.txt
EXPORT_LIST += $(EXPORT_CLIENT_DIR)/libjvm.$(LIBRARY_SUFFIX)
ifeq ($(STATIC_BUILD),true)
EXPORT_LIST += $(EXPORT_CLIENT_DIR)/libjvm.symbols
endif
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
ifeq ($(ZIP_DEBUGINFO_FILES),1)
@ -320,6 +337,9 @@ endif
ifeq ($(JVM_VARIANT_MINIMAL1),true)
EXPORT_LIST += $(EXPORT_MINIMAL_DIR)/Xusage.txt
EXPORT_LIST += $(EXPORT_MINIMAL_DIR)/libjvm.$(LIBRARY_SUFFIX)
ifeq ($(STATIC_BUILD),true)
EXPORT_LIST += $(EXPORT_MINIMAL_DIR)/libjvm.symbols
endif
endif
# Serviceability Binaries
@ -388,7 +408,9 @@ ifeq ($(OS_VENDOR), Darwin)
endif
# Binaries to 'universalize' if built
UNIVERSAL_LIPO_LIST += $(EXPORT_LIB_DIR)/libjsig.$(LIBRARY_SUFFIX)
ifneq ($(STATIC_BUILD),true)
UNIVERSAL_LIPO_LIST += $(EXPORT_LIB_DIR)/libjsig.$(LIBRARY_SUFFIX)
endif
UNIVERSAL_LIPO_LIST += $(EXPORT_LIB_DIR)/libsaproc.$(LIBRARY_SUFFIX)
UNIVERSAL_LIPO_LIST += $(EXPORT_LIB_DIR)/server/libjvm.$(LIBRARY_SUFFIX)
UNIVERSAL_LIPO_LIST += $(EXPORT_LIB_DIR)/client/libjvm.$(LIBRARY_SUFFIX)
@ -396,6 +418,13 @@ ifeq ($(OS_VENDOR), Darwin)
# Files to simply copy in place
UNIVERSAL_COPY_LIST += $(EXPORT_LIB_DIR)/server/Xusage.txt
UNIVERSAL_COPY_LIST += $(EXPORT_LIB_DIR)/client/Xusage.txt
ifeq ($(STATIC_BUILD),true)
UNIVERSAL_COPY_LIST += $(EXPORT_LIB_DIR)/server/libjvm.symbols
UNIVERSAL_COPY_LIST += $(EXPORT_LIB_DIR)/client/libjvm.symbols
UNIVERSAL_COPY_LIST += $(EXPORT_LIB_DIR)/minimal/libjvm.symbols
endif
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
ifeq ($(ZIP_DEBUGINFO_FILES),1)
UNIVERSAL_COPY_LIST += $(EXPORT_LIB_DIR)/server/libjvm.diz

16
hotspot/make/bsd/makefiles/dtrace.make
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -37,15 +37,15 @@ DtraceOutDir = $(GENERATED)/dtracefiles
# Bsd does not build libjvm_db, does not compile on macosx
# disabled in build: rule in vm.make
JVM_DB = libjvm_db
LIBJVM_DB = libjvm_db.dylib
LIBJVM_DB = libjvm_db.$(LIBRARY_SUFFIX)
LIBJVM_DB_DEBUGINFO = libjvm_db.dylib.dSYM
LIBJVM_DB_DEBUGINFO = libjvm_db.$(LIBRARY_SUFFIX).dSYM
LIBJVM_DB_DIZ = libjvm_db.diz
JVM_DTRACE = jvm_dtrace
LIBJVM_DTRACE = libjvm_dtrace.dylib
LIBJVM_DTRACE = libjvm_dtrace.$(LIBRARY_SUFFIX)
LIBJVM_DTRACE_DEBUGINFO = libjvm_dtrace.dylib.dSYM
LIBJVM_DTRACE_DEBUGINFO = libjvm_dtrace.$(LIBRARY_SUFFIX).dSYM
LIBJVM_DTRACE_DIZ = libjvm_dtrace.diz
JVMOFFS = JvmOffsets
@ -167,14 +167,14 @@ endif # ifneq ("${ISA}","${BUILDARCH}")
LFLAGS_GENOFFS += -L.
lib$(GENOFFS).dylib: $(DTRACE_SRCDIR)/$(GENOFFS).cpp $(DTRACE_SRCDIR)/$(GENOFFS).h \
lib$(GENOFFS).$(LIBRARY_SUFFIX): $(DTRACE_SRCDIR)/$(GENOFFS).cpp $(DTRACE_SRCDIR)/$(GENOFFS).h \
$(LIBJVM.o)
$(QUIETLY) $(CXX) $(CXXFLAGS) $(GENOFFS_CFLAGS) $(SHARED_FLAG) $(PICFLAG) \
$(LFLAGS_GENOFFS) -o $@ $(DTRACE_SRCDIR)/$(GENOFFS).cpp -ljvm
$(GENOFFS): $(DTRACE_SRCDIR)/$(GENOFFS)Main.c lib$(GENOFFS).dylib
$(GENOFFS): $(DTRACE_SRCDIR)/$(GENOFFS)Main.c lib$(GENOFFS).$(LIBRARY_SUFFIX)
$(QUIETLY) $(LINK.CXX) -o $@ $(DTRACE_SRCDIR)/$(GENOFFS)Main.c \
./lib$(GENOFFS).dylib
./lib$(GENOFFS).$(LIBRARY_SUFFIX)
# $@.tmp is created first to avoid an empty $(JVMOFFS).h if an error occurs.
$(JVMOFFS).h: $(GENOFFS)

9
hotspot/make/bsd/makefiles/gcc.make
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -186,7 +186,14 @@ ifeq ($(JVM_VARIANT_ZEROSHARK), true)
CFLAGS += $(LIBFFI_CFLAGS)
CFLAGS += $(LLVM_CFLAGS)
endif
ifeq ($(STATIC_BUILD),true)
CXXFLAGS += -DSTATIC_BUILD
CFLAGS += -DSTATIC_BUILD
else
CFLAGS += $(VM_PICFLAG)
endif
CFLAGS += -fno-rtti
CFLAGS += -fno-exceptions
ifeq ($(USE_CLANG),)

14
hotspot/make/bsd/makefiles/jsig.make
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -28,9 +28,9 @@
JSIG = jsig
ifeq ($(OS_VENDOR), Darwin)
LIBJSIG = lib$(JSIG).dylib
LIBJSIG = lib$(JSIG).$(LIBRARY_SUFFIX)
LIBJSIG_DEBUGINFO = lib$(JSIG).dylib.dSYM
LIBJSIG_DEBUGINFO = lib$(JSIG).$(LIBRARY_SUFFIX).dSYM
LIBJSIG_DIZ = lib$(JSIG).diz
else
LIBJSIG = lib$(JSIG).so
@ -61,8 +61,14 @@ endif
$(LIBJSIG): $(JSIGSRCDIR)/jsig.c $(LIBJSIG_MAPFILE)
@echo $(LOG_INFO) Making signal interposition lib...
ifeq ($(STATIC_BUILD),true)
$(QUIETLY) $(CC) -c $(SYMFLAG) $(EXTRA_CFLAGS) $(ARCHFLAG) $(PICFLAG) \
$(LFLAGS_JSIG) $(JSIG_DEBUG_CFLAGS) -o $(JSIG).o $<
$(QUIETLY) $(AR) $(ARFLAGS) $@ $(JSIG).o
else
$(QUIETLY) $(CC) $(SYMFLAG) $(ARCHFLAG) $(SHARED_FLAG) $(PICFLAG) \
$(LFLAGS_JSIG) $(JSIG_DEBUG_CFLAGS) $(EXTRA_CFLAGS) -o $@ $<
$(LFLAGS_JSIG) $(JSIG_DEBUG_CFLAGS) $(EXTRA_CFLAGS) -o $@ $<
endif
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
ifeq ($(OS_VENDOR), Darwin)
$(DSYMUTIL) $@

6
hotspot/make/bsd/makefiles/rules.make
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -39,7 +39,11 @@ AS.S = $(AS) $(ASFLAGS)
COMPILE.CC = $(CC_COMPILE) -c
GENASM.CC = $(CC_COMPILE) -S
LINK.CC = $(CC) $(LFLAGS) $(AOUT_FLAGS) $(PROF_AOUT_FLAGS)
ifeq ($(STATIC_BUILD),true)
LINK_LIB.CC = $(AR) $(ARFLAGS)
else
LINK_LIB.CC = $(CC) $(LFLAGS) $(SHARED_FLAG)
endif
PREPROCESS.CC = $(CC_COMPILE) -E
COMPILE.CXX = $(CXX_COMPILE) -c

6
hotspot/make/bsd/makefiles/saproc.make
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -28,9 +28,9 @@
SAPROC = saproc
ifeq ($(OS_VENDOR), Darwin)
LIBSAPROC = lib$(SAPROC).dylib
LIBSAPROC = lib$(SAPROC).$(LIBRARY_SUFFIX)
LIBSAPROC_DEBUGINFO = lib$(SAPROC).dylib.dSYM
LIBSAPROC_DEBUGINFO = lib$(SAPROC).$(LIBRARY_SUFFIX).dSYM
LIBSAPROC_DIZ = lib$(SAPROC).diz
else
LIBSAPROC = lib$(SAPROC).so

32
hotspot/make/bsd/makefiles/vm.make
View File

@ -142,10 +142,10 @@ include $(MAKEFILES_DIR)/dtrace.make
JVM = jvm
ifeq ($(OS_VENDOR), Darwin)
LIBJVM = lib$(JVM).dylib
LIBJVM = lib$(JVM).$(LIBRARY_SUFFIX)
CFLAGS += -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE
LIBJVM_DEBUGINFO = lib$(JVM).dylib.dSYM
LIBJVM_DEBUGINFO = lib$(JVM).$(LIBRARY_SUFFIX).dSYM
LIBJVM_DIZ = lib$(JVM).diz
else
LIBJVM = lib$(JVM).so
@ -261,6 +261,16 @@ mapfile : $(MAPFILE) mapfile_extra vm.def
{ print $$0 } \
}' > $@ < $(MAPFILE)
ifeq ($(STATIC_BUILD),true)
EXPORTED_SYMBOLS = libjvm.symbols
libjvm.symbols : mapfile
$(CP) mapfile libjvm.symbols
else
EXPORTED_SYMBOLS =
endif
mapfile_reorder : mapfile $(REORDERFILE)
rm -f $@
cat $^ > $@
@ -288,9 +298,11 @@ else
LFLAGS_VM += $(SONAMEFLAG:SONAME=$(LIBJVM))
ifeq ($(OS_VENDOR), Darwin)
LFLAGS_VM += -Xlinker -rpath -Xlinker @loader_path/.
LFLAGS_VM += -Xlinker -rpath -Xlinker @loader_path/..
LFLAGS_VM += -Xlinker -install_name -Xlinker @rpath/$(@F)
ifneq ($(STATIC_BUILD),true)
LFLAGS_VM += -Xlinker -rpath -Xlinker @loader_path/.
LFLAGS_VM += -Xlinker -rpath -Xlinker @loader_path/..
LFLAGS_VM += -Xlinker -install_name -Xlinker @rpath/$(@F)
endif
else
LFLAGS_VM += -Wl,-z,defs
endif
@ -345,6 +357,10 @@ LD_SCRIPT_FLAG = -Wl,-T,$(LD_SCRIPT)
endif
$(LIBJVM): $(LIBJVM.o) $(LIBJVM_MAPFILE) $(LD_SCRIPT)
ifeq ($(STATIC_BUILD),true)
echo Linking static vm...;
$(LINK_LIB.CC) $@ $(LIBJVM.o)
else
$(QUIETLY) { \
echo $(LOG_INFO) Linking vm...; \
$(LINK_LIB.CXX/PRE_HOOK) \
@ -354,6 +370,8 @@ $(LIBJVM): $(LIBJVM.o) $(LIBJVM_MAPFILE) $(LD_SCRIPT)
rm -f $@.1; ln -s $@ $@.1; \
}
endif
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
ifeq ($(OS_VENDOR), Darwin)
$(DSYMUTIL) $@
@ -410,10 +428,10 @@ include $(MAKEFILES_DIR)/saproc.make
ifeq ($(OS_VENDOR), Darwin)
# no libjvm_db for macosx
build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(BUILDLIBSAPROC) dtraceCheck
build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(BUILDLIBSAPROC) dtraceCheck $(EXPORTED_SYMBOLS)
echo "Doing vm.make build:"
else
build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(BUILDLIBSAPROC)
build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(BUILDLIBSAPROC) $(EXPORTED_SYMBOLS)
endif
install: install_jvm install_jsig install_saproc

2
hotspot/make/linux/makefiles/gcc.make
View File

@ -223,6 +223,8 @@ ifeq ($(USE_CLANG),)
WARNING_FLAGS += -Wtype-limits
# GCC < 4.8 don't accept this flag for C++.
WARNING_FLAGS += -Wno-format-zero-length
# GCC 4.8 reports less false positives than the older compilers.
WARNING_FLAGS += -Wuninitialized
endif
endif

17
hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp
View File

@ -1667,8 +1667,8 @@ void LIR_Assembler::emit_typecheck_helper(LIR_OpTypeCheck *op, Label* success, L
Register Rtmp1 = noreg;
// check if it needs to be profiled
ciMethodData* md;
ciProfileData* data;
ciMethodData* md = NULL;
ciProfileData* data = NULL;
if (op->should_profile()) {
ciMethod* method = op->profiled_method();
@ -1827,8 +1827,8 @@ void LIR_Assembler::emit_opTypeCheck(LIR_OpTypeCheck* op) {
CodeStub* stub = op->stub();
// check if it needs to be profiled
ciMethodData* md;
ciProfileData* data;
ciMethodData* md = NULL;
ciProfileData* data = NULL;
if (op->should_profile()) {
ciMethod* method = op->profiled_method();
@ -2005,7 +2005,8 @@ void LIR_Assembler::cmove(LIR_Condition condition, LIR_Opr opr1, LIR_Opr opr2, L
case lir_cond_greater: acond = Assembler::greater; ncond = Assembler::lessEqual; break;
case lir_cond_belowEqual: acond = Assembler::belowEqual; ncond = Assembler::above; break;
case lir_cond_aboveEqual: acond = Assembler::aboveEqual; ncond = Assembler::below; break;
default: ShouldNotReachHere();
default: acond = Assembler::equal; ncond = Assembler::notEqual;
ShouldNotReachHere();
}
if (opr1->is_cpu_register()) {
@ -3182,27 +3183,23 @@ void LIR_Assembler::emit_arraycopy(LIR_OpArrayCopy* op) {
assert(default_type != NULL && default_type->is_array_klass() && default_type->is_loaded(), "must be true at this point");
int elem_size = type2aelembytes(basic_type);
int shift_amount;
Address::ScaleFactor scale;
switch (elem_size) {
case 1 :
shift_amount = 0;
scale = Address::times_1;
break;
case 2 :
shift_amount = 1;
scale = Address::times_2;
break;
case 4 :
shift_amount = 2;
scale = Address::times_4;
break;
case 8 :
shift_amount = 3;
scale = Address::times_8;
break;
default:
scale = Address::no_scale;
ShouldNotReachHere();
}

6
hotspot/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp
View File

@ -195,7 +195,7 @@ LIR_Address* LIRGenerator::emit_array_address(LIR_Opr array_opr, LIR_Opr index_o
LIR_Opr LIRGenerator::load_immediate(int x, BasicType type) {
LIR_Opr r;
LIR_Opr r = NULL;
if (type == T_LONG) {
r = LIR_OprFact::longConst(x);
} else if (type == T_INT) {
@ -484,7 +484,7 @@ void LIRGenerator::do_ArithmeticOp_Long(ArithmeticOp* x) {
__ cmp(lir_cond_equal, right.result(), LIR_OprFact::longConst(0));
__ branch(lir_cond_equal, T_LONG, new DivByZeroStub(info));
address entry;
address entry = NULL;
switch (x->op()) {
case Bytecodes::_lrem:
entry = CAST_FROM_FN_PTR(address, SharedRuntime::lrem);
@ -1054,7 +1054,7 @@ LIR_Opr fixed_register_for(BasicType type) {
void LIRGenerator::do_Convert(Convert* x) {
// flags that vary for the different operations and different SSE-settings
bool fixed_input, fixed_result, round_result, needs_stub;
bool fixed_input = false, fixed_result = false, round_result = false, needs_stub = false;
switch (x->op()) {
case Bytecodes::_i2l: // fall through

8
hotspot/src/cpu/x86/vm/jniFastGetField_x86_32.cpp
View File

@ -48,7 +48,7 @@ GetDoubleField_t JNI_FastGetField::jni_fast_GetDoubleField_fp;
// between loads, which is much more efficient than lfence.
address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {
const char *name;
const char *name = NULL;
switch (type) {
case T_BOOLEAN: name = "jni_fast_GetBooleanField"; break;
case T_BYTE: name = "jni_fast_GetByteField"; break;
@ -122,7 +122,7 @@ address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {
slowcase_entry_pclist[count++] = __ pc();
__ bind (slow);
address slow_case_addr;
address slow_case_addr = NULL;
switch (type) {
case T_BOOLEAN: slow_case_addr = jni_GetBooleanField_addr(); break;
case T_BYTE: slow_case_addr = jni_GetByteField_addr(); break;
@ -256,7 +256,7 @@ address JNI_FastGetField::generate_fast_get_long_field() {
}
address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) {
const char *name;
const char *name = NULL;
switch (type) {
case T_FLOAT: name = "jni_fast_GetFloatField"; break;
case T_DOUBLE: name = "jni_fast_GetDoubleField"; break;
@ -337,7 +337,7 @@ address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) {
slowcase_entry_pclist[count++] = __ pc();
__ bind (slow);
address slow_case_addr;
address slow_case_addr = NULL;
switch (type) {
case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break;
case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr(); break;

8
hotspot/src/cpu/x86/vm/jniFastGetField_x86_64.cpp
View File

@ -51,7 +51,7 @@ static const Register rcounter_addr = r11;
// since that may scratch r10!
address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {
const char *name;
const char *name = NULL;
switch (type) {
case T_BOOLEAN: name = "jni_fast_GetBooleanField"; break;
case T_BYTE: name = "jni_fast_GetByteField"; break;
@ -111,7 +111,7 @@ address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {
slowcase_entry_pclist[count++] = __ pc();
__ bind (slow);
address slow_case_addr;
address slow_case_addr = NULL;
switch (type) {
case T_BOOLEAN: slow_case_addr = jni_GetBooleanField_addr(); break;
case T_BYTE: slow_case_addr = jni_GetByteField_addr(); break;
@ -153,7 +153,7 @@ address JNI_FastGetField::generate_fast_get_long_field() {
}
address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) {
const char *name;
const char *name = NULL;
switch (type) {
case T_FLOAT: name = "jni_fast_GetFloatField"; break;
case T_DOUBLE: name = "jni_fast_GetDoubleField"; break;
@ -206,7 +206,7 @@ address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) {
slowcase_entry_pclist[count++] = __ pc();
__ bind (slow);
address slow_case_addr;
address slow_case_addr = NULL;
switch (type) {
case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break;
case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr();

12
hotspot/src/os/bsd/vm/os_bsd.cpp
View File

@ -440,6 +440,10 @@ void os::init_system_properties_values() {
if (pslash != NULL) {
*pslash = '\0'; // Get rid of /{client|server|hotspot}.
}
#ifdef STATIC_BUILD
strcat(buf, "/lib");
#endif
Arguments::set_dll_dir(buf);
if (pslash != NULL) {
@ -1388,6 +1392,9 @@ bool os::dll_address_to_library_name(address addr, char* buf,
#ifdef __APPLE__
void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
#ifdef STATIC_BUILD
return os::get_default_process_handle();
#else
void * result= ::dlopen(filename, RTLD_LAZY);
if (result != NULL) {
// Successful loading
@ -1399,9 +1406,13 @@ void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
ebuf[ebuflen-1]='\0';
return NULL;
#endif // STATIC_BUILD
}
#else
void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
#ifdef STATIC_BUILD
return os::get_default_process_handle();
#else
void * result= ::dlopen(filename, RTLD_LAZY);
if (result != NULL) {
// Successful loading
@ -1574,6 +1585,7 @@ void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
}
return NULL;
#endif // STATIC_BUILD
}
#endif // !__APPLE__

8
hotspot/src/os/linux/vm/os_linux.cpp
View File

@ -2794,7 +2794,7 @@ char *os::scan_pages(char *start, char* end, page_info* page_expected,
int os::Linux::sched_getcpu_syscall(void) {
unsigned int cpu;
unsigned int cpu = 0;
int retval = -1;
#if defined(IA32)
@ -4187,8 +4187,8 @@ static bool call_chained_handler(struct sigaction *actp, int sig,
sigaddset(&(actp->sa_mask), sig);
}
sa_handler_t hand;
sa_sigaction_t sa;
sa_handler_t hand = NULL;
sa_sigaction_t sa = NULL;
bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
// retrieve the chained handler
if (siginfo_flag_set) {
@ -4393,7 +4393,7 @@ jlong os::Linux::fast_thread_cpu_time(clockid_t clockid) {
static const char* get_signal_handler_name(address handler,
char* buf, int buflen) {
int offset;
int offset = 0;
bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
if (found) {
// skip directory names

6
hotspot/src/os_cpu/linux_x86/vm/copy_linux_x86.inline.hpp
View File

@ -30,7 +30,7 @@ static void pd_conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
(void)memmove(to, from, count * HeapWordSize);
#else
// Includes a zero-count check.
intx temp;
intx temp = 0;
__asm__ volatile(" testl %6,%6 ;"
" jz 7f ;"
" cmpl %4,%5 ;"
@ -88,7 +88,7 @@ static void pd_disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
}
#else
// Includes a zero-count check.
intx temp;
intx temp = 0;
__asm__ volatile(" testl %6,%6 ;"
" jz 3f ;"
" cmpl $32,%6 ;"
@ -145,7 +145,7 @@ static void pd_conjoint_bytes(void* from, void* to, size_t count) {
(void)memmove(to, from, count);
#else
// Includes a zero-count check.
intx temp;
intx temp = 0;
__asm__ volatile(" testl %6,%6 ;"
" jz 13f ;"
" cmpl %4,%5 ;"

5
hotspot/src/share/vm/c1/c1_Canonicalizer.cpp
View File

@ -639,7 +639,7 @@ void Canonicalizer::do_If(If* x) {
if (l == r && !lt->is_float_kind()) {
// pattern: If (a cond a) => simplify to Goto
BlockBegin* sux;
BlockBegin* sux = NULL;
switch (x->cond()) {
case If::eql: sux = x->sux_for(true); break;
case If::neq: sux = x->sux_for(false); break;
@ -647,6 +647,7 @@ void Canonicalizer::do_If(If* x) {
case If::leq: sux = x->sux_for(true); break;
case If::gtr: sux = x->sux_for(false); break;
case If::geq: sux = x->sux_for(true); break;
default: ShouldNotReachHere();
}
// If is a safepoint then the debug information should come from the state_before of the If.
set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
@ -684,7 +685,7 @@ void Canonicalizer::do_If(If* x) {
} else {
// two successors differ and two successors are the same => simplify to: If (x cmp y)
// determine new condition & successors
If::Condition cond;
If::Condition cond = If::eql;
BlockBegin* tsux = NULL;
BlockBegin* fsux = NULL;
if (lss_sux == eql_sux) { cond = If::leq; tsux = lss_sux; fsux = gtr_sux; }

4
hotspot/src/share/vm/c1/c1_GraphBuilder.cpp
View File

@ -3823,8 +3823,8 @@ bool GraphBuilder::try_inline_full(ciMethod* callee, bool holder_known, Bytecode
caller_state->truncate_stack(args_base);
assert(callee_state->stack_size() == 0, "callee stack must be empty");
Value lock;
BlockBegin* sync_handler;
Value lock = NULL;
BlockBegin* sync_handler = NULL;
// Inline the locking of the receiver if the callee is synchronized
if (callee->is_synchronized()) {

4
hotspot/src/share/vm/c1/c1_LIRGenerator.cpp
View File

@ -3348,7 +3348,7 @@ void LIRGenerator::do_ProfileInvoke(ProfileInvoke* x) {
}
void LIRGenerator::increment_event_counter(CodeEmitInfo* info, int bci, bool backedge) {
int freq_log;
int freq_log = 0;
int level = compilation()->env()->comp_level();
if (level == CompLevel_limited_profile) {
freq_log = (backedge ? Tier2BackedgeNotifyFreqLog : Tier2InvokeNotifyFreqLog);
@ -3394,7 +3394,7 @@ void LIRGenerator::increment_event_counter_impl(CodeEmitInfo* info,
assert(level > CompLevel_simple, "Shouldn't be here");
int offset = -1;
LIR_Opr counter_holder;
LIR_Opr counter_holder = NULL;
if (level == CompLevel_limited_profile) {
MethodCounters* counters_adr = method->ensure_method_counters();
if (counters_adr == NULL) {

3
hotspot/src/share/vm/c1/c1_LIRGenerator.hpp
View File

@ -409,7 +409,7 @@ class LIRGenerator: public InstructionVisitor, public BlockClosure {
}
static LIR_Condition lir_cond(If::Condition cond) {
LIR_Condition l;
LIR_Condition l = lir_cond_unknown;
switch (cond) {
case If::eql: l = lir_cond_equal; break;
case If::neq: l = lir_cond_notEqual; break;
@ -419,6 +419,7 @@ class LIRGenerator: public InstructionVisitor, public BlockClosure {
case If::gtr: l = lir_cond_greater; break;
case If::aeq: l = lir_cond_aboveEqual; break;
case If::beq: l = lir_cond_belowEqual; break;
default: fatal("You must pass valid If::Condition");
};
return l;
}

1
hotspot/src/share/vm/ci/ciObjectFactory.cpp
View File

@ -414,6 +414,7 @@ void ciObjectFactory::ensure_metadata_alive(ciMetadata* m) {
metadata_owner_klass = m->as_method()->get_Method()->constants()->pool_holder();
} else {
fatal("Not implemented for other types of metadata");
return;
}
oop metadata_holder = metadata_owner_klass->klass_holder();

46
hotspot/src/share/vm/classfile/classFileParser.cpp
View File

@ -3211,19 +3211,19 @@ void ClassFileParser::layout_fields(Handle class_loader,
// Field size and offset computation
int nonstatic_field_size = _super_klass() == NULL ? 0 : _super_klass()->nonstatic_field_size();
int next_static_oop_offset;
int next_static_double_offset;
int next_static_word_offset;
int next_static_short_offset;
int next_static_byte_offset;
int next_nonstatic_oop_offset;
int next_nonstatic_double_offset;
int next_nonstatic_word_offset;
int next_nonstatic_short_offset;
int next_nonstatic_byte_offset;
int first_nonstatic_oop_offset;
int next_nonstatic_field_offset;
int next_nonstatic_padded_offset;
int next_static_oop_offset = 0;
int next_static_double_offset = 0;
int next_static_word_offset = 0;
int next_static_short_offset = 0;
int next_static_byte_offset = 0;
int next_nonstatic_oop_offset = 0;
int next_nonstatic_double_offset = 0;
int next_nonstatic_word_offset = 0;
int next_nonstatic_short_offset = 0;
int next_nonstatic_byte_offset = 0;
int first_nonstatic_oop_offset = 0;
int next_nonstatic_field_offset = 0;
int next_nonstatic_padded_offset = 0;
// Count the contended fields by type.
//
@ -3376,14 +3376,14 @@ void ClassFileParser::layout_fields(Handle class_loader,
ShouldNotReachHere();
}
int nonstatic_oop_space_count = 0;
int nonstatic_word_space_count = 0;
int nonstatic_short_space_count = 0;
int nonstatic_byte_space_count = 0;
int nonstatic_oop_space_offset;
int nonstatic_word_space_offset;
int nonstatic_short_space_offset;
int nonstatic_byte_space_offset;
int nonstatic_oop_space_count = 0;
int nonstatic_word_space_count = 0;
int nonstatic_short_space_count = 0;
int nonstatic_byte_space_count = 0;
int nonstatic_oop_space_offset = 0;
int nonstatic_word_space_offset = 0;
int nonstatic_short_space_offset = 0;
int nonstatic_byte_space_offset = 0;
// Try to squeeze some of the fields into the gaps due to
// long/double alignment.
@ -3455,7 +3455,7 @@ void ClassFileParser::layout_fields(Handle class_loader,
// contended instance fields are handled below
if (fs.is_contended() && !fs.access_flags().is_static()) continue;
int real_offset;
int real_offset = 0;
FieldAllocationType atype = (FieldAllocationType) fs.allocation_type();
// pack the rest of the fields
@ -3589,7 +3589,7 @@ void ClassFileParser::layout_fields(Handle class_loader,
// handle statics below
if (fs.access_flags().is_static()) continue;
int real_offset;
int real_offset = 0;
FieldAllocationType atype = (FieldAllocationType) fs.allocation_type();
switch (atype) {

10
hotspot/src/share/vm/classfile/compactHashtable.cpp
View File

@ -422,7 +422,7 @@ int HashtableTextDump::scan_prefix(int* utf8_length) {
int HashtableTextDump::scan_string_prefix() {
// Expect /[0-9]+: /
int utf8_length;
int utf8_length = 0;
get_num(':', &utf8_length);
if (*_p != ' ') {
corrupted(_p, "Wrong prefix format for string");
@ -433,13 +433,13 @@ int HashtableTextDump::scan_string_prefix() {
int HashtableTextDump::scan_symbol_prefix() {
// Expect /[0-9]+ (-|)[0-9]+: /
int utf8_length;
int utf8_length = 0;
get_num(' ', &utf8_length);
if (*_p == '-') {
_p++;
if (*_p == '-') {
_p++;
}
int ref_num;
(void)get_num(':', &ref_num);
get_num(':', &ref_num);
if (*_p != ' ') {
corrupted(_p, "Wrong prefix format for symbol");
}

2
hotspot/src/share/vm/classfile/placeholders.hpp
View File

@ -220,7 +220,7 @@ class PlaceholderEntry : public HashtableEntry<Symbol*, mtClass> {
}
SeenThread* actionToQueue(PlaceholderTable::classloadAction action) {
SeenThread* queuehead;
SeenThread* queuehead = NULL;
switch (action) {
case PlaceholderTable::LOAD_INSTANCE:
queuehead = _loadInstanceThreadQ;

7
hotspot/src/share/vm/compiler/disassembler.cpp
View File

@ -86,6 +86,12 @@ bool Disassembler::load_library() {
os::jvm_path(buf, sizeof(buf));
int jvm_offset = -1;
int lib_offset = -1;
#ifdef STATIC_BUILD
char* p = strrchr(buf, '/');
*p = '\0';
strcat(p, "/lib/");
lib_offset = jvm_offset = strlen(buf);
#else
{
// Match "jvm[^/]*" in jvm_path.
const char* base = buf;
@ -94,6 +100,7 @@ bool Disassembler::load_library() {
p = strstr(p ? p : base, "jvm");
if (p != NULL) jvm_offset = p - base;
}
#endif
// Find the disassembler shared library.
// Search for several paths derived from libjvm, in this order:
// 1. <home>/jre/lib/<arch>/<vm>/libhsdis-<arch>.so (for compatibility)

6
hotspot/src/share/vm/compiler/oopMap.hpp
View File

@ -73,8 +73,8 @@ public:
// Constructors
OopMapValue () { set_value(0); set_content_reg(VMRegImpl::Bad()); }
OopMapValue (VMReg reg, oop_types t) { set_reg_type(reg,t); }
OopMapValue (VMReg reg, oop_types t, VMReg reg2) { set_reg_type(reg,t); set_content_reg(reg2); }
OopMapValue (VMReg reg, oop_types t) { set_reg_type(reg, t); set_content_reg(VMRegImpl::Bad()); }
OopMapValue (VMReg reg, oop_types t, VMReg reg2) { set_reg_type(reg, t); set_content_reg(reg2); }
OopMapValue (CompressedReadStream* stream) { read_from(stream); }
// Archiving
@ -87,7 +87,7 @@ public:
void read_from(CompressedReadStream* stream) {
set_value(stream->read_int());
if(is_callee_saved() || is_derived_oop()) {
if (is_callee_saved() || is_derived_oop()) {
set_content_reg(VMRegImpl::as_VMReg(stream->read_int(), true));
}
}

136
hotspot/src/share/vm/gc/cms/compactibleFreeListSpace.cpp
View File

@ -73,11 +73,7 @@ void CompactibleFreeListSpace::set_cms_values() {
}
// Constructor
CompactibleFreeListSpace::CompactibleFreeListSpace(BlockOffsetSharedArray* bs,
MemRegion mr, bool use_adaptive_freelists,
FreeBlockDictionary<FreeChunk>::DictionaryChoice dictionaryChoice) :
_dictionaryChoice(dictionaryChoice),
_adaptive_freelists(use_adaptive_freelists),
CompactibleFreeListSpace::CompactibleFreeListSpace(BlockOffsetSharedArray* bs, MemRegion mr) :
_bt(bs, mr),
// free list locks are in the range of values taken by _lockRank
// This range currently is [_leaf+2, _leaf+3]
@ -100,48 +96,17 @@ CompactibleFreeListSpace::CompactibleFreeListSpace(BlockOffsetSharedArray* bs,
"FreeChunk is larger than expected");
_bt.set_space(this);
initialize(mr, SpaceDecorator::Clear, SpaceDecorator::Mangle);
// We have all of "mr", all of which we place in the dictionary
// as one big chunk. We'll need to decide here which of several
// possible alternative dictionary implementations to use. For
// now the choice is easy, since we have only one working
// implementation, namely, the simple binary tree (splaying
// temporarily disabled).
switch (dictionaryChoice) {
case FreeBlockDictionary<FreeChunk>::dictionaryBinaryTree:
_dictionary = new AFLBinaryTreeDictionary(mr);
break;
case FreeBlockDictionary<FreeChunk>::dictionarySplayTree:
case FreeBlockDictionary<FreeChunk>::dictionarySkipList:
default:
warning("dictionaryChoice: selected option not understood; using"
" default BinaryTreeDictionary implementation instead.");
}
_dictionary = new AFLBinaryTreeDictionary(mr);
assert(_dictionary != NULL, "CMS dictionary initialization");
// The indexed free lists are initially all empty and are lazily
// filled in on demand. Initialize the array elements to NULL.
initializeIndexedFreeListArray();
// Not using adaptive free lists assumes that allocation is first
// from the linAB's. Also a cms perm gen which can be compacted
// has to have the klass's klassKlass allocated at a lower
// address in the heap than the klass so that the klassKlass is
// moved to its new location before the klass is moved.
// Set the _refillSize for the linear allocation blocks
if (!use_adaptive_freelists) {
FreeChunk* fc = _dictionary->get_chunk(mr.word_size(),
FreeBlockDictionary<FreeChunk>::atLeast);
// The small linAB initially has all the space and will allocate
// a chunk of any size.
HeapWord* addr = (HeapWord*) fc;
_smallLinearAllocBlock.set(addr, fc->size() ,
1024*SmallForLinearAlloc, fc->size());
// Note that _unallocated_block is not updated here.
// Allocations from the linear allocation block should
// update it.
} else {
_smallLinearAllocBlock.set(0, 0, 1024*SmallForLinearAlloc,
SmallForLinearAlloc);
}
_smallLinearAllocBlock.set(0, 0, 1024*SmallForLinearAlloc,
SmallForLinearAlloc);
// CMSIndexedFreeListReplenish should be at least 1
CMSIndexedFreeListReplenish = MAX2((uintx)1, CMSIndexedFreeListReplenish);
_promoInfo.setSpace(this);
@ -297,22 +262,7 @@ void CompactibleFreeListSpace::reset_after_compaction() {
MemRegion mr(compaction_top(), end());
reset(mr);
// Now refill the linear allocation block(s) if possible.
if (_adaptive_freelists) {
refillLinearAllocBlocksIfNeeded();
} else {
// Place as much of mr in the linAB as we can get,
// provided it was big enough to go into the dictionary.
FreeChunk* fc = dictionary()->find_largest_dict();
if (fc != NULL) {
assert(fc->size() == mr.word_size(),
"Why was the chunk broken up?");
removeChunkFromDictionary(fc);
HeapWord* addr = (HeapWord*) fc;
_smallLinearAllocBlock.set(addr, fc->size() ,
1024*SmallForLinearAlloc, fc->size());
// Note that _unallocated_block is not updated here.
}
}
refillLinearAllocBlocksIfNeeded();
}
// Walks the entire dictionary, returning a coterminal
@ -445,8 +395,7 @@ void CompactibleFreeListSpace::print_on(outputStream* st) const {
// dump_memory_block(_smallLinearAllocBlock->_ptr, 128);
st->print_cr(" _fitStrategy = %s, _adaptive_freelists = %s",
_fitStrategy?"true":"false", _adaptive_freelists?"true":"false");
st->print_cr(" _fitStrategy = %s", BOOL_TO_STR(_fitStrategy));
}
void CompactibleFreeListSpace::print_indexed_free_lists(outputStream* st)
@ -617,23 +566,9 @@ void CompactibleFreeListSpace::set_end(HeapWord* value) {
// Now, take this new chunk and add it to the free blocks.
// Note that the BOT has not yet been updated for this block.
size_t newFcSize = pointer_delta(value, prevEnd);
// XXX This is REALLY UGLY and should be fixed up. XXX
if (!_adaptive_freelists && _smallLinearAllocBlock._ptr == NULL) {
// Mark the boundary of the new block in BOT
_bt.mark_block(prevEnd, value);
// put it all in the linAB
MutexLockerEx x(parDictionaryAllocLock(),
Mutex::_no_safepoint_check_flag);
_smallLinearAllocBlock._ptr = prevEnd;
_smallLinearAllocBlock._word_size = newFcSize;
repairLinearAllocBlock(&_smallLinearAllocBlock);
// Births of chunks put into a LinAB are not recorded. Births
// of chunks as they are allocated out of a LinAB are.
} else {
// Add the block to the free lists, if possible coalescing it
// with the last free block, and update the BOT and census data.
addChunkToFreeListsAtEndRecordingStats(prevEnd, newFcSize);
}
// Add the block to the free lists, if possible coalescing it
// with the last free block, and update the BOT and census data.
addChunkToFreeListsAtEndRecordingStats(prevEnd, newFcSize);
}
}
}
@ -1177,11 +1112,7 @@ HeapWord* CompactibleFreeListSpace::allocate(size_t size) {
assert(size == adjustObjectSize(size),
"use adjustObjectSize() before calling into allocate()");
if (_adaptive_freelists) {
res = allocate_adaptive_freelists(size);
} else { // non-adaptive free lists
res = allocate_non_adaptive_freelists(size);
}
res = allocate_adaptive_freelists(size);
if (res != NULL) {
// check that res does lie in this space!
@ -1203,27 +1134,6 @@ HeapWord* CompactibleFreeListSpace::allocate(size_t size) {
return res;
}
HeapWord* CompactibleFreeListSpace::allocate_non_adaptive_freelists(size_t size) {
HeapWord* res = NULL;
// try and use linear allocation for smaller blocks
if (size < _smallLinearAllocBlock._allocation_size_limit) {
// if successful, the following also adjusts block offset table
res = getChunkFromSmallLinearAllocBlock(size);
}
// Else triage to indexed lists for smaller sizes
if (res == NULL) {
if (size < SmallForDictionary) {
res = (HeapWord*) getChunkFromIndexedFreeList(size);
} else {
// else get it from the big dictionary; if even this doesn't
// work we are out of luck.
res = (HeapWord*)getChunkFromDictionaryExact(size);
}
}
return res;
}
HeapWord* CompactibleFreeListSpace::allocate_adaptive_freelists(size_t size) {
assert_lock_strong(freelistLock());
HeapWord* res = NULL;
@ -1281,9 +1191,6 @@ size_t CompactibleFreeListSpace::expansionSpaceRequired(size_t obj_size) const {
// bigLAB or a smallLAB plus refilling a PromotionInfo object. MinChunkSize
// is added because the dictionary may over-allocate to avoid fragmentation.
size_t space = obj_size;
if (!_adaptive_freelists) {
space = MAX2(space, _smallLinearAllocBlock._refillSize);
}
space += _promoInfo.refillSize() + 2 * MinChunkSize;
return space;
}
@ -1698,11 +1605,7 @@ CompactibleFreeListSpace::returnChunkToFreeList(FreeChunk* fc) {
size_t size = fc->size();
_bt.verify_single_block((HeapWord*) fc, size);
_bt.verify_not_unallocated((HeapWord*) fc, size);
if (_adaptive_freelists) {
_indexedFreeList[size].return_chunk_at_tail(fc);
} else {
_indexedFreeList[size].return_chunk_at_head(fc);
}
_indexedFreeList[size].return_chunk_at_tail(fc);
#ifndef PRODUCT
if (CMSCollector::abstract_state() != CMSCollector::Sweeping) {
_indexedFreeList[size].verify_stats();
@ -1931,10 +1834,6 @@ CompactibleFreeListSpace::gc_prologue() {
void
CompactibleFreeListSpace::gc_epilogue() {
assert_locked();
if (PrintGCDetails && Verbose && !_adaptive_freelists) {
if (_smallLinearAllocBlock._word_size == 0)
warning("CompactibleFreeListSpace(epilogue):: Linear allocation failure");
}
assert(_promoInfo.noPromotions(), "_promoInfo inconsistency");
_promoInfo.stopTrackingPromotions();
repairLinearAllocationBlocks();
@ -2060,13 +1959,6 @@ CompactibleFreeListSpace::refillLinearAllocBlock(LinearAllocBlock* blk) {
}
}
// Support for concurrent collection policy decisions.
bool CompactibleFreeListSpace::should_concurrent_collect() const {
// In the future we might want to add in fragmentation stats --
// including erosion of the "mountain" into this decision as well.
return !adaptive_freelists() && linearAllocationWouldFail();
}
// Support for compaction
void CompactibleFreeListSpace::prepare_for_compaction(CompactPoint* cp) {
scan_and_forward(this, cp);

17
hotspot/src/share/vm/gc/cms/compactibleFreeListSpace.hpp
View File

@ -138,15 +138,13 @@ class CompactibleFreeListSpace: public CompactibleSpace {
// Linear allocation blocks
LinearAllocBlock _smallLinearAllocBlock;
FreeBlockDictionary<FreeChunk>::DictionaryChoice _dictionaryChoice;
AFLBinaryTreeDictionary* _dictionary; // Pointer to dictionary for large size blocks
// Indexed array for small size blocks
AdaptiveFreeList<FreeChunk> _indexedFreeList[IndexSetSize];
// Allocation strategy
bool _fitStrategy; // Use best fit strategy
bool _adaptive_freelists; // Use adaptive freelists
bool _fitStrategy; // Use best fit strategy
// This is an address close to the largest free chunk in the heap.
// It is currently assumed to be at the end of the heap. Free
@ -204,10 +202,6 @@ class CompactibleFreeListSpace: public CompactibleSpace {
// strategy that attempts to keep the needed number of chunks in each
// indexed free lists.
HeapWord* allocate_adaptive_freelists(size_t size);
// Allocate from the linear allocation buffers first. This allocation
// strategy assumes maximal coalescing can maintain chunks large enough
// to be used as linear allocation buffers.
HeapWord* allocate_non_adaptive_freelists(size_t size);
// Gets a chunk from the linear allocation block (LinAB). If there
// is not enough space in the LinAB, refills it.
@ -333,9 +327,7 @@ class CompactibleFreeListSpace: public CompactibleSpace {
public:
// Constructor
CompactibleFreeListSpace(BlockOffsetSharedArray* bs, MemRegion mr,
bool use_adaptive_freelists,
FreeBlockDictionary<FreeChunk>::DictionaryChoice);
CompactibleFreeListSpace(BlockOffsetSharedArray* bs, MemRegion mr);
// Accessors
bool bestFitFirst() { return _fitStrategy == FreeBlockBestFitFirst; }
FreeBlockDictionary<FreeChunk>* dictionary() const { return _dictionary; }
@ -349,8 +341,6 @@ class CompactibleFreeListSpace: public CompactibleSpace {
// chunk exists, return NULL.
FreeChunk* find_chunk_at_end();
bool adaptive_freelists() const { return _adaptive_freelists; }
void set_collector(CMSCollector* collector) { _collector = collector; }
// Support for parallelization of rescan and marking.
@ -536,9 +526,6 @@ class CompactibleFreeListSpace: public CompactibleSpace {
void addChunkAndRepairOffsetTable(HeapWord* chunk, size_t size,
bool coalesced);
// Support for decisions regarding concurrent collection policy.
bool should_concurrent_collect() const;
// Support for compaction.
void prepare_for_compaction(CompactPoint* cp);
void adjust_pointers();

167
hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp
View File

@ -190,9 +190,7 @@ class CMSParGCThreadState: public CHeapObj<mtGC> {
};
ConcurrentMarkSweepGeneration::ConcurrentMarkSweepGeneration(
ReservedSpace rs, size_t initial_byte_size,
CardTableRS* ct, bool use_adaptive_freelists,
FreeBlockDictionary<FreeChunk>::DictionaryChoice dictionaryChoice) :
ReservedSpace rs, size_t initial_byte_size, CardTableRS* ct) :
CardGeneration(rs, initial_byte_size, ct),
_dilatation_factor(((double)MinChunkSize)/((double)(CollectedHeap::min_fill_size()))),
_did_compact(false)
@ -208,9 +206,7 @@ ConcurrentMarkSweepGeneration::ConcurrentMarkSweepGeneration(
_numWordsAllocated = 0;
)
_cmsSpace = new CompactibleFreeListSpace(_bts, MemRegion(bottom, end),
use_adaptive_freelists,
dictionaryChoice);
_cmsSpace = new CompactibleFreeListSpace(_bts, MemRegion(bottom, end));
NOT_PRODUCT(debug_cms_space = _cmsSpace;)
_cmsSpace->_old_gen = this;
@ -1312,13 +1308,6 @@ bool ConcurrentMarkSweepGeneration::should_concurrent_collect() const {
}
return true;
}
if (_cmsSpace->should_concurrent_collect()) {
if (PrintGCDetails && Verbose) {
gclog_or_tty->print(" %s: collect because cmsSpace says so ",
short_name());
}
return true;
}
return false;
}
@ -1766,9 +1755,8 @@ void CMSCollector::collect_in_background(GCCause::Cause cause) {
MutexLockerEx hl(Heap_lock, safepoint_check);
FreelistLocker fll(this);
MutexLockerEx x(CGC_lock, safepoint_check);
if (_foregroundGCIsActive || !UseAsyncConcMarkSweepGC) {
// The foreground collector is active or we're
// not using asynchronous collections. Skip this
if (_foregroundGCIsActive) {
// The foreground collector is. Skip this
// background collection.
assert(!_foregroundGCShouldWait, "Should be clear");
return;
@ -1795,7 +1783,7 @@ void CMSCollector::collect_in_background(GCCause::Cause cause) {
}
// Used for PrintGC
size_t prev_used;
size_t prev_used = 0;
if (PrintGC && Verbose) {
prev_used = _cmsGen->used();
}
@ -5214,9 +5202,8 @@ void CMSCollector::do_remark_non_parallel() {
verify_work_stacks_empty();
// Restore evacuated mark words, if any, used for overflow list links
if (!CMSOverflowEarlyRestoration) {
restore_preserved_marks_if_any();
}
restore_preserved_marks_if_any();
verify_overflow_empty();
}
@ -6186,17 +6173,8 @@ void MarkRefsIntoAndScanClosure::do_oop(oop obj) {
assert(_mark_stack->isEmpty(), "post-condition (eager drainage)");
assert(_collector->overflow_list_is_empty(),
"overflow list was drained above");
// We could restore evacuated mark words, if any, used for
// overflow list links here because the overflow list is
// provably empty here. That would reduce the maximum
// size requirements for preserved_{oop,mark}_stack.
// But we'll just postpone it until we are all done
// so we can just stream through.
if (!_concurrent_precleaning && CMSOverflowEarlyRestoration) {
_collector->restore_preserved_marks_if_any();
assert(_collector->no_preserved_marks(), "No preserved marks");
}
assert(!CMSOverflowEarlyRestoration || _collector->no_preserved_marks(),
assert(_collector->no_preserved_marks(),
"All preserved marks should have been restored above");
}
}
@ -7372,14 +7350,6 @@ void SweepClosure::initialize_free_range(HeapWord* freeFinger,
set_freeFinger(freeFinger);
set_freeRangeInFreeLists(freeRangeInFreeLists);
if (CMSTestInFreeList) {
if (freeRangeInFreeLists) {
FreeChunk* fc = (FreeChunk*) freeFinger;
assert(fc->is_free(), "A chunk on the free list should be free.");
assert(fc->size() > 0, "Free range should have a size");
assert(_sp->verify_chunk_in_free_list(fc), "Chunk is not in free lists");
}
}
}
// Note that the sweeper runs concurrently with mutators. Thus,
@ -7532,12 +7502,7 @@ size_t SweepClosure::do_blk_careful(HeapWord* addr) {
void SweepClosure::do_already_free_chunk(FreeChunk* fc) {
const size_t size = fc->size();
// Chunks that cannot be coalesced are not in the
// free lists.
if (CMSTestInFreeList && !fc->cantCoalesce()) {
assert(_sp->verify_chunk_in_free_list(fc),
"free chunk should be in free lists");
}
// a chunk that is already free, should not have been
// marked in the bit map
HeapWord* const addr = (HeapWord*) fc;
@ -7550,57 +7515,8 @@ void SweepClosure::do_already_free_chunk(FreeChunk* fc) {
// See the definition of cantCoalesce().
if (!fc->cantCoalesce()) {
// This chunk can potentially be coalesced.
if (_sp->adaptive_freelists()) {
// All the work is done in
do_post_free_or_garbage_chunk(fc, size);
} else { // Not adaptive free lists
// this is a free chunk that can potentially be coalesced by the sweeper;
if (!inFreeRange()) {
// if the next chunk is a free block that can't be coalesced
// it doesn't make sense to remove this chunk from the free lists
FreeChunk* nextChunk = (FreeChunk*)(addr + size);
assert((HeapWord*)nextChunk <= _sp->end(), "Chunk size out of bounds?");
if ((HeapWord*)nextChunk < _sp->end() && // There is another free chunk to the right ...
nextChunk->is_free() && // ... which is free...
nextChunk->cantCoalesce()) { // ... but can't be coalesced
// nothing to do
} else {
// Potentially the start of a new free range:
// Don't eagerly remove it from the free lists.
// No need to remove it if it will just be put
// back again. (Also from a pragmatic point of view
// if it is a free block in a region that is beyond
// any allocated blocks, an assertion will fail)
// Remember the start of a free run.
initialize_free_range(addr, true);
// end - can coalesce with next chunk
}
} else {
// the midst of a free range, we are coalescing
print_free_block_coalesced(fc);
if (CMSTraceSweeper) {
gclog_or_tty->print(" -- pick up free block " PTR_FORMAT " (" SIZE_FORMAT ")\n", p2i(fc), size);
}
// remove it from the free lists
_sp->removeFreeChunkFromFreeLists(fc);
set_lastFreeRangeCoalesced(true);
// If the chunk is being coalesced and the current free range is
// in the free lists, remove the current free range so that it
// will be returned to the free lists in its entirety - all
// the coalesced pieces included.
if (freeRangeInFreeLists()) {
FreeChunk* ffc = (FreeChunk*) freeFinger();
assert(ffc->size() == pointer_delta(addr, freeFinger()),
"Size of free range is inconsistent with chunk size.");
if (CMSTestInFreeList) {
assert(_sp->verify_chunk_in_free_list(ffc),
"free range is not in free lists");
}
_sp->removeFreeChunkFromFreeLists(ffc);
set_freeRangeInFreeLists(false);
}
}
}
// All the work is done in
do_post_free_or_garbage_chunk(fc, size);
// Note that if the chunk is not coalescable (the else arm
// below), we unconditionally flush, without needing to do
// a "lookahead," as we do below.
@ -7626,46 +7542,11 @@ size_t SweepClosure::do_garbage_chunk(FreeChunk* fc) {
HeapWord* const addr = (HeapWord*) fc;
const size_t size = CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size());
if (_sp->adaptive_freelists()) {
// Verify that the bit map has no bits marked between
// addr and purported end of just dead object.
_bitMap->verifyNoOneBitsInRange(addr + 1, addr + size);
// Verify that the bit map has no bits marked between
// addr and purported end of just dead object.
_bitMap->verifyNoOneBitsInRange(addr + 1, addr + size);
do_post_free_or_garbage_chunk(fc, size);
do_post_free_or_garbage_chunk(fc, size);
} else {
if (!inFreeRange()) {
// start of a new free range
assert(size > 0, "A free range should have a size");
initialize_free_range(addr, false);
} else {
// this will be swept up when we hit the end of the
// free range
if (CMSTraceSweeper) {
gclog_or_tty->print(" -- pick up garbage " PTR_FORMAT " (" SIZE_FORMAT ")\n", p2i(fc), size);
}
// If the chunk is being coalesced and the current free range is
// in the free lists, remove the current free range so that it
// will be returned to the free lists in its entirety - all
// the coalesced pieces included.
if (freeRangeInFreeLists()) {
FreeChunk* ffc = (FreeChunk*)freeFinger();
assert(ffc->size() == pointer_delta(addr, freeFinger()),
"Size of free range is inconsistent with chunk size.");
if (CMSTestInFreeList) {
assert(_sp->verify_chunk_in_free_list(ffc),
"free range is not in free lists");
}
_sp->removeFreeChunkFromFreeLists(ffc);
set_freeRangeInFreeLists(false);
}
set_lastFreeRangeCoalesced(true);
}
// this will be swept up when we hit the end of the free range
// Verify that the bit map has no bits marked between
// addr and purported end of just dead object.
_bitMap->verifyNoOneBitsInRange(addr + 1, addr + size);
}
assert(_limit >= addr + size,
"A freshly garbage chunk can't possibly straddle over _limit");
if (inFreeRange()) lookahead_and_flush(fc, size);
@ -7727,11 +7608,7 @@ void SweepClosure::do_post_free_or_garbage_chunk(FreeChunk* fc,
// do_post_free_or_garbage_chunk() should only be called in the case
// of the adaptive free list allocator.
const bool fcInFreeLists = fc->is_free();
assert(_sp->adaptive_freelists(), "Should only be used in this case.");
assert((HeapWord*)fc <= _limit, "sweep invariant");
if (CMSTestInFreeList && fcInFreeLists) {
assert(_sp->verify_chunk_in_free_list(fc), "free chunk is not in free lists");
}
if (CMSTraceSweeper) {
gclog_or_tty->print_cr(" -- pick up another chunk at " PTR_FORMAT " (" SIZE_FORMAT ")", p2i(fc), chunkSize);
@ -7739,7 +7616,7 @@ void SweepClosure::do_post_free_or_garbage_chunk(FreeChunk* fc,
HeapWord* const fc_addr = (HeapWord*) fc;
bool coalesce;
bool coalesce = false;
const size_t left = pointer_delta(fc_addr, freeFinger());
const size_t right = chunkSize;
switch (FLSCoalescePolicy) {
@ -7784,10 +7661,6 @@ void SweepClosure::do_post_free_or_garbage_chunk(FreeChunk* fc,
FreeChunk* const ffc = (FreeChunk*)freeFinger();
assert(ffc->size() == pointer_delta(fc_addr, freeFinger()),
"Size of free range is inconsistent with chunk size.");
if (CMSTestInFreeList) {
assert(_sp->verify_chunk_in_free_list(ffc),
"Chunk is not in free lists");
}
_sp->coalDeath(ffc->size());
_sp->removeFreeChunkFromFreeLists(ffc);
set_freeRangeInFreeLists(false);
@ -7856,12 +7729,6 @@ void SweepClosure::flush_cur_free_chunk(HeapWord* chunk, size_t size) {
assert(size > 0,
"A zero sized chunk cannot be added to the free lists.");
if (!freeRangeInFreeLists()) {
if (CMSTestInFreeList) {
FreeChunk* fc = (FreeChunk*) chunk;
fc->set_size(size);
assert(!_sp->verify_chunk_in_free_list(fc),
"chunk should not be in free lists yet");
}
if (CMSTraceSweeper) {
gclog_or_tty->print_cr(" -- add free block " PTR_FORMAT " (" SIZE_FORMAT ") to free lists",
p2i(chunk), size);

11
hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp
View File

@ -1076,10 +1076,7 @@ class ConcurrentMarkSweepGeneration: public CardGeneration {
void assert_correct_size_change_locking();
public:
ConcurrentMarkSweepGeneration(ReservedSpace rs, size_t initial_byte_size,
CardTableRS* ct,
bool use_adaptive_freelists,
FreeBlockDictionary<FreeChunk>::DictionaryChoice);
ConcurrentMarkSweepGeneration(ReservedSpace rs, size_t initial_byte_size, CardTableRS* ct);
// Accessors
CMSCollector* collector() const { return _collector; }
@ -1121,12 +1118,6 @@ class ConcurrentMarkSweepGeneration: public CardGeneration {
// over-rides
MemRegion used_region_at_save_marks() const;
// Does a "full" (forced) collection invoked on this generation collect
// the young generation as well?
virtual bool full_collects_young_generation() const {
return !ScavengeBeforeFullGC;
}
// Adjust quantities in the generation affected by
// the compaction.
void reset_after_compaction();

1
hotspot/src/share/vm/gc/cms/vmCMSOperations.hpp
View File

@ -138,7 +138,6 @@ class VM_GenCollectFullConcurrent: public VM_GC_Operation {
: VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true /* full */)
{
assert(FullGCCount_lock != NULL, "Error");
assert(UseAsyncConcMarkSweepGC, "Else will hang caller");
}
~VM_GenCollectFullConcurrent() {}
virtual VMOp_Type type() const { return VMOp_GenCollectFullConcurrent; }

47
hotspot/src/share/vm/gc/g1/g1CollectorPolicy.cpp
View File

@ -431,7 +431,7 @@ void G1CollectorPolicy::init() {
}
_free_regions_at_end_of_collection = _g1->num_free_regions();
update_young_list_target_length();
update_young_list_max_and_target_length();
// We may immediately start allocating regions and placing them on the
// collection set list. Initialize the per-collection set info
start_incremental_cset_building();
@ -507,13 +507,24 @@ uint G1CollectorPolicy::calculate_young_list_desired_max_length() const {
return _young_gen_sizer->max_desired_young_length();
}
void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths) {
if (rs_lengths == (size_t) -1) {
// if it's set to the default value (-1), we should predict it;
// otherwise, use the given value.
rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq);
}
void G1CollectorPolicy::update_young_list_max_and_target_length() {
update_young_list_max_and_target_length(get_new_prediction(_rs_lengths_seq));
}
void G1CollectorPolicy::update_young_list_max_and_target_length(size_t rs_lengths) {
update_young_list_target_length(rs_lengths);
update_max_gc_locker_expansion();
}
void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths) {
_young_list_target_length = bounded_young_list_target_length(rs_lengths);
}
void G1CollectorPolicy::update_young_list_target_length() {
update_young_list_target_length(get_new_prediction(_rs_lengths_seq));
}
uint G1CollectorPolicy::bounded_young_list_target_length(size_t rs_lengths) const {
// Calculate the absolute and desired min bounds.
// This is how many young regions we already have (currently: the survivors).
@ -544,7 +555,6 @@ void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths) {
base_min_length,
desired_min_length,
desired_max_length);
_rs_lengths_prediction = rs_lengths;
} else {
// Don't calculate anything and let the code below bound it to
// the desired_min_length, i.e., do the next GC as soon as
@ -569,9 +579,8 @@ void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths) {
assert(young_list_target_length > recorded_survivor_regions(),
"we should be able to allocate at least one eden region");
assert(young_list_target_length >= absolute_min_length, "post-condition");
_young_list_target_length = young_list_target_length;
update_max_gc_locker_expansion();
return young_list_target_length;
}
uint
@ -695,11 +704,21 @@ void G1CollectorPolicy::revise_young_list_target_length_if_necessary() {
if (rs_lengths > _rs_lengths_prediction) {
// add 10% to avoid having to recalculate often
size_t rs_lengths_prediction = rs_lengths * 1100 / 1000;
update_young_list_target_length(rs_lengths_prediction);
update_rs_lengths_prediction(rs_lengths_prediction);
update_young_list_max_and_target_length(rs_lengths_prediction);
}
}
void G1CollectorPolicy::update_rs_lengths_prediction() {
update_rs_lengths_prediction(get_new_prediction(_rs_lengths_seq));
}
void G1CollectorPolicy::update_rs_lengths_prediction(size_t prediction) {
if (collector_state()->gcs_are_young() && adaptive_young_list_length()) {
_rs_lengths_prediction = prediction;
}
}
HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size,
bool is_tlab,
@ -801,7 +820,8 @@ void G1CollectorPolicy::record_full_collection_end() {
_free_regions_at_end_of_collection = _g1->num_free_regions();
// Reset survivors SurvRateGroup.
_survivor_surv_rate_group->reset();
update_young_list_target_length();
update_young_list_max_and_target_length();
update_rs_lengths_prediction();
_collectionSetChooser->clear();
}
@ -1147,7 +1167,8 @@ void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms, size_t
collector_state()->set_in_marking_window(new_in_marking_window);
collector_state()->set_in_marking_window_im(new_in_marking_window_im);
_free_regions_at_end_of_collection = _g1->num_free_regions();
update_young_list_target_length();
update_young_list_max_and_target_length();
update_rs_lengths_prediction();
// Note that _mmu_tracker->max_gc_time() returns the time in seconds.
double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0;

11
hotspot/src/share/vm/gc/g1/g1CollectorPolicy.hpp
View File

@ -465,12 +465,16 @@ private:
double _mark_remark_start_sec;
double _mark_cleanup_start_sec;
void update_young_list_max_and_target_length();
void update_young_list_max_and_target_length(size_t rs_lengths);
// Update the young list target length either by setting it to the
// desired fixed value or by calculating it using G1's pause
// prediction model. If no rs_lengths parameter is passed, predict
// the RS lengths using the prediction model, otherwise use the
// given rs_lengths as the prediction.
void update_young_list_target_length(size_t rs_lengths = (size_t) -1);
void update_young_list_target_length();
void update_young_list_target_length(size_t rs_lengths);
// Calculate and return the minimum desired young list target
// length. This is the minimum desired young list length according
@ -493,6 +497,11 @@ private:
uint desired_min_length,
uint desired_max_length) const;
uint bounded_young_list_target_length(size_t rs_lengths) const;
void update_rs_lengths_prediction();
void update_rs_lengths_prediction(size_t prediction);
// Calculate and return chunk size (in number of regions) for parallel
// concurrent mark cleanup.
uint calculate_parallel_work_chunk_size(uint n_workers, uint n_regions) const;

5
hotspot/src/share/vm/gc/g1/heapRegionRemSet.cpp
View File

@ -563,7 +563,7 @@ PerRegionTable* OtherRegionsTable::delete_region_table() {
assert(_n_fine_entries == _max_fine_entries, "Precondition");
PerRegionTable* max = NULL;
jint max_occ = 0;
PerRegionTable** max_prev;
PerRegionTable** max_prev = NULL;
size_t max_ind;
size_t i = _fine_eviction_start;
@ -599,6 +599,7 @@ PerRegionTable* OtherRegionsTable::delete_region_table() {
}
guarantee(max != NULL, "Since _n_fine_entries > 0");
guarantee(max_prev != NULL, "Since max != NULL.");
// Set the corresponding coarse bit.
size_t max_hrm_index = (size_t) max->hr()->hrm_index();
@ -1138,7 +1139,7 @@ void HeapRegionRemSet::print_event(outputStream* str, Event evnt) {
void HeapRegionRemSet::print_recorded() {
int cur_evnt = 0;
Event cur_evnt_kind;
Event cur_evnt_kind = Event_illegal;
int cur_evnt_ind = 0;
if (_n_recorded_events > 0) {
cur_evnt_kind = _recorded_events[cur_evnt];

2
hotspot/src/share/vm/gc/g1/heapRegionRemSet.hpp
View File

@ -222,7 +222,7 @@ class HeapRegionRemSet : public CHeapObj<mtGC> {
public:
enum Event {
Event_EvacStart, Event_EvacEnd, Event_RSUpdateEnd
Event_EvacStart, Event_EvacEnd, Event_RSUpdateEnd, Event_illegal
};
private:

2
hotspot/src/share/vm/gc/serial/defNewGeneration.cpp
View File

@ -383,7 +383,7 @@ void DefNewGeneration::compute_new_size() {
size_t old_size = gch->old_gen()->capacity();
size_t new_size_before = _virtual_space.committed_size();
size_t min_new_size = spec()->init_size();
size_t min_new_size = initial_size();
size_t max_new_size = reserved().byte_size();
assert(min_new_size <= new_size_before &&
new_size_before <= max_new_size,

7
hotspot/src/share/vm/gc/serial/tenuredGeneration.hpp
View File

@ -66,13 +66,6 @@ class TenuredGeneration: public CardGeneration {
const char* name() const { return "tenured generation"; }
const char* short_name() const { return "Tenured"; }
// Does a "full" (forced) collection invoked on this generation collect
// the young generation as well? Note that this is a hack to allow the
// collection of the young gen first if the flag is set.
virtual bool full_collects_young_generation() const {
return !ScavengeBeforeFullGC;
}
size_t unsafe_max_alloc_nogc() const;
size_t contiguous_available() const;

32
hotspot/src/share/vm/gc/shared/cardGeneration.cpp
View File

@ -208,8 +208,7 @@ void CardGeneration::compute_new_size() {
const double min_tmp = used_after_gc / maximum_used_percentage;
size_t minimum_desired_capacity = (size_t)MIN2(min_tmp, double(max_uintx));
// Don't shrink less than the initial generation size
minimum_desired_capacity = MAX2(minimum_desired_capacity,
spec()->init_size());
minimum_desired_capacity = MAX2(minimum_desired_capacity, initial_size());
assert(used_after_gc <= minimum_desired_capacity, "sanity check");
if (PrintGC && Verbose) {
@ -262,8 +261,7 @@ void CardGeneration::compute_new_size() {
const double minimum_used_percentage = 1.0 - maximum_free_percentage;
const double max_tmp = used_after_gc / minimum_used_percentage;
size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, double(max_uintx));
maximum_desired_capacity = MAX2(maximum_desired_capacity,
spec()->init_size());
maximum_desired_capacity = MAX2(maximum_desired_capacity, initial_size());
if (PrintGC && Verbose) {
gclog_or_tty->print_cr(" "
" maximum_free_percentage: %6.2f"
@ -299,20 +297,20 @@ void CardGeneration::compute_new_size() {
}
if (PrintGC && Verbose) {
gclog_or_tty->print_cr(" "
" shrinking:"
" initSize: %.1fK"
" maximum_desired_capacity: %.1fK",
spec()->init_size() / (double) K,
maximum_desired_capacity / (double) K);
" shrinking:"
" initSize: %.1fK"
" maximum_desired_capacity: %.1fK",
initial_size() / (double) K,
maximum_desired_capacity / (double) K);
gclog_or_tty->print_cr(" "
" shrink_bytes: %.1fK"
" current_shrink_factor: " SIZE_FORMAT
" new shrink factor: " SIZE_FORMAT
" _min_heap_delta_bytes: %.1fK",
shrink_bytes / (double) K,
current_shrink_factor,
_shrink_factor,
_min_heap_delta_bytes / (double) K);
" shrink_bytes: %.1fK"
" current_shrink_factor: " SIZE_FORMAT
" new shrink factor: " SIZE_FORMAT
" _min_heap_delta_bytes: %.1fK",
shrink_bytes / (double) K,
current_shrink_factor,
_shrink_factor,
_min_heap_delta_bytes / (double) K);
}
}
}

11
hotspot/src/share/vm/gc/shared/genCollectedHeap.cpp
View File

@ -460,10 +460,9 @@ void GenCollectedHeap::do_collection(bool full,
bool prepared_for_verification = false;
bool collected_old = false;
bool old_collects_young = complete &&
_old_gen->full_collects_young_generation();
if (!old_collects_young &&
_young_gen->should_collect(full, size, is_tlab)) {
bool old_collects_young = complete && !ScavengeBeforeFullGC;
if (!old_collects_young && _young_gen->should_collect(full, size, is_tlab)) {
if (run_verification && VerifyGCLevel <= 0 && VerifyBeforeGC) {
prepare_for_verify();
prepared_for_verification = true;
@ -1107,10 +1106,6 @@ void GenCollectedHeap::prepare_for_compaction() {
_young_gen->prepare_for_compaction(&cp);
}
GCStats* GenCollectedHeap::gc_stats(Generation* gen) const {
return gen->gc_stats();
}
void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) {
if (!silent) {
gclog_or_tty->print("%s", _old_gen->name());

2
hotspot/src/share/vm/gc/shared/genCollectedHeap.hpp
View File

@ -126,8 +126,6 @@ public:
WorkGang* workers() const { return _workers; }
GCStats* gc_stats(Generation* generation) const;
// Returns JNI_OK on success
virtual jint initialize();

6
hotspot/src/share/vm/gc/shared/generation.cpp
View File

@ -58,12 +58,12 @@ Generation::Generation(ReservedSpace rs, size_t initial_size) :
(HeapWord*)_virtual_space.high_boundary());
}
GenerationSpec* Generation::spec() {
size_t Generation::initial_size() {
GenCollectedHeap* gch = GenCollectedHeap::heap();
if (gch->is_young_gen(this)) {
return gch->gen_policy()->young_gen_spec();
return gch->gen_policy()->young_gen_spec()->init_size();
}
return gch->gen_policy()->old_gen_spec();
return gch->gen_policy()->old_gen_spec()->init_size();
}
size_t Generation::max_capacity() const {

10
hotspot/src/share/vm/gc/shared/generation.hpp
View File

@ -141,14 +141,14 @@ class Generation: public CHeapObj<mtGC> {
}
virtual Generation::Name kind() { return Generation::Other; }
GenerationSpec* spec();
// This properly belongs in the collector, but for now this
// will do.
virtual bool refs_discovery_is_atomic() const { return true; }
virtual bool refs_discovery_is_mt() const { return false; }
// Space enquiries (results in bytes)
// Space inquiries (results in bytes)
size_t initial_size();
virtual size_t capacity() const = 0; // The maximum number of object bytes the
// generation can currently hold.
virtual size_t used() const = 0; // The number of used bytes in the gen.
@ -309,10 +309,6 @@ class Generation: public CHeapObj<mtGC> {
// do nothing.
virtual void par_oop_since_save_marks_iterate_done(int thread_num) {}
// This generation will collect all younger generations
// during a full collection.
virtual bool full_collects_young_generation() const { return false; }
// This generation does in-place marking, meaning that mark words
// are mutated during the marking phase and presumably reinitialized
// to a canonical value after the GC. This is currently used by the
@ -403,7 +399,7 @@ class Generation: public CHeapObj<mtGC> {
// that was most recently collected. This allows the generation to
// decide what statistics are valid to collect. For example, the
// generation can decide to gather the amount of promoted data if
// the collection of the younger generations has completed.
// the collection of the young generation has completed.
GCStats* gc_stats() const { return _gc_stats; }
virtual void update_gc_stats(Generation* current_generation, bool full) {}

4
hotspot/src/share/vm/gc/shared/generationSpec.cpp
View File

@ -58,9 +58,7 @@ Generation* GenerationSpec::init(ReservedSpace rs, CardTableRS* remset) {
// else registers with an existing CMSCollector
ConcurrentMarkSweepGeneration* g = NULL;
g = new ConcurrentMarkSweepGeneration(rs,
init_size(), remset, UseCMSAdaptiveFreeLists,
(FreeBlockDictionary<FreeChunk>::DictionaryChoice)CMSDictionaryChoice);
g = new ConcurrentMarkSweepGeneration(rs, init_size(), remset);
g->initialize_performance_counters();

2
hotspot/src/share/vm/interpreter/templateInterpreter.cpp
View File

@ -562,7 +562,7 @@ void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState t
if (StopInterpreterAt > 0) stop_interpreter_at();
__ verify_FPU(1, t->tos_in());
#endif // !PRODUCT
int step;
int step = 0;
if (!t->does_dispatch()) {
step = t->is_wide() ? Bytecodes::wide_length_for(t->bytecode()) : Bytecodes::length_for(t->bytecode());
if (tos_out == ilgl) tos_out = t->tos_out();

6
hotspot/src/share/vm/memory/allocation.cpp
View File

@ -66,7 +66,7 @@ void MetaspaceObj::print_address_on(outputStream* st) const {
}
void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) throw() {
address res;
address res = NULL;
switch (type) {
case C_HEAP:
res = (address)AllocateHeap(size, flags, CALLER_PC);
@ -88,8 +88,8 @@ void* ResourceObj::operator new [](size_t size, allocation_type type, MEMFLAGS f
void* ResourceObj::operator new(size_t size, const std::nothrow_t& nothrow_constant,
allocation_type type, MEMFLAGS flags) throw() {
//should only call this with std::nothrow, use other operator new() otherwise
address res;
// should only call this with std::nothrow, use other operator new() otherwise
address res = NULL;
switch (type) {
case C_HEAP:
res = (address)AllocateHeap(size, flags, CALLER_PC, AllocFailStrategy::RETURN_NULL);

2
hotspot/src/share/vm/opto/callGenerator.cpp
View File

@ -671,7 +671,7 @@ JVMState* PredictedCallGenerator::generate(JVMState* jvms) {
&exact_receiver);
SafePointNode* slow_map = NULL;
JVMState* slow_jvms;
JVMState* slow_jvms = NULL;
{ PreserveJVMState pjvms(&kit);
kit.set_control(slow_ctl);
if (!kit.stopped()) {

2
hotspot/src/share/vm/opto/compile.cpp
View File

@ -3757,7 +3757,7 @@ void Compile::ConstantTable::emit(CodeBuffer& cb) {
MacroAssembler _masm(&cb);
for (int i = 0; i < _constants.length(); i++) {
Constant con = _constants.at(i);
address constant_addr;
address constant_addr = NULL;
switch (con.type()) {
case T_LONG: constant_addr = _masm.long_constant( con.get_jlong() ); break;
case T_FLOAT: constant_addr = _masm.float_constant( con.get_jfloat() ); break;

10
hotspot/src/share/vm/opto/compile.hpp
View File

@ -89,7 +89,7 @@ struct Final_Reshape_Counts;
typedef unsigned int node_idx_t;
class NodeCloneInfo {
private:
uint64_t _idx_clone_orig;
uint64_t _idx_clone_orig;
public:
void set_idx(node_idx_t idx) {
@ -98,17 +98,17 @@ class NodeCloneInfo {
node_idx_t idx() const { return (node_idx_t)(_idx_clone_orig & 0xFFFFFFFF); }
void set_gen(int generation) {
uint64_t g = (uint64_t)generation << 32;
uint64_t g = (uint64_t)generation << 32;
_idx_clone_orig = _idx_clone_orig & 0xFFFFFFFF | g;
}
int gen() const { return (int)(_idx_clone_orig >> 32); }
void set(uint64_t x) { _idx_clone_orig = x; }
void set(node_idx_t x, int g) { set_idx(x); set_gen(g); }
void set(uint64_t x) { _idx_clone_orig = x; }
void set(node_idx_t x, int g) { set_idx(x); set_gen(g); }
uint64_t get() const { return _idx_clone_orig; }
NodeCloneInfo(uint64_t idx_clone_orig) : _idx_clone_orig(idx_clone_orig) {}
NodeCloneInfo(node_idx_t x, int g) {set(x, g);}
NodeCloneInfo(node_idx_t x, int g) : _idx_clone_orig(0) { set(x, g); }
void dump() const;
};

2
hotspot/src/share/vm/opto/generateOptoStub.cpp
View File

@ -261,7 +261,7 @@ void GraphKit::gen_stub(address C_function,
//-----------------------------
// If this is a normal subroutine return, issue the return and be done.
Node *ret;
Node *ret = NULL;
switch( is_fancy_jump ) {
case 0: // Make a return instruction
// Return to caller, free any space for return address

2
hotspot/src/share/vm/opto/lcm.cpp
View File

@ -806,7 +806,7 @@ uint PhaseCFG::sched_call(Block* block, uint node_cnt, Node_List& worklist, Grow
block->insert_node(proj, node_cnt++);
// Select the right register save policy.
const char * save_policy;
const char *save_policy = NULL;
switch (op) {
case Op_CallRuntime:
case Op_CallLeaf:

16
hotspot/src/share/vm/opto/library_call.cpp
View File

@ -1364,7 +1364,7 @@ Node* LibraryCallKit::round_double_node(Node* n) {
// public static double Math.log10(double)
bool LibraryCallKit::inline_math(vmIntrinsics::ID id) {
Node* arg = round_double_node(argument(0));
Node* n;
Node* n = NULL;
switch (id) {
case vmIntrinsics::_dabs: n = new AbsDNode( arg); break;
case vmIntrinsics::_dsqrt: n = new SqrtDNode(C, control(), arg); break;
@ -2108,7 +2108,7 @@ inline Node* LibraryCallKit::make_unsafe_address(Node* base, Node* offset) {
// inline long Long.reverseBytes(long)
bool LibraryCallKit::inline_number_methods(vmIntrinsics::ID id) {
Node* arg = argument(0);
Node* n;
Node* n = NULL;
switch (id) {
case vmIntrinsics::_numberOfLeadingZeros_i: n = new CountLeadingZerosINode( arg); break;
case vmIntrinsics::_numberOfLeadingZeros_l: n = new CountLeadingZerosLNode( arg); break;
@ -2648,7 +2648,7 @@ bool LibraryCallKit::inline_unsafe_load_store(BasicType type, LoadStoreKind kind
// For now, we handle only those cases that actually exist: ints,
// longs, and Object. Adding others should be straightforward.
Node* load_store;
Node* load_store = NULL;
switch(type) {
case T_INT:
if (kind == LS_xadd) {
@ -3654,7 +3654,7 @@ bool LibraryCallKit::inline_array_copyOf(bool is_copyOfRange) {
Node* end = is_copyOfRange? argument(2): argument(1);
Node* array_type_mirror = is_copyOfRange? argument(3): argument(2);
Node* newcopy;
Node* newcopy = NULL;
// Set the original stack and the reexecute bit for the interpreter to reexecute
// the bytecode that invokes Arrays.copyOf if deoptimization happens.
@ -4089,7 +4089,7 @@ bool LibraryCallKit::inline_native_Reflection_getCallerClass() {
bool LibraryCallKit::inline_fp_conversions(vmIntrinsics::ID id) {
Node* arg = argument(0);
Node* result;
Node* result = NULL;
switch (id) {
case vmIntrinsics::_floatToRawIntBits: result = new MoveF2INode(arg); break;
@ -5718,7 +5718,7 @@ Node * LibraryCallKit::load_field_from_object(Node * fromObj, const char * field
//------------------------------inline_aescrypt_Block-----------------------
bool LibraryCallKit::inline_aescrypt_Block(vmIntrinsics::ID id) {
address stubAddr;
address stubAddr = NULL;
const char *stubName;
assert(UseAES, "need AES instruction support");
@ -5784,8 +5784,8 @@ bool LibraryCallKit::inline_aescrypt_Block(vmIntrinsics::ID id) {
//------------------------------inline_cipherBlockChaining_AESCrypt-----------------------
bool LibraryCallKit::inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id) {
address stubAddr;
const char *stubName;
address stubAddr = NULL;
const char *stubName = NULL;
assert(UseAES, "need AES instruction support");

16
hotspot/src/share/vm/opto/macro.cpp
View File

@ -779,10 +779,10 @@ bool PhaseMacroExpand::scalar_replacement(AllocateNode *alloc, GrowableArray <Sa
ciKlass* klass = NULL;
ciInstanceKlass* iklass = NULL;
int nfields = 0;
int array_base;
int element_size;
BasicType basic_elem_type;
ciType* elem_type;
int array_base = 0;
int element_size = 0;
BasicType basic_elem_type = T_ILLEGAL;
ciType* elem_type = NULL;
Node* res = alloc->result_cast();
assert(res == NULL || res->is_CheckCastPP(), "unexpected AllocateNode result");
@ -1305,10 +1305,10 @@ void PhaseMacroExpand::expand_allocate_common(
// We need a Region and corresponding Phi's to merge the slow-path and fast-path results.
// they will not be used if "always_slow" is set
enum { slow_result_path = 1, fast_result_path = 2 };
Node *result_region;
Node *result_phi_rawmem;
Node *result_phi_rawoop;
Node *result_phi_i_o;
Node *result_region = NULL;
Node *result_phi_rawmem = NULL;
Node *result_phi_rawoop = NULL;
Node *result_phi_i_o = NULL;
// The initial slow comparison is a size check, the comparison
// we want to do is a BoolTest::gt

4
hotspot/src/share/vm/opto/parse1.cpp
View File

@ -108,7 +108,7 @@ Node *Parse::fetch_interpreter_state(int index,
// Very similar to LoadNode::make, except we handle un-aligned longs and
// doubles on Sparc. Intel can handle them just fine directly.
Node *l;
Node *l = NULL;
switch (bt) { // Signature is flattened
case T_INT: l = new LoadINode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInt::INT, MemNode::unordered); break;
case T_FLOAT: l = new LoadFNode(ctl, mem, adr, TypeRawPtr::BOTTOM, Type::FLOAT, MemNode::unordered); break;
@ -1903,7 +1903,7 @@ PhiNode *Parse::ensure_phi(int idx, bool nocreate) {
// Now use a Phi here for merging
assert(!nocreate, "Cannot build a phi for a block already parsed.");
const JVMState* jvms = map->jvms();
const Type* t;
const Type* t = NULL;
if (jvms->is_loc(idx)) {
t = block()->local_type_at(idx - jvms->locoff());
} else if (jvms->is_stk(idx)) {

4
hotspot/src/share/vm/opto/split_if.cpp
View File

@ -451,8 +451,8 @@ void PhaseIdealLoop::do_split_if( Node *iff ) {
// Replace both uses of 'new_iff' with Regions merging True/False
// paths. This makes 'new_iff' go dead.
Node *old_false, *old_true;
Node *new_false, *new_true;
Node *old_false = NULL, *old_true = NULL;
Node *new_false = NULL, *new_true = NULL;
for (DUIterator_Last j2min, j2 = iff->last_outs(j2min); j2 >= j2min; --j2) {
Node *ifp = iff->last_out(j2);
assert( ifp->Opcode() == Op_IfFalse || ifp->Opcode() == Op_IfTrue, "" );

2
hotspot/src/share/vm/opto/superword.cpp
View File

@ -3665,7 +3665,7 @@ Node* SuperWord::last_node(Node* nd) {
}
int SuperWord::mark_generations() {
Node *ii_err = 0, *tail_err;
Node *ii_err = NULL, *tail_err = NULL;
for (int i = 0; i < _mem_slice_head.length(); i++) {
Node* phi = _mem_slice_head.at(i);
assert(phi->is_Phi(), "must be phi");

4
hotspot/src/share/vm/prims/jvmtiEnter.xsl
View File

@ -629,8 +629,8 @@ static jvmtiError JNICALL
jint trace_flags = JvmtiTrace::trace_flags(</xsl:text>
<xsl:value-of select="@num"/>
<xsl:text>);
const char *func_name;
const char *curr_thread_name;
const char *func_name = NULL;
const char *curr_thread_name = NULL;
if (trace_flags) {
func_name = JvmtiTrace::function_name(</xsl:text>
<xsl:value-of select="@num"/>

10
hotspot/src/share/vm/prims/jvmtiEnv.cpp
View File

@ -3064,7 +3064,7 @@ JvmtiEnv::RawMonitorEnter(JvmtiRawMonitor * rmonitor) {
// in thread.cpp.
JvmtiPendingMonitors::enter(rmonitor);
} else {
int r;
int r = 0;
Thread* thread = Thread::current();
if (thread->is_Java_thread()) {
@ -3127,7 +3127,7 @@ JvmtiEnv::RawMonitorExit(JvmtiRawMonitor * rmonitor) {
err = JVMTI_ERROR_NOT_MONITOR_OWNER;
}
} else {
int r;
int r = 0;
Thread* thread = Thread::current();
if (thread->is_Java_thread()) {
@ -3161,7 +3161,7 @@ JvmtiEnv::RawMonitorExit(JvmtiRawMonitor * rmonitor) {
// rmonitor - pre-checked for validity
jvmtiError
JvmtiEnv::RawMonitorWait(JvmtiRawMonitor * rmonitor, jlong millis) {
int r;
int r = 0;
Thread* thread = Thread::current();
if (thread->is_Java_thread()) {
@ -3220,7 +3220,7 @@ JvmtiEnv::RawMonitorWait(JvmtiRawMonitor * rmonitor, jlong millis) {
// rmonitor - pre-checked for validity
jvmtiError
JvmtiEnv::RawMonitorNotify(JvmtiRawMonitor * rmonitor) {
int r;
int r = 0;
Thread* thread = Thread::current();
if (thread->is_Java_thread()) {
@ -3251,7 +3251,7 @@ JvmtiEnv::RawMonitorNotify(JvmtiRawMonitor * rmonitor) {
// rmonitor - pre-checked for validity
jvmtiError
JvmtiEnv::RawMonitorNotifyAll(JvmtiRawMonitor * rmonitor) {
int r;
int r = 0;
Thread* thread = Thread::current();
if (thread->is_Java_thread()) {

4
hotspot/src/share/vm/prims/jvmtiEnvBase.cpp
View File

@ -512,7 +512,7 @@ JvmtiEnvBase::is_thread_fully_suspended(JavaThread* thr, bool wait_for_suspend,
// mean much better out of memory handling
unsigned char *
JvmtiEnvBase::jvmtiMalloc(jlong size) {
unsigned char* mem;
unsigned char* mem = NULL;
jvmtiError result = allocate(size, &mem);
assert(result == JVMTI_ERROR_NONE, "Allocate failed");
return mem;
@ -1032,7 +1032,7 @@ JvmtiEnvBase::get_object_monitor_usage(JavaThread* calling_thread, jobject objec
// implied else: entry_count == 0
}
jint nWant, nWait;
jint nWant = 0, nWait = 0;
if (mon != NULL) {
// this object has a heavyweight monitor
nWant = mon->contentions(); // # of threads contending for monitor

2
hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp
View File

@ -336,7 +336,7 @@ void VM_RedefineClasses::append_entry(const constantPoolHandle& scratch_cp,
int new_name_and_type_ref_i = find_or_append_indirect_entry(scratch_cp, name_and_type_ref_i,
merge_cp_p, merge_cp_length_p, THREAD);
const char *entry_name;
const char *entry_name = NULL;
switch (scratch_cp->tag_at(scratch_i).value()) {
case JVM_CONSTANT_Fieldref:
entry_name = "Fieldref";

4
hotspot/src/share/vm/prims/unsafe.cpp
View File

@ -783,7 +783,7 @@ static void getBaseAndScale(int& base, int& scale, jclass acls, TRAPS) {
UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset(JNIEnv *env, jobject unsafe, jclass acls))
UnsafeWrapper("Unsafe_ArrayBaseOffset");
int base, scale;
int base = 0, scale = 0;
getBaseAndScale(base, scale, acls, CHECK_0);
return field_offset_from_byte_offset(base);
UNSAFE_END
@ -791,7 +791,7 @@ UNSAFE_END
UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale(JNIEnv *env, jobject unsafe, jclass acls))
UnsafeWrapper("Unsafe_ArrayIndexScale");
int base, scale;
int base = 0, scale = 0;
getBaseAndScale(base, scale, acls, CHECK_0);
// This VM packs both fields and array elements down to the byte.
// But watch out: If this changes, so that array references for

25
hotspot/src/share/vm/runtime/arguments.cpp
View File

@ -1120,7 +1120,7 @@ bool Arguments::process_argument(const char* arg,
Flag::Flags origin) {
JDK_Version since = JDK_Version();
if (parse_argument(arg, origin) || ignore_unrecognized) {
if (parse_argument(arg, origin)) {
return true;
}
@ -1156,7 +1156,7 @@ bool Arguments::process_argument(const char* arg,
Flag* found_flag = Flag::find_flag((const char*)argname, arg_len, true, true);
if (found_flag != NULL) {
char locked_message_buf[BUFLEN];
found_flag->get_locked_message(locked_message_buf, BUFLEN);
Flag::MsgType msg_type = found_flag->get_locked_message(locked_message_buf, BUFLEN);
if (strlen(locked_message_buf) == 0) {
if (found_flag->is_bool() && !has_plus_minus) {
jio_fprintf(defaultStream::error_stream(),
@ -1169,9 +1169,19 @@ bool Arguments::process_argument(const char* arg,
"Improperly specified VM option '%s'\n", argname);
}
} else {
#ifdef PRODUCT
bool mismatched = ((msg_type == Flag::NOTPRODUCT_FLAG_BUT_PRODUCT_BUILD) ||
(msg_type == Flag::DEVELOPER_FLAG_BUT_PRODUCT_BUILD));
if (ignore_unrecognized && mismatched) {
return true;
}
#endif
jio_fprintf(defaultStream::error_stream(), "%s", locked_message_buf);
}
} else {
if (ignore_unrecognized) {
return true;
}
jio_fprintf(defaultStream::error_stream(),
"Unrecognized VM option '%s'\n", argname);
Flag* fuzzy_matched = Flag::fuzzy_match((const char*)argname, arg_len, true);
@ -2469,16 +2479,6 @@ bool Arguments::check_vm_args_consistency() {
}
}
// Note: only executed in non-PRODUCT mode
if (!UseAsyncConcMarkSweepGC &&
(ExplicitGCInvokesConcurrent ||
ExplicitGCInvokesConcurrentAndUnloadsClasses)) {
jio_fprintf(defaultStream::error_stream(),
"error: +ExplicitGCInvokesConcurrent[AndUnloadsClasses] conflicts"
" with -UseAsyncConcMarkSweepGC");
status = false;
}
if (PrintNMTStatistics) {
#if INCLUDE_NMT
if (MemTracker::tracking_level() == NMT_off) {
@ -3858,6 +3858,7 @@ jint Arguments::parse_options_buffer(const char* name, char* buffer, const size_
JavaVMOption option;
option.optionString = opt_hd;
option.extraInfo = NULL;
options->append(option); // Fill in option

15
hotspot/src/share/vm/runtime/globals.cpp
View File

@ -306,35 +306,36 @@ void Flag::unlock_diagnostic() {
_flags = Flags(_flags & ~KIND_DIAGNOSTIC);
}
// Get custom message for this locked flag, or return NULL if
// none is available.
void Flag::get_locked_message(char* buf, int buflen) const {
// Get custom message for this locked flag, or NULL if
// none is available. Returns message type produced.
Flag::MsgType Flag::get_locked_message(char* buf, int buflen) const {
buf[0] = '\0';
if (is_diagnostic() && !is_unlocked()) {
jio_snprintf(buf, buflen,
"Error: VM option '%s' is diagnostic and must be enabled via -XX:+UnlockDiagnosticVMOptions.\n"
"Error: The unlock option must precede '%s'.\n",
_name, _name);
return;
return Flag::DIAGNOSTIC_FLAG_BUT_LOCKED;
}
if (is_experimental() && !is_unlocked()) {
jio_snprintf(buf, buflen,
"Error: VM option '%s' is experimental and must be enabled via -XX:+UnlockExperimentalVMOptions.\n"
"Error: The unlock option must precede '%s'.\n",
_name, _name);
return;
return Flag::EXPERIMENTAL_FLAG_BUT_LOCKED;
}
if (is_develop() && is_product_build()) {
jio_snprintf(buf, buflen, "Error: VM option '%s' is develop and is available only in debug version of VM.\n",
_name);
return;
return Flag::DEVELOPER_FLAG_BUT_PRODUCT_BUILD;
}
if (is_notproduct() && is_product_build()) {
jio_snprintf(buf, buflen, "Error: VM option '%s' is notproduct and is available only in debug version of VM.\n",
_name);
return;
return Flag::NOTPRODUCT_FLAG_BUT_PRODUCT_BUILD;
}
get_locked_message_ext(buf, buflen);
return Flag::NONE;
}
bool Flag::is_writeable() const {

27
hotspot/src/share/vm/runtime/globals.hpp
View File

@ -282,6 +282,14 @@ struct Flag {
ERR_OTHER
};
enum MsgType {
NONE = 0,
DIAGNOSTIC_FLAG_BUT_LOCKED,
EXPERIMENTAL_FLAG_BUT_LOCKED,
DEVELOPER_FLAG_BUT_PRODUCT_BUILD,
NOTPRODUCT_FLAG_BUT_PRODUCT_BUILD
};
const char* _type;
const char* _name;
void* _addr;
@ -367,7 +375,7 @@ struct Flag {
void unlock_diagnostic();
void get_locked_message(char*, int) const;
Flag::MsgType get_locked_message(char*, int) const;
void get_locked_message_ext(char*, int) const;
// printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges
@ -1622,12 +1630,6 @@ public:
"Number of times to retry allocations when " \
"blocked by the GC locker") \
\
develop(bool, UseCMSAdaptiveFreeLists, true, \
"Use adaptive free lists in the CMS generation") \
\
develop(bool, UseAsyncConcMarkSweepGC, true, \
"Use Asynchronous Concurrent Mark-Sweep GC in the old generation")\
\
product(bool, UseCMSBestFit, true, \
"Use CMS best fit allocation strategy") \
\
@ -1822,10 +1824,6 @@ public:
"When CMS class unloading is enabled, the maximum CMS cycle " \
"count for which classes may not be unloaded") \
\
develop(intx, CMSDictionaryChoice, 0, \
"Use BinaryTreeDictionary as default in the CMS generation") \
range(0, 2) \
\
product(uintx, CMSIndexedFreeListReplenish, 4, \
"Replenish an indexed free list with this number of chunks") \
range(1, max_uintx) \
@ -1840,9 +1838,6 @@ public:
product(bool, CMSLoopWarn, false, \
"Warn in case of excessive CMS looping") \
\
develop(bool, CMSOverflowEarlyRestoration, false, \
"Restore preserved marks early") \
\
/* where does the range max value of (max_jint - 1) come from? */ \
product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
"Maximum size of marking stack") \
@ -2080,10 +2075,6 @@ public:
"unloading of classes when class unloading is enabled") \
range(0, 100) \
\
develop(bool, CMSTestInFreeList, false, \
"Check if the coalesced range is already in the " \
"free lists as claimed") \
\
notproduct(bool, CMSVerifyReturnedBytes, false, \
"Check that all the garbage collected was returned to the " \
"free lists") \

4
hotspot/src/share/vm/runtime/safepoint.cpp
View File

@ -122,7 +122,7 @@ void SafepointSynchronize::begin() {
// Save the starting time, so that it can be compared to see if this has taken
// too long to complete.
jlong safepoint_limit_time;
jlong safepoint_limit_time = 0;
timeout_error_printed = false;
// PrintSafepointStatisticsTimeout can be specified separately. When
@ -901,7 +901,7 @@ void ThreadSafepointState::restart() {
void ThreadSafepointState::print_on(outputStream *st) const {
const char *s;
const char *s = NULL;
switch(_type) {
case _running : s = "_running"; break;

8
hotspot/src/share/vm/services/threadService.hpp
View File

@ -425,12 +425,12 @@ class JavaThreadStatusChanger : public StackObj {
}
JavaThreadStatusChanger(JavaThread* java_thread,
java_lang_Thread::ThreadStatus state) {
java_lang_Thread::ThreadStatus state) : _old_state(java_lang_Thread::NEW) {
save_old_state(java_thread);
set_thread_status(state);
}
JavaThreadStatusChanger(JavaThread* java_thread) {
JavaThreadStatusChanger(JavaThread* java_thread) : _old_state(java_lang_Thread::NEW) {
save_old_state(java_thread);
}
@ -527,7 +527,7 @@ class JavaThreadBlockedOnMonitorEnterState : public JavaThreadStatusChanger {
// Current thread is the notifying thread which holds the monitor.
static bool wait_reenter_begin(JavaThread *java_thread, ObjectMonitor *obj_m) {
assert((java_thread != NULL), "Java thread should not be null here");
bool active = false;
bool active = false;
if (is_alive(java_thread) && ServiceUtil::visible_oop((oop)obj_m->object())) {
active = contended_enter_begin(java_thread);
}
@ -542,7 +542,7 @@ class JavaThreadBlockedOnMonitorEnterState : public JavaThreadStatusChanger {
}
JavaThreadBlockedOnMonitorEnterState(JavaThread *java_thread, ObjectMonitor *obj_m) :
JavaThreadStatusChanger(java_thread) {
_stat(NULL), _active(false), JavaThreadStatusChanger(java_thread) {
assert((java_thread != NULL), "Java thread should not be null here");
// Change thread status and collect contended enter stats for monitor contended
// enter done for external java world objects and it is contended. All other cases

3
hotspot/test/Makefile
View File

@ -243,6 +243,9 @@ hotspot_%:
$(ECHO) "Running tests: $@"
$(MAKE) -j 1 TEST_SELECTION=":$@" UNIQUE_DIR=$@ jtreg_tests;
hotspot_internal:
$(ALT_OUTPUTDIR)/jdk/bin/java -XX:+ExecuteInternalVMTests -XX:+ShowMessageBoxOnError -version
# Prep for output
prep: clean
@$(MKDIR) -p $(ABS_TEST_OUTPUT_DIR)

1
hotspot/test/compiler/jvmci/compilerToVM/GetConstantPoolTest.java
View File

@ -27,6 +27,7 @@
* @bug 8136421
* @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9") & os.arch != "aarch64"
* @library /testlibrary /../../test/lib /
* @ignore 8139385
* @compile ../common/CompilerToVMHelper.java
* @build sun.hotspot.WhiteBox
* compiler.jvmci.compilerToVM.GetConstantPoolTest

6
hotspot/test/compiler/membars/DekkerTest.java
View File

@ -25,9 +25,9 @@
* @test
* @bug 8007898
* @summary Incorrect optimization of Memory Barriers in Matcher::post_store_load_barrier().
* @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:CICompilerCount=1 -XX:-TieredCompilation -XX:+StressGCM -XX:+StressLCM DekkerTest
* @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:CICompilerCount=1 -XX:-TieredCompilation -XX:+StressGCM -XX:+StressLCM DekkerTest
* @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:CICompilerCount=1 -XX:-TieredCompilation -XX:+StressGCM -XX:+StressLCM DekkerTest
* @run main/othervm -Xbatch -XX:-TieredCompilation -XX:CICompilerCount=1 -XX:+StressGCM -XX:+StressLCM DekkerTest
* @run main/othervm -Xbatch -XX:-TieredCompilation -XX:CICompilerCount=1 -XX:+StressGCM -XX:+StressLCM DekkerTest
* @run main/othervm -Xbatch -XX:-TieredCompilation -XX:CICompilerCount=1 -XX:+StressGCM -XX:+StressLCM DekkerTest
* @author Martin Doerr martin DOT doerr AT sap DOT com
*
* Run 3 times since the failure is intermittent.

177
hotspot/test/runtime/CommandLine/IgnoreUnrecognizedVMOptions.java Normal file
View File

@ -0,0 +1,177 @@
/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import jdk.test.lib.*;
/*
* @test
* @bug 8129855
* @summary -XX:+IgnoreUnrecognizedVMOptions should work according to the spec from JDK-8129855
*
* @library /testlibrary
* @modules java.base/sun.misc
* java.management
* @run main IgnoreUnrecognizedVMOptions
*/
public class IgnoreUnrecognizedVMOptions {
private static void runJavaAndCheckExitValue(boolean shouldSucceed, String... args) throws Exception {
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(args);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
if (shouldSucceed) {
output.shouldHaveExitValue(0);
} else {
output.shouldHaveExitValue(1);
}
}
public static void main(String[] args) throws Exception {
boolean product = !Platform.isDebugBuild();
/*
#1.1 wrong value and non-existing flag:
exists, invalid value does not exist
-XX:MinHeapFreeRatio=notnum -XX:THIS_FLAG_DOESNT_EXIST
-IgnoreUnrecognizedVMOptions ERR ERR
+IgnoreUnrecognizedVMOptions ERR OK
*/
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:MinHeapFreeRatio=notnum", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:THIS_FLAG_DOESNT_EXIST", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:MinHeapFreeRatio=notnum", "-version");
runJavaAndCheckExitValue(true, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:THIS_FLAG_DOESNT_EXIST", "-version");
/*
#1.2 normal flag with ranges:
exists, in range exists, out of range
-XX:StackRedPages=1 -XX:StackRedPages=0
-IgnoreUnrecognizedVMOptions OK ERR
+IgnoreUnrecognizedVMOptions OK ERR
*/
runJavaAndCheckExitValue(true, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:StackRedPages=1", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:StackRedPages=0", "-version");
runJavaAndCheckExitValue(true, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:StackRedPages=1", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:StackRedPages=0", "-version");
/*
#1.3 develop & notproduct flag on debug VM:
develop & !product_build notproduct & !product_build
-XX:+DeoptimizeALot -XX:+VerifyCodeCache
-IgnoreUnrecognizedVMOptions OK OK
+IgnoreUnrecognizedVMOptions OK OK
*/
if (!product) {
runJavaAndCheckExitValue(true, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:+DeoptimizeALot", "-version");
runJavaAndCheckExitValue(true, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:+VerifyCodeCache", "-version");
runJavaAndCheckExitValue(true, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:+DeoptimizeALot", "-version");
runJavaAndCheckExitValue(true, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:+VerifyCodeCache", "-version");
}
/*
#1.4 develop & notproduct flag on product VM:
develop & !product_build notproduct & !product_build
-XX:+DeoptimizeALot -XX:+VerifyCodeCache
-IgnoreUnrecognizedVMOptions ERR ERR
+IgnoreUnrecognizedVMOptions OK OK
*/
if (product) {
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:+DeoptimizeALot", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:+VerifyCodeCache", "-version");
runJavaAndCheckExitValue(true, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:+DeoptimizeALot", "-version");
runJavaAndCheckExitValue(true, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:+VerifyCodeCache", "-version");
}
/*
#1.5 malformed develop & notproduct flag on debug VM:
develop & !product_build notproduct & !product_build
-XX:DeoptimizeALot -XX:VerifyCodeCache
-IgnoreUnrecognizedVMOptions ERR ERR
+IgnoreUnrecognizedVMOptions ERR ERR
*/
if (!product) {
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:DeoptimizeALot", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:VerifyCodeCache", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:DeoptimizeALot", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:VerifyCodeCache", "-version");
}
/*
#1.6 malformed develop & notproduct flag on product VM:
develop & !product_build .notproduct & !product_build
-XX:DeoptimizeALot -XX:VerifyCodeCache
-IgnoreUnrecognizedVMOptions ERR ERR
+IgnoreUnrecognizedVMOptions OK OK
*/
if (product) {
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:DeoptimizeALot", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:VerifyCodeCache", "-version");
runJavaAndCheckExitValue(true, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:DeoptimizeALot", "-version");
runJavaAndCheckExitValue(true, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:VerifyCodeCache", "-version");
}
/*
#1.7 locked flag:
diagnostic & locked experimental & locked commercial & locked
-XX:-UnlockDiagnosticVMOptions -XX:-UnlockExperimentalVMOptions -XX:-UnlockCommercialFeatures
-XX:+PrintInlining -XX:+AlwaysSafeConstructors -XX:+FlightRecorder
-IgnoreUnrecognizedVMOptions ERR ERR ERR
+IgnoreUnrecognizedVMOptions ERR ERR ERR
*/
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:-UnlockDiagnosticVMOptions", "-XX:+PrintInlining", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:-UnlockExperimentalVMOptions", "-XX:+AlwaysSafeConstructors", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:-UnlockCommercialFeatures", "-XX:+FlightRecorder", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:-UnlockDiagnosticVMOptions", "-XX:+PrintInlining", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:-UnlockExperimentalVMOptions", "-XX:+AlwaysSafeConstructors", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:-UnlockCommercialFeatures", "-XX:+FlightRecorder", "-version");
/*
#1.8 malformed locked flag:
diagnostic & locked experimental & locked commercial & locked
-XX:-UnlockDiagnosticVMOptions -XX:-UnlockExperimentalVMOptions -XX:-UnlockCommercialFeatures
-XX:PrintInlining -XX:AlwaysSafeConstructors -XX:FlightRecorder
-IgnoreUnrecognizedVMOptions ERR ERR ERR
+IgnoreUnrecognizedVMOptions ERR ERR ERR
*/
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:-UnlockDiagnosticVMOptions", "-XX:PrintInlining", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:-UnlockExperimentalVMOptions", "-XX:AlwaysSafeConstructors", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:-UnlockCommercialFeatures", "-XX:FlightRecorder", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:-UnlockDiagnosticVMOptions", "-XX:PrintInlining", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:-UnlockExperimentalVMOptions", "-XX:AlwaysSafeConstructors", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:-UnlockCommercialFeatures", "-XX:FlightRecorder", "-version");
/*
#1.9 malformed unlocked flag:
diagnostic & locked experimental & locked commercial & locked
-XX:+UnlockDiagnosticVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UnlockCommercialFeatures
-XX:PrintInlining -XX:AlwaysSafeConstructors -XX:FlightRecorder
-IgnoreUnrecognizedVMOptions ERR ERR ERR
+IgnoreUnrecognizedVMOptions ERR ERR ERR
*/
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:-UnlockDiagnosticVMOptions", "-XX:PrintInlining", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:-UnlockExperimentalVMOptions", "-XX:AlwaysSafeConstructors", "-version");
runJavaAndCheckExitValue(false, "-XX:-IgnoreUnrecognizedVMOptions", "-XX:-UnlockCommercialFeatures", "-XX:FlightRecorder", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:-UnlockDiagnosticVMOptions", "-XX:PrintInlining", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:-UnlockExperimentalVMOptions", "-XX:AlwaysSafeConstructors", "-version");
runJavaAndCheckExitValue(false, "-XX:+IgnoreUnrecognizedVMOptions", "-XX:-UnlockCommercialFeatures", "-XX:FlightRecorder", "-version");
}
}