diff --git a/ASSEMBLY_EXCEPTION b/ASSEMBLY_EXCEPTION index 3e78398d9063218f0a43fc99cb515d939fc5d490..065b8d90239f30b7de3eba350f6446a932d4d131 100644 --- a/ASSEMBLY_EXCEPTION +++ b/ASSEMBLY_EXCEPTION @@ -1,9 +1,9 @@ OPENJDK ASSEMBLY EXCEPTION -The OpenJDK source code made available by Oracle at openjdk.java.net and -openjdk.dev.java.net ("OpenJDK Code") is distributed under the terms of the -GNU General Public License version 2 +The OpenJDK source code made available by Oracle America, Inc. (Oracle) at +openjdk.java.net ("OpenJDK Code") is distributed under the terms of the GNU +General Public License version 2 only ("GPL2"), with the following clarification and special exception. Linking this OpenJDK Code statically or dynamically with other code @@ -19,9 +19,9 @@ only ("GPL2"), with the following clarification and special exception. provided that the Designated Exception Modules continue to be governed by the licenses under which they were offered by Oracle. -As such, it allows licensees and sublicensees of Oracle's GPL2 OpenJDK Code to -build an executable that includes those portions of necessary code that Oracle -could not provide under GPL2 (or that Oracle has provided under GPL2 with the -Classpath exception). If you modify or add to the OpenJDK code, that new -GPL2 code may still be combined with Designated Exception Modules if the -new code is made subject to this exception by its copyright holder. +As such, it allows licensees and sublicensees of Oracle's GPL2 OpenJDK Code +to build an executable that includes those portions of necessary code that +Oracle could not provide under GPL2 (or that Oracle has provided under GPL2 +with the Classpath exception). If you modify or add to the OpenJDK code, +that new GPL2 code may still be combined with Designated Exception Modules +if the new code is made subject to this exception by its copyright holder. diff --git a/src/cpu/x86/vm/vm_version_x86.cpp b/src/cpu/x86/vm/vm_version_x86.cpp index 28aa48e45c21824a746d59bbbb9870fa660d08bd..134fa24180e6cc8867fc73358abf77ab587f38e9 100644 --- a/src/cpu/x86/vm/vm_version_x86.cpp +++ b/src/cpu/x86/vm/vm_version_x86.cpp @@ -704,16 +704,16 @@ void VM_Version::get_processor_features() { UseMultiplyToLenIntrinsic = true; } if (FLAG_IS_DEFAULT(UseSquareToLenIntrinsic)) { - UseSquareToLenIntrinsic = false; + UseSquareToLenIntrinsic = true; } if (FLAG_IS_DEFAULT(UseMulAddIntrinsic)) { - UseMulAddIntrinsic = false; + UseMulAddIntrinsic = true; } if (FLAG_IS_DEFAULT(UseMontgomeryMultiplyIntrinsic)) { - UseMontgomeryMultiplyIntrinsic = false; + UseMontgomeryMultiplyIntrinsic = true; } if (FLAG_IS_DEFAULT(UseMontgomerySquareIntrinsic)) { - UseMontgomerySquareIntrinsic = false; + UseMontgomerySquareIntrinsic = true; } #else if (UseMultiplyToLenIntrinsic) { diff --git a/src/share/vm/oops/instanceKlass.cpp b/src/share/vm/oops/instanceKlass.cpp index 481742db9e3beea1dc460827214b20d53207130d..4ecc87e9530d0ed576efc0d0dc0776afa59877bd 100644 --- a/src/share/vm/oops/instanceKlass.cpp +++ b/src/share/vm/oops/instanceKlass.cpp @@ -616,7 +616,11 @@ bool InstanceKlass::link_class_or_fail(TRAPS) { bool InstanceKlass::link_class_impl( instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) { - // check for error state + // check for error state. + // This is checking for the wrong state. If the state is initialization_error, + // then this class *was* linked. The CDS code does a try_link_class and uses + // initialization_error to mark classes to not include in the archive during + // DumpSharedSpaces. This should be removed when the CDS bug is fixed. if (this_oop->is_in_error_state()) { ResourceMark rm(THREAD); THROW_MSG_(vmSymbols::java_lang_NoClassDefFoundError(), @@ -801,37 +805,22 @@ void InstanceKlass::link_methods(TRAPS) { } // Eagerly initialize superinterfaces that declare default methods (concrete instance: any access) -void InstanceKlass::initialize_super_interfaces(instanceKlassHandle this_oop, TRAPS) { - if (this_oop->has_default_methods()) { - for (int i = 0; i < this_oop->local_interfaces()->length(); ++i) { - Klass* iface = this_oop->local_interfaces()->at(i); - InstanceKlass* ik = InstanceKlass::cast(iface); - if (ik->should_be_initialized()) { - if (ik->has_default_methods()) { - ik->initialize_super_interfaces(ik, THREAD); - } - // Only initialize() interfaces that "declare" concrete methods. - // has_default_methods drives searching superinterfaces since it - // means has_default_methods in its superinterface hierarchy - if (!HAS_PENDING_EXCEPTION && ik->declares_default_methods()) { - ik->initialize(THREAD); - } - if (HAS_PENDING_EXCEPTION) { - Handle e(THREAD, PENDING_EXCEPTION); - CLEAR_PENDING_EXCEPTION; - { - EXCEPTION_MARK; - // Locks object, set state, and notify all waiting threads - this_oop->set_initialization_state_and_notify( - initialization_error, THREAD); - - // ignore any exception thrown, superclass initialization error is - // thrown below - CLEAR_PENDING_EXCEPTION; - } - THROW_OOP(e()); - } - } +void InstanceKlass::initialize_super_interfaces(instanceKlassHandle this_k, TRAPS) { + assert (this_k->has_default_methods(), "caller should have checked this"); + for (int i = 0; i < this_k->local_interfaces()->length(); ++i) { + Klass* iface = this_k->local_interfaces()->at(i); + InstanceKlass* ik = InstanceKlass::cast(iface); + + // Initialization is depth first search ie. we start with top of the inheritance tree + // has_default_methods drives searching superinterfaces since it + // means has_default_methods in its superinterface hierarchy + if (ik->has_default_methods()) { + ik->initialize_super_interfaces(ik, CHECK); + } + + // Only initialize() interfaces that "declare" concrete methods. + if (ik->should_be_initialized() && ik->declares_default_methods()) { + ik->initialize(CHECK); } } } @@ -897,30 +886,36 @@ void InstanceKlass::initialize_impl(instanceKlassHandle this_oop, TRAPS) { } // Step 7 - Klass* super_klass = this_oop->super(); - if (super_klass != NULL && !this_oop->is_interface() && super_klass->should_be_initialized()) { - super_klass->initialize(THREAD); + // Next, if C is a class rather than an interface, initialize its super class and super + // interfaces. + if (!this_oop->is_interface()) { + Klass* super_klass = this_oop->super(); + if (super_klass != NULL && super_klass->should_be_initialized()) { + super_klass->initialize(THREAD); + } + // If C implements any interfaces that declares a non-abstract, non-static method, + // the initialization of C triggers initialization of its super interfaces. + // Only need to recurse if has_default_methods which includes declaring and + // inheriting default methods + if (!HAS_PENDING_EXCEPTION && this_oop->has_default_methods()) { + this_oop->initialize_super_interfaces(this_oop, THREAD); + } + // If any exceptions, complete abruptly, throwing the same exception as above. if (HAS_PENDING_EXCEPTION) { Handle e(THREAD, PENDING_EXCEPTION); CLEAR_PENDING_EXCEPTION; { EXCEPTION_MARK; - this_oop->set_initialization_state_and_notify(initialization_error, THREAD); // Locks object, set state, and notify all waiting threads - CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, superclass initialization error is thrown below + // Locks object, set state, and notify all waiting threads + this_oop->set_initialization_state_and_notify(initialization_error, THREAD); + CLEAR_PENDING_EXCEPTION; } DTRACE_CLASSINIT_PROBE_WAIT(super__failed, InstanceKlass::cast(this_oop()), -1,wait); THROW_OOP(e()); } } - // Recursively initialize any superinterfaces that declare default methods - // Only need to recurse if has_default_methods which includes declaring and - // inheriting default methods - if (this_oop->has_default_methods()) { - this_oop->initialize_super_interfaces(this_oop, CHECK); - } - // Step 8 { assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl"); @@ -981,10 +976,15 @@ void InstanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS) void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_oop, ClassState state, TRAPS) { oop init_lock = this_oop->init_lock(); - ObjectLocker ol(init_lock, THREAD, init_lock != NULL); - this_oop->set_init_state(state); - this_oop->fence_and_clear_init_lock(); - ol.notify_all(CHECK); + if (init_lock != NULL) { + ObjectLocker ol(init_lock, THREAD); + this_oop->set_init_state(state); + this_oop->fence_and_clear_init_lock(); + ol.notify_all(CHECK); + } else { + assert(init_lock != NULL, "The initialization state should never be set twice"); + this_oop->set_init_state(state); + } } // The embedded _implementor field can only record one implementor. diff --git a/src/share/vm/prims/unsafe.cpp b/src/share/vm/prims/unsafe.cpp index 0846b202f555809f4dfec359c9dcd7238692d9f0..5e39b385de9d56b4170fa3ed2be4d7929d072ec7 100644 --- a/src/share/vm/prims/unsafe.cpp +++ b/src/share/vm/prims/unsafe.cpp @@ -985,14 +985,6 @@ UNSAFE_ENTRY(jclass, Unsafe_DefineClass(JNIEnv *env, jobject unsafe, jstring nam } UNSAFE_END -static jobject get_class_loader(JNIEnv* env, jclass cls) { - if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { - return NULL; - } - Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); - oop loader = k->class_loader(); - return JNIHandles::make_local(env, loader); -} UNSAFE_ENTRY(jclass, Unsafe_DefineClass0(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length)) UnsafeWrapper("Unsafe_DefineClass"); @@ -1001,7 +993,7 @@ UNSAFE_ENTRY(jclass, Unsafe_DefineClass0(JNIEnv *env, jobject unsafe, jstring na int depthFromDefineClass0 = 1; jclass caller = JVM_GetCallerClass(env, depthFromDefineClass0); - jobject loader = (caller == NULL) ? NULL : get_class_loader(env, caller); + jobject loader = (caller == NULL) ? NULL : JVM_GetClassLoader(env, caller); jobject pd = (caller == NULL) ? NULL : JVM_GetProtectionDomain(env, caller); return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd); diff --git a/test/runtime/lambda-features/TestInterfaceInit.java b/test/runtime/lambda-features/TestInterfaceInit.java index 0493a60bb1e7f2d74156f5631f4ff993269e0a5e..a6f057c0460a6c255bcce6d3fdb67340308f743c 100644 --- a/test/runtime/lambda-features/TestInterfaceInit.java +++ b/test/runtime/lambda-features/TestInterfaceInit.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 2016, 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 @@ -25,7 +25,8 @@ /* * @test * @bug 8034275 - * @summary [JDK 8u40] Test interface initialization: only for interfaces declaring default methods + * @bug 8163969 + * @summary [JDK 8u40] Test interface init: only for interfaces declaring default methods, when subclass inits * @run main TestInterfaceInit */ import java.util.List; @@ -39,43 +40,59 @@ public class TestInterfaceInit { // Declares a default method and initializes interface I { boolean v = TestInterfaceInit.out(I.class); - default void x() {} + default void ix() {} } // Declares a default method and initializes interface J extends I { boolean v = TestInterfaceInit.out(J.class); - default void x() {} + default void jx() {} } - // No default method, does not initialize + // No default method, has an abstract method, does not initialize interface JN extends J { boolean v = TestInterfaceInit.out(JN.class); + public abstract void jnx(); } // Declares a default method and initializes interface K extends I { boolean v = TestInterfaceInit.out(K.class); - default void x() {} + default void kx() {} } - // No default method, does not initialize + // No default method, has a static method, does not initialize interface KN extends K { boolean v = TestInterfaceInit.out(KN.class); + static void knx() {} } interface L extends JN, KN { boolean v = TestInterfaceInit.out(L.class); - default void x() {} + default void lx() {} + } + + static class ChildClass implements JN, KN { + boolean v = TestInterfaceInit.out(ChildClass.class); + public void jnx() {} } public static void main(String[] args) { // Trigger initialization boolean v = L.v; - List> expectedCInitOrder = Arrays.asList(I.class,J.class,K.class,L.class); + List> expectedCInitOrder = Arrays.asList(L.class); + if (!cInitOrder.equals(expectedCInitOrder)) { + throw new RuntimeException(String.format("Class initialization array %s not equal to expected array %s", cInitOrder, expectedCInitOrder)); + } + + ChildClass myC = new ChildClass(); + boolean w = myC.v; + + expectedCInitOrder = Arrays.asList(L.class,I.class,J.class,K.class,ChildClass.class); if (!cInitOrder.equals(expectedCInitOrder)) { throw new RuntimeException(String.format("Class initialization array %s not equal to expected array %s", cInitOrder, expectedCInitOrder)); } + } static boolean out(Class c) { diff --git a/test/testlibrary/com/oracle/java/testlibrary/Utils.java b/test/testlibrary/com/oracle/java/testlibrary/Utils.java index 84215195cbaf030e469aa152dac9ab6bc57f3e80..b332c1e3a3b518e7176fa40388a6f585e6309f11 100644 --- a/test/testlibrary/com/oracle/java/testlibrary/Utils.java +++ b/test/testlibrary/com/oracle/java/testlibrary/Utils.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2016, 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 @@ -260,8 +260,8 @@ public final class Utils { output = ProcessTools.executeProcess(jcmdLauncher.getCommand()); output.shouldHaveExitValue(0); - // Search for a line starting with numbers (pid), follwed by the key. - Pattern pattern = Pattern.compile("([0-9]+)\\s.*(" + key + ").*\\r?\\n"); + // Search for a line starting with numbers (pid), followed by the key. + Pattern pattern = Pattern.compile("^([0-9]+)\\s.*(" + key + ")", Pattern.MULTILINE); Matcher matcher = pattern.matcher(output.getStdout()); int pid = -1;