Mercurial > hg > graal-compiler
changeset 981:1af62b6ca0f9
Merge
| author | apetrusenko |
|---|---|
| date | Fri, 25 Sep 2009 04:39:54 -0700 |
| parents | 87770dcf831b (diff) c3c4a1d3801a (current diff) |
| children | 7a102acc9f17 46b819ba120b a0107ba3bc53 054afbef9081 |
| files | |
| diffstat | 38 files changed, 360 insertions(+), 110 deletions(-) [+] |
line wrap: on
line diff
--- a/make/linux/makefiles/jvmti.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/linux/makefiles/jvmti.make Fri Sep 25 04:39:54 2009 -0700 @@ -70,10 +70,10 @@ both = $(JvmtiGenClass) $(JvmtiSrcDir)/jvmti.xml $(JvmtiSrcDir)/jvmtiLib.xsl $(JvmtiGenClass): $(JvmtiGenSource) - $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -g -d $(JvmtiOutDir) $(JvmtiGenSource) + $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -d $(JvmtiOutDir) $(JvmtiGenSource) $(JvmtiEnvFillClass): $(JvmtiEnvFillSource) - $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -g -d $(JvmtiOutDir) $(JvmtiEnvFillSource) + $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -d $(JvmtiOutDir) $(JvmtiEnvFillSource) $(JvmtiOutDir)/jvmtiEnter.cpp: $(both) $(JvmtiSrcDir)/jvmtiEnter.xsl @echo Generating $@
--- a/make/linux/makefiles/mapfile-vers-debug Wed Sep 23 11:36:06 2009 -0700 +++ b/make/linux/makefiles/mapfile-vers-debug Fri Sep 25 04:39:54 2009 -0700 @@ -74,6 +74,7 @@ JVM_CurrentTimeMillis; JVM_DefineClass; JVM_DefineClassWithSource; + JVM_DefineClassWithSourceCond; JVM_DesiredAssertionStatus; JVM_DisableCompiler; JVM_DoPrivileged;
--- a/make/linux/makefiles/mapfile-vers-product Wed Sep 23 11:36:06 2009 -0700 +++ b/make/linux/makefiles/mapfile-vers-product Fri Sep 25 04:39:54 2009 -0700 @@ -74,6 +74,7 @@ JVM_CurrentTimeMillis; JVM_DefineClass; JVM_DefineClassWithSource; + JVM_DefineClassWithSourceCond; JVM_DesiredAssertionStatus; JVM_DisableCompiler; JVM_DoPrivileged;
--- a/make/linux/makefiles/rules.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/linux/makefiles/rules.make Fri Sep 25 04:39:54 2009 -0700 @@ -122,12 +122,20 @@ endif endif +COMPILE.JAVAC += $(BOOTSTRAP_JAVAC_FLAGS) + SUM = /usr/bin/sum # 'gmake MAKE_VERBOSE=y' gives all the gory details. QUIETLY$(MAKE_VERBOSE) = @ RUN.JAR$(MAKE_VERBOSE) += >/dev/null +# Settings for javac +BOOT_SOURCE_LANGUAGE_VERSION = 6 +BOOT_TARGET_CLASS_VERSION = 6 +JAVAC_FLAGS = -g -encoding ascii +BOOTSTRAP_JAVAC_FLAGS = $(JAVAC_FLAGS) -source $(BOOT_SOURCE_LANGUAGE_VERSION) -target $(BOOT_TARGET_CLASS_VERSION) + # With parallel makes, print a message at the end of compilation. ifeq ($(findstring j,$(MFLAGS)),j) COMPILE_DONE = && { echo Done with $<; }
--- a/make/linux/makefiles/sa.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/linux/makefiles/sa.make Fri Sep 25 04:39:54 2009 -0700 @@ -74,8 +74,8 @@ mkdir -p $(SA_CLASSDIR); \ fi - $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES1) - $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES2) + $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES1) + $(QUIETLY) $(REMOTE) $(COMPILE.JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES2) $(QUIETLY) $(REMOTE) $(COMPILE.RMIC) -classpath $(SA_CLASSDIR) -d $(SA_CLASSDIR) sun.jvm.hotspot.debugger.remote.RemoteDebuggerServer $(QUIETLY) echo "$(SA_BUILD_VERSION_PROP)" > $(SA_PROPERTIES)
--- a/make/linux/makefiles/top.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/linux/makefiles/top.make Fri Sep 25 04:39:54 2009 -0700 @@ -24,7 +24,7 @@ # top.make is included in the Makefile in the build directories. # It DOES NOT include the vm dependency info in order to be faster. -# It's main job is to implement the incremental form of make lists. +# Its main job is to implement the incremental form of make lists. # It also: # -builds and runs adlc via adlc.make # -generates JVMTI source and docs via jvmti.make (JSR-163) @@ -114,7 +114,7 @@ # make makeDeps: (and zap the cached db files to force a nonincremental run) $(GENERATED)/$(MakeDepsClass): $(MakeDepsSources) - @$(REMOTE) $(COMPILE.JAVAC) -classpath $(GAMMADIR)/src/share/tools/MakeDeps -g -d $(GENERATED) $(MakeDepsSources) + @$(REMOTE) $(COMPILE.JAVAC) -classpath $(GAMMADIR)/src/share/tools/MakeDeps -d $(GENERATED) $(MakeDepsSources) @echo Removing $(Incremental_Lists) to force regeneration. @rm -f $(Incremental_Lists) @$(CDG) echo >$(Cached_plat)
--- a/make/solaris/makefiles/jvmti.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/solaris/makefiles/jvmti.make Fri Sep 25 04:39:54 2009 -0700 @@ -69,10 +69,10 @@ both = $(JvmtiGenClass) $(JvmtiSrcDir)/jvmti.xml $(JvmtiSrcDir)/jvmtiLib.xsl $(JvmtiGenClass): $(JvmtiGenSource) - $(QUIETLY) $(COMPILE.JAVAC) -g -d $(JvmtiOutDir) $(JvmtiGenSource) + $(QUIETLY) $(COMPILE.JAVAC) -d $(JvmtiOutDir) $(JvmtiGenSource) $(JvmtiEnvFillClass): $(JvmtiEnvFillSource) - $(QUIETLY) $(COMPILE.JAVAC) -g -d $(JvmtiOutDir) $(JvmtiEnvFillSource) + $(QUIETLY) $(COMPILE.JAVAC) -d $(JvmtiOutDir) $(JvmtiEnvFillSource) $(JvmtiOutDir)/jvmtiEnter.cpp: $(both) $(JvmtiSrcDir)/jvmtiEnter.xsl @echo Generating $@
--- a/make/solaris/makefiles/mapfile-vers Wed Sep 23 11:36:06 2009 -0700 +++ b/make/solaris/makefiles/mapfile-vers Fri Sep 25 04:39:54 2009 -0700 @@ -74,6 +74,7 @@ JVM_CurrentTimeMillis; JVM_DefineClass; JVM_DefineClassWithSource; + JVM_DefineClassWithSourceCond; JVM_DesiredAssertionStatus; JVM_DisableCompiler; JVM_DoPrivileged;
--- a/make/solaris/makefiles/rules.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/solaris/makefiles/rules.make Fri Sep 25 04:39:54 2009 -0700 @@ -122,12 +122,20 @@ endif endif +COMPILE.JAVAC += $(BOOTSTRAP_JAVAC_FLAGS) + SUM = /usr/bin/sum # 'gmake MAKE_VERBOSE=y' gives all the gory details. QUIETLY$(MAKE_VERBOSE) = @ RUN.JAR$(MAKE_VERBOSE) += >/dev/null +# Settings for javac +BOOT_SOURCE_LANGUAGE_VERSION = 6 +BOOT_TARGET_CLASS_VERSION = 6 +JAVAC_FLAGS = -g -encoding ascii +BOOTSTRAP_JAVAC_FLAGS = $(JAVAC_FLAGS) -source $(BOOT_SOURCE_LANGUAGE_VERSION) -target $(BOOT_TARGET_CLASS_VERSION) + # With parallel makes, print a message at the end of compilation. ifeq ($(findstring j,$(MFLAGS)),j) COMPILE_DONE = && { echo Done with $<; }
--- a/make/solaris/makefiles/sa.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/solaris/makefiles/sa.make Fri Sep 25 04:39:54 2009 -0700 @@ -67,8 +67,8 @@ $(QUIETLY) if [ ! -d $(SA_CLASSDIR) ] ; then \ mkdir -p $(SA_CLASSDIR); \ fi - $(QUIETLY) $(COMPILE.JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES1) - $(QUIETLY) $(COMPILE.JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES2) + $(QUIETLY) $(COMPILE.JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES1) + $(QUIETLY) $(COMPILE.JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES2) $(QUIETLY) $(COMPILE.RMIC) -classpath $(SA_CLASSDIR) -d $(SA_CLASSDIR) sun.jvm.hotspot.debugger.remote.RemoteDebuggerServer $(QUIETLY) echo "$(SA_BUILD_VERSION_PROP)" > $(SA_PROPERTIES)
--- a/make/solaris/makefiles/top.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/solaris/makefiles/top.make Fri Sep 25 04:39:54 2009 -0700 @@ -24,7 +24,7 @@ # top.make is included in the Makefile in the build directories. # It DOES NOT include the vm dependency info in order to be faster. -# It's main job is to implement the incremental form of make lists. +# Its main job is to implement the incremental form of make lists. # It also: # -builds and runs adlc via adlc.make # -generates JVMTI source and docs via jvmti.make (JSR-163) @@ -112,7 +112,7 @@ # make makeDeps: (and zap the cached db files to force a nonincremental run) $(GENERATED)/$(MakeDepsClass): $(MakeDepsSources) - @$(COMPILE.JAVAC) -classpath $(GAMMADIR)/src/share/tools/MakeDeps -g -d $(GENERATED) $(MakeDepsSources) + @$(COMPILE.JAVAC) -classpath $(GAMMADIR)/src/share/tools/MakeDeps -d $(GENERATED) $(MakeDepsSources) @echo Removing $(Incremental_Lists) to force regeneration. @rm -f $(Incremental_Lists) @$(CDG) echo >$(Cached_plat)
--- a/make/windows/makefiles/generated.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/windows/makefiles/generated.make Fri Sep 25 04:39:54 2009 -0700 @@ -91,7 +91,7 @@ classes/MakeDeps.class: $(MakeDepsSources) if exist classes rmdir /s /q classes mkdir classes - $(COMPILE_JAVAC) -classpath $(WorkSpace)\src\share\tools\MakeDeps -g -d classes $(MakeDepsSources) + $(COMPILE_JAVAC) -classpath $(WorkSpace)\src\share\tools\MakeDeps -d classes $(MakeDepsSources) !if ("$(Variant)" == "compiler2") || ("$(Variant)" == "tiered")
--- a/make/windows/makefiles/jvmti.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/windows/makefiles/jvmti.make Fri Sep 25 04:39:54 2009 -0700 @@ -68,10 +68,10 @@ @if not exist $(JvmtiOutDir) mkdir $(JvmtiOutDir) $(JvmtiGenClass): $(JvmtiGenSource) - $(COMPILE_JAVAC) -g -d $(JvmtiOutDir) $(JvmtiGenSource) + $(COMPILE_JAVAC) -d $(JvmtiOutDir) $(JvmtiGenSource) $(JvmtiEnvFillClass): $(JvmtiEnvFillSource) - @$(COMPILE_JAVAC) -g -d $(JvmtiOutDir) $(JvmtiEnvFillSource) + @$(COMPILE_JAVAC) -d $(JvmtiOutDir) $(JvmtiEnvFillSource) $(JvmtiOutDir)/jvmtiEnter.cpp: $(both) $(JvmtiSrcDir)/jvmtiEnter.xsl @echo Generating $@
--- a/make/windows/makefiles/rules.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/windows/makefiles/rules.make Fri Sep 25 04:39:54 2009 -0700 @@ -29,7 +29,7 @@ RUN_JAVAP=$(BootStrapDir)\bin\javap RUN_JAVAH=$(BootStrapDir)\bin\javah RUN_JAR=$(BootStrapDir)\bin\jar -COMPILE_JAVAC=$(BootStrapDir)\bin\javac +COMPILE_JAVAC=$(BootStrapDir)\bin\javac $(BOOTSTRAP_JAVAC_FLAGS) COMPILE_RMIC=$(BootStrapDir)\bin\rmic BOOT_JAVA_HOME=$(BootStrapDir) !else @@ -37,11 +37,17 @@ RUN_JAVAP=javap RUN_JAVAH=javah RUN_JAR=jar -COMPILE_JAVAC=javac +COMPILE_JAVAC=javac $(BOOTSTRAP_JAVAC_FLAGS) COMPILE_RMIC=rmic BOOT_JAVA_HOME= !endif +# Settings for javac +BOOT_SOURCE_LANGUAGE_VERSION=6 +BOOT_TARGET_CLASS_VERSION=6 +JAVAC_FLAGS=-g -encoding ascii +BOOTSTRAP_JAVAC_FLAGS=$(JAVAC_FLAGS) -source $(BOOT_SOURCE_LANGUAGE_VERSION) -target $(BOOT_TARGET_CLASS_VERSION) + ProjectFile=vm.vcproj !if "$(MSC_VER)" == "1200"
--- a/make/windows/makefiles/sa.make Wed Sep 23 11:36:06 2009 -0700 +++ b/make/windows/makefiles/sa.make Fri Sep 25 04:39:54 2009 -0700 @@ -55,9 +55,9 @@ $(GENERATED)\sa-jdi.jar: $(AGENT_FILES1:/=\) $(AGENT_FILES2:/=\) @if not exist $(SA_CLASSDIR) mkdir $(SA_CLASSDIR) @echo ...Building sa-jdi.jar - @echo ...$(COMPILE_JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -g -d $(SA_CLASSDIR) .... - @$(COMPILE_JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES1:/=\) - @$(COMPILE_JAVAC) -source 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -g -d $(SA_CLASSDIR) $(AGENT_FILES2:/=\) + @echo ...$(COMPILE_JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -d $(SA_CLASSDIR) .... + @$(COMPILE_JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES1:/=\) + @$(COMPILE_JAVAC) -source 1.4 -target 1.4 -classpath $(SA_CLASSPATH) -sourcepath $(AGENT_SRC_DIR) -d $(SA_CLASSDIR) $(AGENT_FILES2:/=\) $(COMPILE_RMIC) -classpath $(SA_CLASSDIR) -d $(SA_CLASSDIR) sun.jvm.hotspot.debugger.remote.RemoteDebuggerServer $(QUIETLY) echo $(SA_BUILD_VERSION_PROP)> $(SA_PROPERTIES) $(QUIETLY) rm -f $(SA_CLASSDIR)/sun/jvm/hotspot/utilities/soql/sa.js
--- a/make/windows/projectfiles/common/Makefile Wed Sep 23 11:36:06 2009 -0700 +++ b/make/windows/projectfiles/common/Makefile Fri Sep 25 04:39:54 2009 -0700 @@ -179,6 +179,6 @@ $(HOTSPOTBUILDSPACE)/classes/MakeDeps.class: $(MakeDepsSources) @if exist $(HOTSPOTBUILDSPACE)\classes rmdir /s /q $(HOTSPOTBUILDSPACE)\classes @mkdir $(HOTSPOTBUILDSPACE)\classes - @$(COMPILE_JAVAC) -classpath $(HOTSPOTWORKSPACE)\src\share\tools\MakeDeps -g -d $(HOTSPOTBUILDSPACE)/classes $(MakeDepsSources) + @$(COMPILE_JAVAC) -classpath $(HOTSPOTWORKSPACE)\src\share\tools\MakeDeps -d $(HOTSPOTBUILDSPACE)/classes $(MakeDepsSources) FORCE:
--- a/src/cpu/sparc/vm/interp_masm_sparc.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/cpu/sparc/vm/interp_masm_sparc.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -1696,6 +1696,9 @@ void InterpreterMacroAssembler::record_klass_in_profile_helper( Register receiver, Register scratch, int start_row, Label& done) { + if (TypeProfileWidth == 0) + return; + int last_row = VirtualCallData::row_limit() - 1; assert(start_row <= last_row, "must be work left to do"); // Test this row for both the receiver and for null.
--- a/src/cpu/x86/vm/interp_masm_x86_32.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/cpu/x86/vm/interp_masm_x86_32.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -1262,6 +1262,9 @@ Register receiver, Register mdp, Register reg2, int start_row, Label& done) { + if (TypeProfileWidth == 0) + return; + int last_row = VirtualCallData::row_limit() - 1; assert(start_row <= last_row, "must be work left to do"); // Test this row for both the receiver and for null.
--- a/src/cpu/x86/vm/interp_masm_x86_64.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/cpu/x86/vm/interp_masm_x86_64.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -1272,6 +1272,9 @@ Register receiver, Register mdp, Register reg2, int start_row, Label& done) { + if (TypeProfileWidth == 0) + return; + int last_row = VirtualCallData::row_limit() - 1; assert(start_row <= last_row, "must be work left to do"); // Test this row for both the receiver and for null.
--- a/src/os/windows/vm/os_windows.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/os/windows/vm/os_windows.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -1526,7 +1526,8 @@ case 5000: st->print(" Windows 2000"); break; case 5001: st->print(" Windows XP"); break; case 5002: - case 6000: { + case 6000: + case 6001: { // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could // find out whether we are running on 64 bit processor or not. SYSTEM_INFO si; @@ -1549,13 +1550,27 @@ st->print(" Windows XP x64 Edition"); else st->print(" Windows Server 2003 family"); - } else { // os_vers == 6000 + } else if (os_vers == 6000) { if (osvi.wProductType == VER_NT_WORKSTATION) st->print(" Windows Vista"); else st->print(" Windows Server 2008"); if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) st->print(" , 64 bit"); + } else if (os_vers == 6001) { + if (osvi.wProductType == VER_NT_WORKSTATION) { + st->print(" Windows 7"); + } else { + // Unrecognized windows, print out its major and minor versions + st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion); + } + if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) + st->print(" , 64 bit"); + } else { // future os + // Unrecognized windows, print out its major and minor versions + st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion); + if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) + st->print(" , 64 bit"); } break; }
--- a/src/share/vm/adlc/archDesc.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/adlc/archDesc.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -1031,7 +1031,8 @@ //---------------------------addSUNcopyright------------------------------- // output SUN copyright info void ArchDesc::addSunCopyright(char* legal, int size, FILE *fp) { - fwrite(legal, size, 1, fp); + size_t count = fwrite(legal, 1, size, fp); + assert(count == (size_t) size, "copyright info truncated"); fprintf(fp,"\n"); fprintf(fp,"// Machine Generated File. Do Not Edit!\n"); fprintf(fp,"\n");
--- a/src/share/vm/classfile/classFileParser.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/classfile/classFileParser.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -2547,6 +2547,7 @@ KlassHandle host_klass, GrowableArray<Handle>* cp_patches, symbolHandle& parsed_name, + bool verify, TRAPS) { // So that JVMTI can cache class file in the state before retransformable agents // have modified it @@ -2591,7 +2592,7 @@ instanceKlassHandle nullHandle; // Figure out whether we can skip format checking (matching classic VM behavior) - _need_verify = Verifier::should_verify_for(class_loader()); + _need_verify = Verifier::should_verify_for(class_loader(), verify); // Set the verify flag in stream cfs->set_verify(_need_verify); @@ -3210,6 +3211,7 @@ // Fill in information already parsed this_klass->set_access_flags(access_flags); + this_klass->set_should_verify_class(verify); jint lh = Klass::instance_layout_helper(instance_size, false); this_klass->set_layout_helper(lh); assert(this_klass->oop_is_instance(), "layout is correct"); @@ -3229,6 +3231,12 @@ this_klass->set_has_final_method(); } this_klass->set_method_ordering(method_ordering()); + // The instanceKlass::_methods_jmethod_ids cache and the + // instanceKlass::_methods_cached_itable_indices cache are + // both managed on the assumption that the initial cache + // size is equal to the number of methods in the class. If + // that changes, then instanceKlass::idnum_can_increment() + // has to be changed accordingly. this_klass->set_initial_method_idnum(methods->length()); this_klass->set_name(cp->klass_name_at(this_class_index)); if (LinkWellKnownClasses || is_anonymous()) // I am well known to myself
--- a/src/share/vm/classfile/classFileParser.hpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/classfile/classFileParser.hpp Fri Sep 25 04:39:54 2009 -0700 @@ -260,9 +260,10 @@ Handle class_loader, Handle protection_domain, symbolHandle& parsed_name, + bool verify, TRAPS) { KlassHandle no_host_klass; - return parseClassFile(name, class_loader, protection_domain, no_host_klass, NULL, parsed_name, THREAD); + return parseClassFile(name, class_loader, protection_domain, no_host_klass, NULL, parsed_name, verify, THREAD); } instanceKlassHandle parseClassFile(symbolHandle name, Handle class_loader, @@ -270,6 +271,7 @@ KlassHandle host_klass, GrowableArray<Handle>* cp_patches, symbolHandle& parsed_name, + bool verify, TRAPS); // Verifier checks
--- a/src/share/vm/classfile/classLoader.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/classfile/classLoader.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -874,6 +874,7 @@ class_loader, protection_domain, parsed_name, + false, CHECK_(h)); // add to package table
--- a/src/share/vm/classfile/systemDictionary.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/classfile/systemDictionary.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -970,6 +970,7 @@ host_klass, cp_patches, parsed_name, + true, THREAD); @@ -1025,6 +1026,7 @@ Handle class_loader, Handle protection_domain, ClassFileStream* st, + bool verify, TRAPS) { // Classloaders that support parallelism, e.g. bootstrap classloader, @@ -1055,6 +1057,7 @@ class_loader, protection_domain, parsed_name, + verify, THREAD); const char* pkg = "java/";
--- a/src/share/vm/classfile/systemDictionary.hpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/classfile/systemDictionary.hpp Fri Sep 25 04:39:54 2009 -0700 @@ -259,7 +259,9 @@ TRAPS); // Resolve from stream (called by jni_DefineClass and JVM_DefineClass) - static klassOop resolve_from_stream(symbolHandle class_name, Handle class_loader, Handle protection_domain, ClassFileStream* st, TRAPS); + static klassOop resolve_from_stream(symbolHandle class_name, Handle class_loader, + Handle protection_domain, + ClassFileStream* st, bool verify, TRAPS); // Lookup an already loaded class. If not found NULL is returned. static klassOop find(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS);
--- a/src/share/vm/classfile/verifier.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/classfile/verifier.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -53,8 +53,8 @@ // Methods in Verifier -bool Verifier::should_verify_for(oop class_loader) { - return class_loader == NULL ? +bool Verifier::should_verify_for(oop class_loader, bool should_verify_class) { + return (class_loader == NULL || !should_verify_class) ? BytecodeVerificationLocal : BytecodeVerificationRemote; } @@ -68,7 +68,7 @@ return !need_verify; } -bool Verifier::verify(instanceKlassHandle klass, Verifier::Mode mode, TRAPS) { +bool Verifier::verify(instanceKlassHandle klass, Verifier::Mode mode, bool should_verify_class, TRAPS) { ResourceMark rm(THREAD); HandleMark hm; @@ -81,7 +81,7 @@ // If the class should be verified, first see if we can use the split // verifier. If not, or if verification fails and FailOverToOldVerifier // is set, then call the inference verifier. - if (is_eligible_for_verification(klass)) { + if (is_eligible_for_verification(klass, should_verify_class)) { if (TraceClassInitialization) { tty->print_cr("Start class verification for: %s", klassName); } @@ -141,12 +141,13 @@ } } -bool Verifier::is_eligible_for_verification(instanceKlassHandle klass) { +bool Verifier::is_eligible_for_verification(instanceKlassHandle klass, bool should_verify_class) { symbolOop name = klass->name(); klassOop refl_magic_klass = SystemDictionary::reflect_magic_klass(); - return (should_verify_for(klass->class_loader()) && + return (should_verify_for(klass->class_loader(), should_verify_class) && // return if the class is a bootstrapping class + // or defineClass specified not to verify by default (flags override passed arg) // We need to skip the following four for bootstraping name != vmSymbols::java_lang_Object() && name != vmSymbols::java_lang_Class() &&
--- a/src/share/vm/classfile/verifier.hpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/classfile/verifier.hpp Fri Sep 25 04:39:54 2009 -0700 @@ -34,16 +34,18 @@ * Otherwise, no exception is thrown and the return indicates the * error. */ - static bool verify(instanceKlassHandle klass, Mode mode, TRAPS); + static bool verify(instanceKlassHandle klass, Mode mode, bool should_verify_class, TRAPS); - // Return false if the class is loaded by the bootstrap loader. - static bool should_verify_for(oop class_loader); + // Return false if the class is loaded by the bootstrap loader, + // or if defineClass was called requesting skipping verification + // -Xverify:all/none override this value + static bool should_verify_for(oop class_loader, bool should_verify_class); // Relax certain verifier checks to enable some broken 1.1 apps to run on 1.2. static bool relax_verify_for(oop class_loader); private: - static bool is_eligible_for_verification(instanceKlassHandle klass); + static bool is_eligible_for_verification(instanceKlassHandle klass, bool should_verify_class); static symbolHandle inference_verify( instanceKlassHandle klass, char* msg, size_t msg_len, TRAPS); };
--- a/src/share/vm/oops/instanceKlass.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/oops/instanceKlass.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -110,7 +110,7 @@ // 1) Verify the bytecodes Verifier::Mode mode = throw_verifyerror ? Verifier::ThrowException : Verifier::NoException; - return Verifier::verify(this_oop, mode, CHECK_false); + return Verifier::verify(this_oop, mode, this_oop->should_verify_class(), CHECK_false); } @@ -967,33 +967,78 @@ // Lookup or create a jmethodID. -// This code can be called by the VM thread. For this reason it is critical that -// there are no blocking operations (safepoints) while the lock is held -- or a -// deadlock can occur. -jmethodID instanceKlass::jmethod_id_for_impl(instanceKlassHandle ik_h, methodHandle method_h) { +// This code is called by the VMThread and JavaThreads so the +// locking has to be done very carefully to avoid deadlocks +// and/or other cache consistency problems. +// +jmethodID instanceKlass::get_jmethod_id(instanceKlassHandle ik_h, methodHandle method_h) { size_t idnum = (size_t)method_h->method_idnum(); jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire(); size_t length = 0; jmethodID id = NULL; - // array length stored in first element, other elements offset by one - if (jmeths == NULL || // If there is no jmethodID array, - (length = (size_t)jmeths[0]) <= idnum || // or if it is too short, - (id = jmeths[idnum+1]) == NULL) { // or if this jmethodID isn't allocated + + // We use a double-check locking idiom here because this cache is + // performance sensitive. In the normal system, this cache only + // transitions from NULL to non-NULL which is safe because we use + // release_set_methods_jmethod_ids() to advertise the new cache. + // A partially constructed cache should never be seen by a racing + // thread. We also use release_store_ptr() to save a new jmethodID + // in the cache so a partially constructed jmethodID should never be + // seen either. Cache reads of existing jmethodIDs proceed without a + // lock, but cache writes of a new jmethodID requires uniqueness and + // creation of the cache itself requires no leaks so a lock is + // generally acquired in those two cases. + // + // If the RedefineClasses() API has been used, then this cache can + // grow and we'll have transitions from non-NULL to bigger non-NULL. + // Cache creation requires no leaks and we require safety between all + // cache accesses and freeing of the old cache so a lock is generally + // acquired when the RedefineClasses() API has been used. - // Do all the safepointing things (allocations) before grabbing the lock. - // These allocations will have to be freed if they are unused. + if (jmeths != NULL) { + // the cache already exists + if (!ik_h->idnum_can_increment()) { + // the cache can't grow so we can just get the current values + get_jmethod_id_length_value(jmeths, idnum, &length, &id); + } else { + // cache can grow so we have to be more careful + if (Threads::number_of_threads() == 0 || + SafepointSynchronize::is_at_safepoint()) { + // we're single threaded or at a safepoint - no locking needed + get_jmethod_id_length_value(jmeths, idnum, &length, &id); + } else { + MutexLocker ml(JmethodIdCreation_lock); + get_jmethod_id_length_value(jmeths, idnum, &length, &id); + } + } + } + // implied else: + // we need to allocate a cache so default length and id values are good - // Allocate a new array of methods. + if (jmeths == NULL || // no cache yet + length <= idnum || // cache is too short + id == NULL) { // cache doesn't contain entry + + // This function can be called by the VMThread so we have to do all + // things that might block on a safepoint before grabbing the lock. + // Otherwise, we can deadlock with the VMThread or have a cache + // consistency issue. These vars keep track of what we might have + // to free after the lock is dropped. + jmethodID to_dealloc_id = NULL; + jmethodID* to_dealloc_jmeths = NULL; + + // may not allocate new_jmeths or use it if we allocate it jmethodID* new_jmeths = NULL; if (length <= idnum) { - // A new array will be needed (unless some other thread beats us to it) + // allocate a new cache that might be used size_t size = MAX2(idnum+1, (size_t)ik_h->idnum_allocated_count()); new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1); memset(new_jmeths, 0, (size+1)*sizeof(jmethodID)); - new_jmeths[0] =(jmethodID)size; // array size held in the first element + // cache size is stored in element[0], other elements offset by one + new_jmeths[0] = (jmethodID)size; } - // Allocate a new method ID. + // allocate a new jmethodID that might be used jmethodID new_id = NULL; if (method_h->is_old() && !method_h->is_obsolete()) { // The method passed in is old (but not obsolete), we need to use the current version @@ -1007,63 +1052,111 @@ new_id = JNIHandles::make_jmethod_id(method_h); } - if (Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint()) { - // No need and unsafe to lock the JmethodIdCreation_lock at safepoint. - id = get_jmethod_id(ik_h, idnum, new_id, new_jmeths); + if (Threads::number_of_threads() == 0 || + SafepointSynchronize::is_at_safepoint()) { + // we're single threaded or at a safepoint - no locking needed + id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths, + &to_dealloc_id, &to_dealloc_jmeths); } else { MutexLocker ml(JmethodIdCreation_lock); - id = get_jmethod_id(ik_h, idnum, new_id, new_jmeths); + id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths, + &to_dealloc_id, &to_dealloc_jmeths); + } + + // The lock has been dropped so we can free resources. + // Free up either the old cache or the new cache if we allocated one. + if (to_dealloc_jmeths != NULL) { + FreeHeap(to_dealloc_jmeths); + } + // free up the new ID since it wasn't needed + if (to_dealloc_id != NULL) { + JNIHandles::destroy_jmethod_id(to_dealloc_id); } } return id; } -jmethodID instanceKlass::get_jmethod_id(instanceKlassHandle ik_h, size_t idnum, - jmethodID new_id, jmethodID* new_jmeths) { - // Retry lookup after we got the lock or ensured we are at safepoint +// Common code to fetch the jmethodID from the cache or update the +// cache with the new jmethodID. This function should never do anything +// that causes the caller to go to a safepoint or we can deadlock with +// the VMThread or have cache consistency issues. +// +jmethodID instanceKlass::get_jmethod_id_fetch_or_update( + instanceKlassHandle ik_h, size_t idnum, jmethodID new_id, + jmethodID* new_jmeths, jmethodID* to_dealloc_id_p, + jmethodID** to_dealloc_jmeths_p) { + assert(new_id != NULL, "sanity check"); + assert(to_dealloc_id_p != NULL, "sanity check"); + assert(to_dealloc_jmeths_p != NULL, "sanity check"); + assert(Threads::number_of_threads() == 0 || + SafepointSynchronize::is_at_safepoint() || + JmethodIdCreation_lock->owned_by_self(), "sanity check"); + + // reacquire the cache - we are locked, single threaded or at a safepoint jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire(); - jmethodID id = NULL; - jmethodID to_dealloc_id = NULL; - jmethodID* to_dealloc_jmeths = NULL; - size_t length; + jmethodID id = NULL; + size_t length = 0; - if (jmeths == NULL || (length = (size_t)jmeths[0]) <= idnum) { + if (jmeths == NULL || // no cache yet + (length = (size_t)jmeths[0]) <= idnum) { // cache is too short if (jmeths != NULL) { - // We have grown the array: copy the existing entries, and delete the old array + // copy any existing entries from the old cache for (size_t index = 0; index < length; index++) { new_jmeths[index+1] = jmeths[index+1]; } - to_dealloc_jmeths = jmeths; // using the new jmeths, deallocate the old one + *to_dealloc_jmeths_p = jmeths; // save old cache for later delete } ik_h->release_set_methods_jmethod_ids(jmeths = new_jmeths); } else { + // fetch jmethodID (if any) from the existing cache id = jmeths[idnum+1]; - to_dealloc_jmeths = new_jmeths; // using the old jmeths, deallocate the new one + *to_dealloc_jmeths_p = new_jmeths; // save new cache for later delete } if (id == NULL) { + // No matching jmethodID in the existing cache or we have a new + // cache or we just grew the cache. This cache write is done here + // by the first thread to win the foot race because a jmethodID + // needs to be unique once it is generally available. id = new_id; - jmeths[idnum+1] = id; // install the new method ID + + // The jmethodID cache can be read while unlocked so we have to + // make sure the new jmethodID is complete before installing it + // in the cache. + OrderAccess::release_store_ptr(&jmeths[idnum+1], id); } else { - to_dealloc_id = new_id; // the new id wasn't used, mark it for deallocation - } - - // Free up unneeded or no longer needed resources - FreeHeap(to_dealloc_jmeths); - if (to_dealloc_id != NULL) { - JNIHandles::destroy_jmethod_id(to_dealloc_id); + *to_dealloc_id_p = new_id; // save new id for later delete } return id; } +// Common code to get the jmethodID cache length and the jmethodID +// value at index idnum if there is one. +// +void instanceKlass::get_jmethod_id_length_value(jmethodID* cache, + size_t idnum, size_t *length_p, jmethodID* id_p) { + assert(cache != NULL, "sanity check"); + assert(length_p != NULL, "sanity check"); + assert(id_p != NULL, "sanity check"); + + // cache size is stored in element[0], other elements offset by one + *length_p = (size_t)cache[0]; + if (*length_p <= idnum) { // cache is too short + *id_p = NULL; + } else { + *id_p = cache[idnum+1]; // fetch jmethodID (if any) + } +} + + // Lookup a jmethodID, NULL if not found. Do no blocking, no allocations, no handles jmethodID instanceKlass::jmethod_id_or_null(methodOop method) { size_t idnum = (size_t)method->method_idnum(); jmethodID* jmeths = methods_jmethod_ids_acquire(); size_t length; // length assigned as debugging crumb jmethodID id = NULL; - if (jmeths != NULL && // If there is a jmethodID array, + if (jmeths != NULL && // If there is a cache (length = (size_t)jmeths[0]) > idnum) { // and if it is long enough, id = jmeths[idnum+1]; // Look up the id (may be NULL) } @@ -1074,18 +1167,35 @@ // Cache an itable index void instanceKlass::set_cached_itable_index(size_t idnum, int index) { int* indices = methods_cached_itable_indices_acquire(); - if (indices == NULL || // If there is no index array, - ((size_t)indices[0]) <= idnum) { // or if it is too short - // Lock before we allocate the array so we don't leak + int* to_dealloc_indices = NULL; + + // We use a double-check locking idiom here because this cache is + // performance sensitive. In the normal system, this cache only + // transitions from NULL to non-NULL which is safe because we use + // release_set_methods_cached_itable_indices() to advertise the + // new cache. A partially constructed cache should never be seen + // by a racing thread. Cache reads and writes proceed without a + // lock, but creation of the cache itself requires no leaks so a + // lock is generally acquired in that case. + // + // If the RedefineClasses() API has been used, then this cache can + // grow and we'll have transitions from non-NULL to bigger non-NULL. + // Cache creation requires no leaks and we require safety between all + // cache accesses and freeing of the old cache so a lock is generally + // acquired when the RedefineClasses() API has been used. + + if (indices == NULL || idnum_can_increment()) { + // we need a cache or the cache can grow MutexLocker ml(JNICachedItableIndex_lock); - // Retry lookup after we got the lock + // reacquire the cache to see if another thread already did the work indices = methods_cached_itable_indices_acquire(); size_t length = 0; - // array length stored in first element, other elements offset by one + // cache size is stored in element[0], other elements offset by one if (indices == NULL || (length = (size_t)indices[0]) <= idnum) { size_t size = MAX2(idnum+1, (size_t)idnum_allocated_count()); int* new_indices = NEW_C_HEAP_ARRAY(int, size+1); - // Copy the existing entries, if any + new_indices[0] = (int)size; + // copy any existing entries size_t i; for (i = 0; i < length; i++) { new_indices[i+1] = indices[i+1]; @@ -1095,15 +1205,32 @@ new_indices[i+1] = -1; } if (indices != NULL) { - FreeHeap(indices); // delete any old indices + // We have an old cache to delete so save it for after we + // drop the lock. + to_dealloc_indices = indices; } release_set_methods_cached_itable_indices(indices = new_indices); } + + if (idnum_can_increment()) { + // this cache can grow so we have to write to it safely + indices[idnum+1] = index; + } } else { CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); } - // This is a cache, if there is a race to set it, it doesn't matter - indices[idnum+1] = index; + + if (!idnum_can_increment()) { + // The cache cannot grow and this JNI itable index value does not + // have to be unique like a jmethodID. If there is a race to set it, + // it doesn't matter. + indices[idnum+1] = index; + } + + if (to_dealloc_indices != NULL) { + // we allocated a new cache so free the old one + FreeHeap(to_dealloc_indices); + } } @@ -2299,6 +2426,11 @@ // Add an information node that contains weak references to the // interesting parts of the previous version of the_class. +// This is also where we clean out any unused weak references. +// Note that while we delete nodes from the _previous_versions +// array, we never delete the array itself until the klass is +// unloaded. The has_been_redefined() query depends on that fact. +// void instanceKlass::add_previous_version(instanceKlassHandle ikh, BitMap* emcp_methods, int emcp_method_count) { assert(Thread::current()->is_VM_thread(),
--- a/src/share/vm/oops/instanceKlass.hpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/oops/instanceKlass.hpp Fri Sep 25 04:39:54 2009 -0700 @@ -217,6 +217,7 @@ bool _is_marked_dependent; // used for marking during flushing and deoptimization bool _rewritten; // methods rewritten. bool _has_nonstatic_fields; // for sizing with UseCompressedOops + bool _should_verify_class; // allow caching of preverification u2 _minor_version; // minor version number of class file u2 _major_version; // major version number of class file ClassState _init_state; // state of class @@ -362,6 +363,10 @@ int get_init_state() { return _init_state; } // Useful for debugging bool is_rewritten() const { return _rewritten; } + // defineClass specified verification + bool should_verify_class() const { return _should_verify_class; } + void set_should_verify_class(bool value) { _should_verify_class = value; } + // marking bool is_marked_dependent() const { return _is_marked_dependent; } void set_is_marked_dependent(bool value) { _is_marked_dependent = value; } @@ -460,6 +465,10 @@ // RedefineClasses() support for previous versions: void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods, int emcp_method_count); + // If the _previous_versions array is non-NULL, then this klass + // has been redefined at least once even if we aren't currently + // tracking a previous version. + bool has_been_redefined() const { return _previous_versions != NULL; } bool has_previous_version() const; void init_previous_versions() { _previous_versions = NULL; @@ -501,9 +510,14 @@ void set_bootstrap_method(oop mh) { oop_store(&_bootstrap_method, mh); } // jmethodID support - static jmethodID get_jmethod_id(instanceKlassHandle ik_h, size_t idnum, - jmethodID new_id, jmethodID* new_jmeths); - static jmethodID jmethod_id_for_impl(instanceKlassHandle ik_h, methodHandle method_h); + static jmethodID get_jmethod_id(instanceKlassHandle ik_h, + methodHandle method_h); + static jmethodID get_jmethod_id_fetch_or_update(instanceKlassHandle ik_h, + size_t idnum, jmethodID new_id, jmethodID* new_jmeths, + jmethodID* to_dealloc_id_p, + jmethodID** to_dealloc_jmeths_p); + static void get_jmethod_id_length_value(jmethodID* cache, size_t idnum, + size_t *length_p, jmethodID* id_p); jmethodID jmethod_id_or_null(methodOop method); // cached itable index support @@ -749,6 +763,11 @@ void set_init_thread(Thread *thread) { _init_thread = thread; } u2 idnum_allocated_count() const { return _idnum_allocated_count; } + // The RedefineClasses() API can cause new method idnums to be needed + // which will cause the caches to grow. Safety requires different + // cache management logic if the caches can grow instead of just + // going from NULL to non-NULL. + bool idnum_can_increment() const { return has_been_redefined(); } jmethodID* methods_jmethod_ids_acquire() const { return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids); } void release_set_methods_jmethod_ids(jmethodID* jmeths)
--- a/src/share/vm/oops/methodOop.hpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/oops/methodOop.hpp Fri Sep 25 04:39:54 2009 -0700 @@ -555,7 +555,7 @@ // Get this method's jmethodID -- allocate if it doesn't exist jmethodID jmethod_id() { methodHandle this_h(this); - return instanceKlass::jmethod_id_for_impl(method_holder(), this_h); } + return instanceKlass::get_jmethod_id(method_holder(), this_h); } // Lookup the jmethodID for this method. Return NULL if not found. // NOTE that this function can be called from a signal handler
--- a/src/share/vm/prims/jni.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/prims/jni.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -299,7 +299,8 @@ } } klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader, - Handle(), &st, CHECK_NULL); + Handle(), &st, true, + CHECK_NULL); if (TraceClassResolution && k != NULL) { trace_class_resolution(k);
--- a/src/share/vm/prims/jvm.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/prims/jvm.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -762,7 +762,11 @@ } // common code for JVM_DefineClass() and JVM_DefineClassWithSource() -static jclass jvm_define_class_common(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source, TRAPS) { +// and JVM_DefineClassWithSourceCond() +static jclass jvm_define_class_common(JNIEnv *env, const char *name, + jobject loader, const jbyte *buf, + jsize len, jobject pd, const char *source, + jboolean verify, TRAPS) { if (source == NULL) source = "__JVM_DefineClass__"; assert(THREAD->is_Java_thread(), "must be a JavaThread"); @@ -803,6 +807,7 @@ Handle protection_domain (THREAD, JNIHandles::resolve(pd)); klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader, protection_domain, &st, + verify != 0, CHECK_NULL); if (TraceClassResolution && k != NULL) { @@ -816,16 +821,24 @@ JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd)) JVMWrapper2("JVM_DefineClass %s", name); - return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, THREAD); + return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, true, THREAD); JVM_END JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source)) JVMWrapper2("JVM_DefineClassWithSource %s", name); - return jvm_define_class_common(env, name, loader, buf, len, pd, source, THREAD); -JVM_END - + return jvm_define_class_common(env, name, loader, buf, len, pd, source, true, THREAD); +JVM_END + +JVM_ENTRY(jclass, JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, + jobject loader, const jbyte *buf, + jsize len, jobject pd, + const char *source, jboolean verify)) + JVMWrapper2("JVM_DefineClassWithSourceCond %s", name); + + return jvm_define_class_common(env, name, loader, buf, len, pd, source, verify, THREAD); +JVM_END JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name)) JVMWrapper("JVM_FindLoadedClass");
--- a/src/share/vm/prims/jvm.h Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/prims/jvm.h Fri Sep 25 04:39:54 2009 -0700 @@ -417,6 +417,17 @@ const jbyte *buf, jsize len, jobject pd, const char *source); +/* Define a class with a source with conditional verification (added HSX 14) + * -Xverify:all will verify anyway, -Xverify:none will not verify, + * -Xverify:remote (default) will obey this conditional + * i.e. true = should_verify_class + */ +JNIEXPORT jclass JNICALL +JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, + jobject loader, const jbyte *buf, + jsize len, jobject pd, const char *source, + jboolean verify); + /* Define a class with a source (MLVM) */ JNIEXPORT jclass JNICALL JVM_DefineClassWithCP(JNIEnv *env, const char *name, jobject loader,
--- a/src/share/vm/prims/jvmtiRedefineClasses.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/prims/jvmtiRedefineClasses.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -933,7 +933,7 @@ // description. RedefineVerifyMark rvm(&the_class, &scratch_class, state); Verifier::verify( - scratch_class, Verifier::ThrowException, THREAD); + scratch_class, Verifier::ThrowException, true, THREAD); } if (HAS_PENDING_EXCEPTION) { @@ -959,7 +959,7 @@ // verify what we have done during constant pool merging { RedefineVerifyMark rvm(&the_class, &scratch_class, state); - Verifier::verify(scratch_class, Verifier::ThrowException, THREAD); + Verifier::verify(scratch_class, Verifier::ThrowException, true, THREAD); } if (HAS_PENDING_EXCEPTION) {
--- a/src/share/vm/runtime/safepoint.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/runtime/safepoint.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -769,9 +769,23 @@ // to grab the Threads_lock which we own here, so a thread cannot be // resumed during safepoint synchronization. - // We check with locking because another thread that has not yet - // synchronized may be trying to suspend this one. - bool is_suspended = _thread->is_any_suspended_with_lock(); + // We check to see if this thread is suspended without locking to + // avoid deadlocking with a third thread that is waiting for this + // thread to be suspended. The third thread can notice the safepoint + // that we're trying to start at the beginning of its SR_lock->wait() + // call. If that happens, then the third thread will block on the + // safepoint while still holding the underlying SR_lock. We won't be + // able to get the SR_lock and we'll deadlock. + // + // We don't need to grab the SR_lock here for two reasons: + // 1) The suspend flags are both volatile and are set with an + // Atomic::cmpxchg() call so we should see the suspended + // state right away. + // 2) We're being called from the safepoint polling loop; if + // we don't see the suspended state on this iteration, then + // we'll come around again. + // + bool is_suspended = _thread->is_ext_suspended(); if (is_suspended) { roll_forward(_at_safepoint); return;
--- a/src/share/vm/runtime/thread.cpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/runtime/thread.cpp Fri Sep 25 04:39:54 2009 -0700 @@ -1942,7 +1942,7 @@ MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); - assert(!this->is_any_suspended(), + assert(!this->is_ext_suspended(), "a thread trying to self-suspend should not already be suspended"); if (this->is_suspend_equivalent()) {
--- a/src/share/vm/runtime/thread.hpp Wed Sep 23 11:36:06 2009 -0700 +++ b/src/share/vm/runtime/thread.hpp Fri Sep 25 04:39:54 2009 -0700 @@ -967,11 +967,6 @@ return (_suspend_flags & _ext_suspended) != 0; } - // legacy method that checked for either external suspension or vm suspension - bool is_any_suspended() const { - return is_ext_suspended(); - } - bool is_external_suspend_with_lock() const { MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); return is_external_suspend(); @@ -997,10 +992,6 @@ return ret; } - bool is_any_suspended_with_lock() const { - MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); - return is_any_suspended(); - } // utility methods to see if we are doing some kind of suspension bool is_being_ext_suspended() const { MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);