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 2014-05-17 19:34:38 -04:00
commit 024bb79ec8
46 changed files with 576 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
hotspot/src/cpu/sparc/vm/sharedRuntime_sparc.cpp
View File

@ -2657,6 +2657,30 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
__ bind(done);
}
{
// Normally we do not post method_entry and method_exit events from
// compiled code, only from the interpreter. If method_entry/exit
// events are switched on at runtime, we will deoptimize everything
// (see VM_EnterInterpOnlyMode) on the stack and call method_entry/exit
// from the interpreter. But when we do that, we will not deoptimize
// this native wrapper frame. Thus we have an extra check here to see
// if we are now in interp_only_mode and in that case we do the jvmti
// callback.
Label skip_jvmti_method_exit;
__ ld(G2_thread, JavaThread::interp_only_mode_offset(), G3_scratch);
__ cmp_and_br_short(G3_scratch, 0, Assembler::zero, Assembler::pt, skip_jvmti_method_exit);
save_native_result(masm, ret_type, stack_slots);
__ set_metadata_constant(method(), G3_scratch);
__ call_VM(
noreg,
CAST_FROM_FN_PTR(address, SharedRuntime::jvmti_method_exit),
G2_thread, G3_scratch,
true);
restore_native_result(masm, ret_type, stack_slots);
__ bind(skip_jvmti_method_exit);
}
// Tell dtrace about this method exit
{
SkipIfEqual skip_if(

24
hotspot/src/cpu/x86/vm/sharedRuntime_x86_32.cpp
View File

@ -2238,6 +2238,30 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
}
{
// Normally we do not post method_entry and method_exit events from
// compiled code, only from the interpreter. If method_entry/exit
// events are switched on at runtime, we will deoptimize everything
// (see VM_EnterInterpOnlyMode) on the stack and call method_entry/exit
// from the interpreter. But when we do that, we will not deoptimize
// this native wrapper frame. Thus we have an extra check here to see
// if we are now in interp_only_mode and in that case we do the jvmti
// callback.
Label skip_jvmti_method_exit;
__ cmpl(Address(thread, JavaThread::interp_only_mode_offset()), 0);
__ jcc(Assembler::zero, skip_jvmti_method_exit, true);
save_native_result(masm, ret_type, stack_slots);
__ mov_metadata(rax, method());
__ call_VM(
noreg,
CAST_FROM_FN_PTR(address, SharedRuntime::jvmti_method_exit),
thread, rax,
true);
restore_native_result(masm, ret_type, stack_slots);
__ bind(skip_jvmti_method_exit);
}
{
SkipIfEqual skip_if(masm, &DTraceMethodProbes, 0);
// Tell dtrace about this method exit

25
hotspot/src/cpu/x86/vm/sharedRuntime_x86_64.cpp
View File

@ -2484,6 +2484,31 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
__ bind(done);
}
{
// Normally we do not post method_entry and method_exit events from
// compiled code, only from the interpreter. If method_entry/exit
// events are switched on at runtime, we will deoptimize everything
// (see VM_EnterInterpOnlyMode) on the stack and call method_entry/exit
// from the interpreter. But when we do that, we will not deoptimize
// this native wrapper frame. Thus we have an extra check here to see
// if we are now in interp_only_mode and in that case we do the jvmti
// callback.
Label skip_jvmti_method_exit;
__ cmpl(Address(r15_thread, JavaThread::interp_only_mode_offset()), 0);
__ jcc(Assembler::zero, skip_jvmti_method_exit, true);
save_native_result(masm, ret_type, stack_slots);
__ mov_metadata(c_rarg1, method());
__ call_VM(
noreg,
CAST_FROM_FN_PTR(address, SharedRuntime::jvmti_method_exit),
r15_thread, c_rarg1,
true);
restore_native_result(masm, ret_type, stack_slots);
__ bind(skip_jvmti_method_exit);
}
{
SkipIfEqual skip(masm, &DTraceMethodProbes, false);
save_native_result(masm, ret_type, stack_slots);

6
hotspot/src/os/windows/vm/os_windows.cpp
View File

@ -5005,7 +5005,11 @@ bool os::check_heap(bool force) {
// wrong; at these points, eax contains the address of the offending block (I think).
// To get to the exlicit error message(s) below, just continue twice.
HANDLE heap = GetProcessHeap();
{ HeapLock(heap);
// If we fail to lock the heap, then gflags.exe has been used
// or some other special heap flag has been set that prevents
// locking. We don't try to walk a heap we can't lock.
if (HeapLock(heap) != 0) {
PROCESS_HEAP_ENTRY phe;
phe.lpData = NULL;
while (HeapWalk(heap, &phe) != 0) {

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

@ -2805,7 +2805,7 @@ void ClassFileParser::parse_classfile_bootstrap_methods_attribute(u4 attribute_b
"Short length on BootstrapMethods in class file %s",
CHECK);
guarantee_property(attribute_byte_length > sizeof(u2),
guarantee_property(attribute_byte_length >= sizeof(u2),
"Invalid BootstrapMethods attribute length %u in class file %s",
attribute_byte_length,
CHECK);

29
hotspot/src/share/vm/classfile/classLoaderData.cpp
View File

@ -549,6 +549,8 @@ ClassLoaderData* ClassLoaderDataGraph::_head = NULL;
ClassLoaderData* ClassLoaderDataGraph::_unloading = NULL;
ClassLoaderData* ClassLoaderDataGraph::_saved_head = NULL;
bool ClassLoaderDataGraph::_should_purge = false;
// Add a new class loader data node to the list. Assign the newly created
// ClassLoaderData into the java/lang/ClassLoader object as a hidden field
ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_anonymous, TRAPS) {
@ -675,32 +677,6 @@ GrowableArray<ClassLoaderData*>* ClassLoaderDataGraph::new_clds() {
return array;
}
// For profiling and hsfind() only. Otherwise, this is unsafe (and slow). This
// is done lock free to avoid lock inversion problems. It is safe because
// new ClassLoaderData are added to the end of the CLDG, and only removed at
// safepoint. The _unloading list can be deallocated concurrently with CMS so
// this doesn't look in metaspace for classes that have been unloaded.
bool ClassLoaderDataGraph::contains(const void* x) {
if (DumpSharedSpaces) {
// There are only two metaspaces to worry about.
ClassLoaderData* ncld = ClassLoaderData::the_null_class_loader_data();
return (ncld->ro_metaspace()->contains(x) || ncld->rw_metaspace()->contains(x));
}
if (UseSharedSpaces && MetaspaceShared::is_in_shared_space(x)) {
return true;
}
for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
if (cld->metaspace_or_null() != NULL && cld->metaspace_or_null()->contains(x)) {
return true;
}
}
// Do not check unloading list because deallocation can be concurrent.
return false;
}
#ifndef PRODUCT
bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
@ -759,6 +735,7 @@ bool ClassLoaderDataGraph::do_unloading(BoolObjectClosure* is_alive_closure) {
}
void ClassLoaderDataGraph::purge() {
assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
ClassLoaderData* list = _unloading;
_unloading = NULL;
ClassLoaderData* next = list;

13
hotspot/src/share/vm/classfile/classLoaderData.hpp
View File

@ -66,6 +66,7 @@ class ClassLoaderDataGraph : public AllStatic {
static ClassLoaderData* _unloading;
// CMS support.
static ClassLoaderData* _saved_head;
static bool _should_purge;
static ClassLoaderData* add(Handle class_loader, bool anonymous, TRAPS);
static void post_class_unload_events(void);
@ -87,12 +88,20 @@ class ClassLoaderDataGraph : public AllStatic {
static void remember_new_clds(bool remember) { _saved_head = (remember ? _head : NULL); }
static GrowableArray<ClassLoaderData*>* new_clds();
static void set_should_purge(bool b) { _should_purge = b; }
static void purge_if_needed() {
// Only purge the CLDG for CMS if concurrent sweep is complete.
if (_should_purge) {
purge();
// reset for next time.
set_should_purge(false);
}
}
static void dump_on(outputStream * const out) PRODUCT_RETURN;
static void dump() { dump_on(tty); }
static void verify();
// expensive test for pointer in metaspace for debugging
static bool contains(const void* x);
#ifndef PRODUCT
static bool contains_loader_data(ClassLoaderData* loader_data);
#endif

2
hotspot/src/share/vm/classfile/systemDictionary.cpp
View File

@ -604,7 +604,6 @@ Klass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
Ticks class_load_start_time = Ticks::now();
// UseNewReflection
// Fix for 4474172; see evaluation for more details
class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
ClassLoaderData *loader_data = register_loader(class_loader, CHECK_NULL);
@ -898,7 +897,6 @@ Klass* SystemDictionary::find(Symbol* class_name,
Handle protection_domain,
TRAPS) {
// UseNewReflection
// The result of this call should be consistent with the result
// of the call to resolve_instance_class_or_null().
// See evaluation 6790209 and 4474172 for more details.

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

@ -390,7 +390,7 @@ public:
return k;
}
static Klass* check_klass_Opt_Only_JDK14NewRef(Klass* k) {
assert(JDK_Version::is_gte_jdk14x_version() && UseNewReflection, "JDK 1.4 only");
assert(JDK_Version::is_gte_jdk14x_version(), "JDK 1.4 only");
// despite the optional loading, if you use this it must be present:
return check_klass(k);
}

4
hotspot/src/share/vm/classfile/verifier.cpp
View File

@ -211,9 +211,9 @@ bool Verifier::is_eligible_for_verification(instanceKlassHandle klass, bool shou
// reflection implementation, not just those associated with
// sun/reflect/SerializationConstructorAccessor.
// NOTE: this is called too early in the bootstrapping process to be
// guarded by Universe::is_gte_jdk14x_version()/UseNewReflection.
// guarded by Universe::is_gte_jdk14x_version().
// Also for lambda generated code, gte jdk8
(!is_reflect || VerifyReflectionBytecodes));
(!is_reflect));
}
Symbol* Verifier::inference_verify(

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

@ -86,7 +86,7 @@ bool Disassembler::load_library() {
{
// Match "jvm[^/]*" in jvm_path.
const char* base = buf;
const char* p = strrchr(buf, '/');
const char* p = strrchr(buf, *os::file_separator());
if (p != NULL) lib_offset = p - base + 1;
p = strstr(p ? p : base, "jvm");
if (p != NULL) jvm_offset = p - base;
@ -111,7 +111,7 @@ bool Disassembler::load_library() {
if (_library == NULL) {
// 3. <home>/jre/lib/<arch>/hsdis-<arch>.so
buf[lib_offset - 1] = '\0';
const char* p = strrchr(buf, '/');
const char* p = strrchr(buf, *os::file_separator());
if (p != NULL) {
lib_offset = p - buf + 1;
strcpy(&buf[lib_offset], hsdis_library_name);

4
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
View File

@ -6362,7 +6362,9 @@ void CMSCollector::sweep(bool asynch) {
verify_overflow_empty();
if (should_unload_classes()) {
ClassLoaderDataGraph::purge();
// Delay purge to the beginning of the next safepoint. Metaspace::contains
// requires that the virtual spaces are stable and not deleted.
ClassLoaderDataGraph::set_should_purge(true);
}
_intra_sweep_timer.stop();

2
hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
View File

@ -5401,7 +5401,7 @@ public:
if (_g1h->is_in_g1_reserved(p)) {
_par_scan_state->push_on_queue(p);
} else {
assert(!ClassLoaderDataGraph::contains((address)p),
assert(!Metaspace::contains((const void*)p),
err_msg("Otherwise need to call _copy_metadata_obj_cl->do_oop(p) "
PTR_FORMAT, p));
_copy_non_heap_obj_cl->do_oop(p);

1
hotspot/src/share/vm/interpreter/linkResolver.cpp
View File

@ -950,7 +950,6 @@ void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method
// reflection implementation, not just those associated with
// sun/reflect/SerializationConstructorAccessor.
bool is_reflect = JDK_Version::is_gte_jdk14x_version() &&
UseNewReflection &&
klass_to_check->is_subclass_of(
SystemDictionary::reflect_MagicAccessorImpl_klass());

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

@ -75,7 +75,7 @@ bool MetaspaceObj::is_shared() const {
}
bool MetaspaceObj::is_metaspace_object() const {
return ClassLoaderDataGraph::contains((void*)this);
return Metaspace::contains((void*)this);
}
void MetaspaceObj::print_address_on(outputStream* st) const {

60
hotspot/src/share/vm/memory/metaspace.cpp
View File

@ -316,6 +316,8 @@ class VirtualSpaceNode : public CHeapObj<mtClass> {
MetaWord* bottom() const { return (MetaWord*) _virtual_space.low(); }
MetaWord* end() const { return (MetaWord*) _virtual_space.high(); }
bool contains(const void* ptr) { return ptr >= low() && ptr < high(); }
size_t reserved_words() const { return _virtual_space.reserved_size() / BytesPerWord; }
size_t committed_words() const { return _virtual_space.actual_committed_size() / BytesPerWord; }
@ -557,6 +559,8 @@ class VirtualSpaceList : public CHeapObj<mtClass> {
void inc_virtual_space_count();
void dec_virtual_space_count();
bool contains(const void* ptr);
// Unlink empty VirtualSpaceNodes and free it.
void purge(ChunkManager* chunk_manager);
@ -641,8 +645,6 @@ class SpaceManager : public CHeapObj<mtClass> {
// Accessors
Metachunk* chunks_in_use(ChunkIndex index) const { return _chunks_in_use[index]; }
void set_chunks_in_use(ChunkIndex index, Metachunk* v) {
// ensure lock-free iteration sees fully initialized node
OrderAccess::storestore();
_chunks_in_use[index] = v;
}
@ -757,8 +759,6 @@ class SpaceManager : public CHeapObj<mtClass> {
void print_on(outputStream* st) const;
void locked_print_chunks_in_use_on(outputStream* st) const;
bool contains(const void *ptr);
void verify();
void verify_chunk_size(Metachunk* chunk);
NOT_PRODUCT(void mangle_freed_chunks();)
@ -1078,6 +1078,7 @@ void ChunkManager::remove_chunk(Metachunk* chunk) {
// nodes with a 0 container_count. Remove Metachunks in
// the node from their respective freelists.
void VirtualSpaceList::purge(ChunkManager* chunk_manager) {
assert(SafepointSynchronize::is_at_safepoint(), "must be called at safepoint for contains to work");
assert_lock_strong(SpaceManager::expand_lock());
// Don't use a VirtualSpaceListIterator because this
// list is being changed and a straightforward use of an iterator is not safe.
@ -1111,8 +1112,8 @@ void VirtualSpaceList::purge(ChunkManager* chunk_manager) {
}
#ifdef ASSERT
if (purged_vsl != NULL) {
// List should be stable enough to use an iterator here.
VirtualSpaceListIterator iter(virtual_space_list());
// List should be stable enough to use an iterator here.
VirtualSpaceListIterator iter(virtual_space_list());
while (iter.repeat()) {
VirtualSpaceNode* vsl = iter.get_next();
assert(vsl != purged_vsl, "Purge of vsl failed");
@ -1121,6 +1122,23 @@ void VirtualSpaceList::purge(ChunkManager* chunk_manager) {
#endif
}
// This function looks at the mmap regions in the metaspace without locking.
// The chunks are added with store ordering and not deleted except for at
// unloading time during a safepoint.
bool VirtualSpaceList::contains(const void* ptr) {
// List should be stable enough to use an iterator here because removing virtual
// space nodes is only allowed at a safepoint.
VirtualSpaceListIterator iter(virtual_space_list());
while (iter.repeat()) {
VirtualSpaceNode* vsn = iter.get_next();
if (vsn->contains(ptr)) {
return true;
}
}
return false;
}
void VirtualSpaceList::retire_current_virtual_space() {
assert_lock_strong(SpaceManager::expand_lock());
@ -1210,6 +1228,8 @@ bool VirtualSpaceList::create_new_virtual_space(size_t vs_word_size) {
} else {
assert(new_entry->reserved_words() == vs_word_size,
"Reserved memory size differs from requested memory size");
// ensure lock-free iteration sees fully initialized node
OrderAccess::storestore();
link_vs(new_entry);
return true;
}
@ -2434,21 +2454,6 @@ MetaWord* SpaceManager::allocate_work(size_t word_size) {
return result;
}
// This function looks at the chunks in the metaspace without locking.
// The chunks are added with store ordering and not deleted except for at
// unloading time.
bool SpaceManager::contains(const void *ptr) {
for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i))
{
Metachunk* curr = chunks_in_use(i);
while (curr != NULL) {
if (curr->contains(ptr)) return true;
curr = curr->next();
}
}
return false;
}
void SpaceManager::verify() {
// If there are blocks in the dictionary, then
// verification of chunks does not work since
@ -3538,11 +3543,15 @@ void Metaspace::print_on(outputStream* out) const {
}
bool Metaspace::contains(const void* ptr) {
if (vsm()->contains(ptr)) return true;
if (using_class_space()) {
return class_vsm()->contains(ptr);
if (UseSharedSpaces && MetaspaceShared::is_in_shared_space(ptr)) {
return true;
}
return false;
if (using_class_space() && get_space_list(ClassType)->contains(ptr)) {
return true;
}
return get_space_list(NonClassType)->contains(ptr);
}
void Metaspace::verify() {
@ -3787,5 +3796,4 @@ void TestVirtualSpaceNode_test() {
TestVirtualSpaceNodeTest::test();
TestVirtualSpaceNodeTest::test_is_available();
}
#endif

5
hotspot/src/share/vm/memory/metaspace.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -232,7 +232,8 @@ class Metaspace : public CHeapObj<mtClass> {
MetaWord* expand_and_allocate(size_t size,
MetadataType mdtype);
bool contains(const void* ptr);
static bool contains(const void* ptr);
void dump(outputStream* const out) const;
// Free empty virtualspaces

5
hotspot/src/share/vm/oops/cpCache.cpp
View File

@ -498,9 +498,10 @@ bool ConstantPoolCacheEntry::check_no_old_or_obsolete_entries() {
// _f1 == NULL || !_f1->is_method() are OK here
return true;
}
// return false if _f1 refers to an old or an obsolete method
// return false if _f1 refers to a non-deleted old or obsolete method
return (NOT_PRODUCT(_f1->is_valid() &&) _f1->is_method() &&
!((Method*)_f1)->is_old() && !((Method*)_f1)->is_obsolete());
(f1_as_method()->is_deleted() ||
(!f1_as_method()->is_old() && !f1_as_method()->is_obsolete())));
}
bool ConstantPoolCacheEntry::is_interesting_method_entry(Klass* k) {

2
hotspot/src/share/vm/oops/klass.cpp
View File

@ -640,7 +640,7 @@ void Klass::verify_on(outputStream* st) {
// This can be expensive, but it is worth checking that this klass is actually
// in the CLD graph but not in production.
assert(ClassLoaderDataGraph::contains((address)this), "Should be");
assert(Metaspace::contains((address)this), "Should be");
guarantee(this->is_klass(),"should be klass");

19
hotspot/src/share/vm/oops/method.cpp
View File

@ -1019,13 +1019,11 @@ bool Method::should_not_be_cached() const {
* security related stack walks (like Reflection.getCallerClass).
*/
bool Method::is_ignored_by_security_stack_walk() const {
const bool use_new_reflection = JDK_Version::is_gte_jdk14x_version() && UseNewReflection;
if (intrinsic_id() == vmIntrinsics::_invoke) {
// This is Method.invoke() -- ignore it
return true;
}
if (use_new_reflection &&
if (JDK_Version::is_gte_jdk14x_version() &&
method_holder()->is_subclass_of(SystemDictionary::reflect_MethodAccessorImpl_klass())) {
// This is an auxilary frame -- ignore it
return true;
@ -1868,6 +1866,14 @@ void Method::clear_jmethod_ids(ClassLoaderData* loader_data) {
loader_data->jmethod_ids()->clear_all_methods();
}
bool Method::has_method_vptr(const void* ptr) {
Method m;
// This assumes that the vtbl pointer is the first word of a C++ object.
// This assumption is also in universe.cpp patch_klass_vtble
void* vtbl2 = dereference_vptr((const void*)&m);
void* this_vtbl = dereference_vptr(ptr);
return vtbl2 == this_vtbl;
}
// Check that this pointer is valid by checking that the vtbl pointer matches
bool Method::is_valid_method() const {
@ -1876,12 +1882,7 @@ bool Method::is_valid_method() const {
} else if (!is_metaspace_object()) {
return false;
} else {
Method m;
// This assumes that the vtbl pointer is the first word of a C++ object.
// This assumption is also in universe.cpp patch_klass_vtble
void* vtbl2 = dereference_vptr((void*)&m);
void* this_vtbl = dereference_vptr((void*)this);
return vtbl2 == this_vtbl;
return has_method_vptr((const void*)this);
}
}

3
hotspot/src/share/vm/oops/method.hpp
View File

@ -684,6 +684,8 @@ class Method : public Metadata {
void set_is_old() { _access_flags.set_is_old(); }
bool is_obsolete() const { return access_flags().is_obsolete(); }
void set_is_obsolete() { _access_flags.set_is_obsolete(); }
bool is_deleted() const { return access_flags().is_deleted(); }
void set_is_deleted() { _access_flags.set_is_deleted(); }
bool on_stack() const { return access_flags().on_stack(); }
void set_on_stack(const bool value);
@ -876,6 +878,7 @@ class Method : public Metadata {
const char* internal_name() const { return "{method}"; }
// Check for valid method pointer
static bool has_method_vptr(const void* ptr);
bool is_valid_method() const;
// Verify

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

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -420,7 +420,6 @@ CallGenerator* Compile::make_vm_intrinsic(ciMethod* m, bool is_virtual) {
return NULL;
case vmIntrinsics::_getCallerClass:
if (!UseNewReflection) return NULL;
if (!InlineReflectionGetCallerClass) return NULL;
if (SystemDictionary::reflect_CallerSensitive_klass() == NULL) return NULL;
break;

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

@ -544,7 +544,7 @@ JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID meth
if (m->is_initializer()) {
reflection_method = Reflection::new_constructor(m, CHECK_NULL);
} else {
reflection_method = Reflection::new_method(m, UseNewReflection, false, CHECK_NULL);
reflection_method = Reflection::new_method(m, false, CHECK_NULL);
}
ret = JNIHandles::make_local(env, reflection_method);
return ret;
@ -2272,7 +2272,7 @@ JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldI
found = InstanceKlass::cast(k)->find_field_from_offset(offset, false, &fd);
}
assert(found, "bad fieldID passed into jni_ToReflectedField");
oop reflected = Reflection::new_field(&fd, UseNewReflection, CHECK_NULL);
oop reflected = Reflection::new_field(&fd, CHECK_NULL);
ret = JNIHandles::make_local(env, reflected);
return ret;
JNI_END

9
hotspot/src/share/vm/prims/jvm.cpp
View File

@ -1854,7 +1854,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass,
if (!publicOnly || fs.access_flags().is_public()) {
fd.reinitialize(k(), fs.index());
oop field = Reflection::new_field(&fd, UseNewReflection, CHECK_NULL);
oop field = Reflection::new_field(&fd, CHECK_NULL);
result->obj_at_put(out_idx, field);
++out_idx;
}
@ -1932,7 +1932,7 @@ static jobjectArray get_class_declared_methods_helper(
if (want_constructor) {
m = Reflection::new_constructor(method, CHECK_NULL);
} else {
m = Reflection::new_method(method, UseNewReflection, false, CHECK_NULL);
m = Reflection::new_method(method, false, CHECK_NULL);
}
result->obj_at_put(i, m);
}
@ -2055,7 +2055,7 @@ static jobject get_method_at_helper(constantPoolHandle cp, jint index, bool forc
}
oop method;
if (!m->is_initializer() || m->is_static()) {
method = Reflection::new_method(m, true, true, CHECK_NULL);
method = Reflection::new_method(m, true, CHECK_NULL);
} else {
method = Reflection::new_constructor(m, CHECK_NULL);
}
@ -2105,7 +2105,7 @@ static jobject get_field_at_helper(constantPoolHandle cp, jint index, bool force
if (target_klass == NULL) {
THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class");
}
oop field = Reflection::new_field(&fd, true, CHECK_NULL);
oop field = Reflection::new_field(&fd, CHECK_NULL);
return JNIHandles::make_local(field);
}
@ -3521,7 +3521,6 @@ JVM_END
JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
// UseNewReflection
vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection
oop loader = vfst.method()->method_holder()->class_loader();
if (loader != NULL) {

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

@ -2970,7 +2970,8 @@ void VM_RedefineClasses::check_methods_and_mark_as_obsolete(
assert(!old_method->has_vtable_index(),
"cannot delete methods with vtable entries");;
// Mark all deleted methods as old and obsolete
// Mark all deleted methods as old, obsolete and deleted
old_method->set_is_deleted();
old_method->set_is_old();
old_method->set_is_obsolete();
++obsolete_count;
@ -3576,7 +3577,7 @@ void VM_RedefineClasses::CheckClass::do_klass(Klass* k) {
no_old_methods = false;
}
// the constant pool cache should never contain old or obsolete methods
// the constant pool cache should never contain non-deleted old or obsolete methods
if (ik->constants() != NULL &&
ik->constants()->cache() != NULL &&
!ik->constants()->cache()->check_no_old_or_obsolete_entries()) {

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

@ -312,6 +312,9 @@ static ObsoleteFlag obsolete_jvm_flags[] = {
{ "DefaultThreadPriority", JDK_Version::jdk(9), JDK_Version::jdk(10) },
{ "NoYieldsInMicrolock", JDK_Version::jdk(9), JDK_Version::jdk(10) },
{ "BackEdgeThreshold", JDK_Version::jdk(9), JDK_Version::jdk(10) },
{ "UseNewReflection", JDK_Version::jdk(9), JDK_Version::jdk(10) },
{ "ReflectionWrapResolutionErrors",JDK_Version::jdk(9), JDK_Version::jdk(10) },
{ "VerifyReflectionBytecodes", JDK_Version::jdk(9), JDK_Version::jdk(10) },
{ NULL, JDK_Version(0), JDK_Version(0) }
};
@ -581,11 +584,20 @@ char* SysClassPath::add_jars_to_path(char* path, const char* directory) {
// Parses a memory size specification string.
static bool atomull(const char *s, julong* result) {
julong n = 0;
int args_read = sscanf(s, JULONG_FORMAT, &n);
int args_read = 0;
bool is_hex = false;
// Skip leading 0[xX] for hexadecimal
if (*s =='0' && (*(s+1) == 'x' || *(s+1) == 'X')) {
s += 2;
is_hex = true;
args_read = sscanf(s, JULONG_FORMAT_X, &n);
} else {
args_read = sscanf(s, JULONG_FORMAT, &n);
}
if (args_read != 1) {
return false;
}
while (*s != '\0' && isdigit(*s)) {
while (*s != '\0' && (isdigit(*s) || (is_hex && isxdigit(*s)))) {
s++;
}
// 4705540: illegal if more characters are found after the first non-digit
@ -779,7 +791,7 @@ bool Arguments::parse_argument(const char* arg, Flag::Flags origin) {
}
}
#define VALUE_RANGE "[-kmgtKMGT0123456789]"
#define VALUE_RANGE "[-kmgtxKMGTX0123456789abcdefABCDEF]"
if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) VALUE_RANGE "%c", name, value, &dummy) == 2) {
return set_numeric_flag(name, value, origin);
}

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

@ -3656,22 +3656,6 @@ class CommandLineFlags {
\
/* New JDK 1.4 reflection implementation */ \
\
develop(bool, UseNewReflection, true, \
"Temporary flag for transition to reflection based on dynamic " \
"bytecode generation in 1.4; can no longer be turned off in 1.4 " \
"JDK, and is unneeded in 1.3 JDK, but marks most places VM " \
"changes were needed") \
\
develop(bool, VerifyReflectionBytecodes, false, \
"Force verification of 1.4 reflection bytecodes. Does not work " \
"in situations like that described in 4486457 or for " \
"constructors generated for serialization, so can not be enabled "\
"in product.") \
\
product(bool, ReflectionWrapResolutionErrors, true, \
"Temporary flag for transition to AbstractMethodError wrapped " \
"in InvocationTargetException. See 6531596") \
\
develop(intx, FastSuperclassLimit, 8, \
"Depth of hardwired instanceof accelerator array") \
\

14
hotspot/src/share/vm/runtime/os.cpp
View File

@ -1097,11 +1097,15 @@ void os::print_location(outputStream* st, intptr_t x, bool verbose) {
}
// Check if in metaspace.
if (ClassLoaderDataGraph::contains((address)addr)) {
// Use addr->print() from the debugger instead (not here)
st->print_cr(INTPTR_FORMAT
" is pointing into metadata", addr);
// Check if in metaspace and print types that have vptrs (only method now)
if (Metaspace::contains(addr)) {
if (Method::has_method_vptr((const void*)addr)) {
((Method*)addr)->print_value_on(st);
st->cr();
} else {
// Use addr->print() from the debugger instead (not here)
st->print_cr(INTPTR_FORMAT " is pointing into metadata", addr);
}
return;
}

96
hotspot/src/share/vm/runtime/reflection.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -466,7 +466,6 @@ bool Reflection::verify_class_access(Klass* current_class, Klass* new_class, boo
// New (1.4) reflection implementation. Allow all accesses from
// sun/reflect/MagicAccessorImpl subclasses to succeed trivially.
if ( JDK_Version::is_gte_jdk14x_version()
&& UseNewReflection
&& current_class->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {
return true;
}
@ -571,7 +570,6 @@ bool Reflection::verify_field_access(Klass* current_class,
// New (1.4) reflection implementation. Allow all accesses from
// sun/reflect/MagicAccessorImpl subclasses to succeed trivially.
if ( JDK_Version::is_gte_jdk14x_version()
&& UseNewReflection
&& current_class->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {
return true;
}
@ -708,7 +706,7 @@ Handle Reflection::new_type(Symbol* signature, KlassHandle k, TRAPS) {
}
oop Reflection::new_method(methodHandle method, bool intern_name, bool for_constant_pool_access, TRAPS) {
oop Reflection::new_method(methodHandle method, bool for_constant_pool_access, TRAPS) {
// In jdk1.2.x, getMethods on an interface erroneously includes <clinit>, thus the complicated assert.
// Also allow sun.reflect.ConstantPool to refer to <clinit> methods as java.lang.reflect.Methods.
assert(!method()->is_initializer() ||
@ -731,14 +729,8 @@ oop Reflection::new_method(methodHandle method, bool intern_name, bool for_const
if (exception_types.is_null()) return NULL;
Symbol* method_name = method->name();
Handle name;
if (intern_name) {
// intern_name is only true with UseNewReflection
oop name_oop = StringTable::intern(method_name, CHECK_NULL);
name = Handle(THREAD, name_oop);
} else {
name = java_lang_String::create_from_symbol(method_name, CHECK_NULL);
}
oop name_oop = StringTable::intern(method_name, CHECK_NULL);
Handle name = Handle(THREAD, name_oop);
if (name == NULL) return NULL;
int modifiers = method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
@ -825,16 +817,10 @@ oop Reflection::new_constructor(methodHandle method, TRAPS) {
}
oop Reflection::new_field(fieldDescriptor* fd, bool intern_name, TRAPS) {
oop Reflection::new_field(fieldDescriptor* fd, TRAPS) {
Symbol* field_name = fd->name();
Handle name;
if (intern_name) {
// intern_name is only true with UseNewReflection
oop name_oop = StringTable::intern(field_name, CHECK_NULL);
name = Handle(THREAD, name_oop);
} else {
name = java_lang_String::create_from_symbol(field_name, CHECK_NULL);
}
oop name_oop = StringTable::intern(field_name, CHECK_NULL);
Handle name = Handle(THREAD, name_oop);
Symbol* signature = fd->signature();
instanceKlassHandle holder (THREAD, fd->field_holder());
Handle type = new_type(signature, holder, CHECK_NULL);
@ -933,27 +919,23 @@ oop Reflection::invoke(instanceKlassHandle klass, methodHandle reflected_method,
// resolve based on the receiver
if (reflected_method->method_holder()->is_interface()) {
// resolve interface call
if (ReflectionWrapResolutionErrors) {
// new default: 6531596
// Match resolution errors with those thrown due to reflection inlining
// Linktime resolution & IllegalAccessCheck already done by Class.getMethod()
method = resolve_interface_call(klass, reflected_method, target_klass, receiver, THREAD);
if (HAS_PENDING_EXCEPTION) {
// Method resolution threw an exception; wrap it in an InvocationTargetException
oop resolution_exception = PENDING_EXCEPTION;
CLEAR_PENDING_EXCEPTION;
// JVMTI has already reported the pending exception
// JVMTI internal flag reset is needed in order to report InvocationTargetException
if (THREAD->is_Java_thread()) {
JvmtiExport::clear_detected_exception((JavaThread*) THREAD);
}
JavaCallArguments args(Handle(THREAD, resolution_exception));
THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
vmSymbols::throwable_void_signature(),
&args);
//
// Match resolution errors with those thrown due to reflection inlining
// Linktime resolution & IllegalAccessCheck already done by Class.getMethod()
method = resolve_interface_call(klass, reflected_method, target_klass, receiver, THREAD);
if (HAS_PENDING_EXCEPTION) {
// Method resolution threw an exception; wrap it in an InvocationTargetException
oop resolution_exception = PENDING_EXCEPTION;
CLEAR_PENDING_EXCEPTION;
// JVMTI has already reported the pending exception
// JVMTI internal flag reset is needed in order to report InvocationTargetException
if (THREAD->is_Java_thread()) {
JvmtiExport::clear_detected_exception((JavaThread*) THREAD);
}
} else {
method = resolve_interface_call(klass, reflected_method, target_klass, receiver, CHECK_(NULL));
JavaCallArguments args(Handle(THREAD, resolution_exception));
THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
vmSymbols::throwable_void_signature(),
&args);
}
} else {
// if the method can be overridden, we resolve using the vtable index.
@ -970,24 +952,16 @@ oop Reflection::invoke(instanceKlassHandle klass, methodHandle reflected_method,
// Check for abstract methods as well
if (method->is_abstract()) {
// new default: 6531596
if (ReflectionWrapResolutionErrors) {
ResourceMark rm(THREAD);
Handle h_origexception = Exceptions::new_exception(THREAD,
vmSymbols::java_lang_AbstractMethodError(),
Method::name_and_sig_as_C_string(target_klass(),
method->name(),
method->signature()));
JavaCallArguments args(h_origexception);
THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
vmSymbols::throwable_void_signature(),
&args);
} else {
ResourceMark rm(THREAD);
THROW_MSG_0(vmSymbols::java_lang_AbstractMethodError(),
Method::name_and_sig_as_C_string(target_klass(),
method->name(),
method->signature()));
}
ResourceMark rm(THREAD);
Handle h_origexception = Exceptions::new_exception(THREAD,
vmSymbols::java_lang_AbstractMethodError(),
Method::name_and_sig_as_C_string(target_klass(),
method->name(),
method->signature()));
JavaCallArguments args(h_origexception);
THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
vmSymbols::throwable_void_signature(),
&args);
}
}
}
@ -1006,7 +980,7 @@ oop Reflection::invoke(instanceKlassHandle klass, methodHandle reflected_method,
// In the JDK 1.4 reflection implementation, the security check is
// done at the Java level
if (!(JDK_Version::is_gte_jdk14x_version() && UseNewReflection)) {
if (!JDK_Version::is_gte_jdk14x_version()) {
// Access checking (unless overridden by Method)
if (!override) {
@ -1018,7 +992,7 @@ oop Reflection::invoke(instanceKlassHandle klass, methodHandle reflected_method,
}
}
} // !(Universe::is_gte_jdk14x_version() && UseNewReflection)
} // !Universe::is_gte_jdk14x_version()
assert(ptypes->is_objArray(), "just checking");
int args_len = args.is_null() ? 0 : args->length();

6
hotspot/src/share/vm/runtime/reflection.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -113,11 +113,11 @@ class Reflection: public AllStatic {
//
// Create a java.lang.reflect.Method object based on a method
static oop new_method(methodHandle method, bool intern_name, bool for_constant_pool_access, TRAPS);
static oop new_method(methodHandle method, bool for_constant_pool_access, TRAPS);
// Create a java.lang.reflect.Constructor object based on a method
static oop new_constructor(methodHandle method, TRAPS);
// Create a java.lang.reflect.Field object based on a field descriptor
static oop new_field(fieldDescriptor* fd, bool intern_name, TRAPS);
static oop new_field(fieldDescriptor* fd, TRAPS);
// Create a java.lang.reflect.Parameter object based on a
// MethodParameterElement
static oop new_parameter(Handle method, int index, Symbol* sym,

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

@ -541,6 +541,13 @@ void SafepointSynchronize::do_cleanup_tasks() {
gclog_or_tty->rotate_log(false);
}
{
// CMS delays purging the CLDG until the beginning of the next safepoint and to
// make sure concurrent sweep is done
TraceTime t7("purging class loader data graph", TraceSafepointCleanupTime);
ClassLoaderDataGraph::purge_if_needed();
}
if (MemTracker::is_on()) {
MemTracker::sync();
}

6
hotspot/src/share/vm/runtime/sharedRuntime.cpp
View File

@ -993,6 +993,12 @@ JRT_LEAF(int, SharedRuntime::dtrace_method_exit(
return 0;
JRT_END
JRT_ENTRY(int, SharedRuntime::jvmti_method_exit(
JavaThread* thread, Method* method))
JvmtiExport::post_method_exit(thread, method, thread->last_frame());
return 0;
JRT_END
// Finds receiver, CallInfo (i.e. receiver method), and calling bytecode)
// for a call current in progress, i.e., arguments has been pushed on stack

3
hotspot/src/share/vm/runtime/sharedRuntime.hpp
View File

@ -263,6 +263,9 @@ class SharedRuntime: AllStatic {
static int dtrace_method_entry(JavaThread* thread, Method* m);
static int dtrace_method_exit(JavaThread* thread, Method* m);
// jvmti notification
static int jvmti_method_exit(JavaThread* thread, Method* m);
// Utility method for retrieving the Java thread id, returns 0 if the
// thread is not a well formed Java thread.
static jlong get_java_tid(Thread* thread);

2
hotspot/src/share/vm/runtime/vframe.cpp
View File

@ -473,7 +473,7 @@ void vframeStreamCommon::skip_prefixed_method_and_wrappers() {
void vframeStreamCommon::skip_reflection_related_frames() {
while (!at_end() &&
(JDK_Version::is_gte_jdk14x_version() && UseNewReflection &&
(JDK_Version::is_gte_jdk14x_version() &&
(method()->method_holder()->is_subclass_of(SystemDictionary::reflect_MethodAccessorImpl_klass()) ||
method()->method_holder()->is_subclass_of(SystemDictionary::reflect_ConstructorAccessorImpl_klass())))) {
next();

2
hotspot/src/share/vm/trace/traceStream.hpp
View File

@ -66,7 +66,7 @@ class TraceStream : public StackObj {
}
void print_val(const char* label, s8 val) {
_st.print("%s = "INT64_FORMAT, label, val);
_st.print("%s = "INT64_FORMAT, label, (int64_t) val);
}
void print_val(const char* label, bool val) {

5
hotspot/src/share/vm/utilities/accessFlags.hpp
View File

@ -54,7 +54,8 @@ enum {
JVM_ACC_IS_OLD = 0x00010000, // RedefineClasses() has replaced this method
JVM_ACC_IS_OBSOLETE = 0x00020000, // RedefineClasses() has made method obsolete
JVM_ACC_IS_PREFIXED_NATIVE = 0x00040000, // JVMTI has prefixed this native method
JVM_ACC_ON_STACK = 0x00080000, // RedefinedClasses() is used on the stack
JVM_ACC_ON_STACK = 0x00080000, // RedefineClasses() was used on the stack
JVM_ACC_IS_DELETED = 0x00008000, // RedefineClasses() has deleted this method
// Klass* flags
JVM_ACC_HAS_MIRANDA_METHODS = 0x10000000, // True if this class has miranda methods in it's vtable
@ -131,6 +132,7 @@ class AccessFlags VALUE_OBJ_CLASS_SPEC {
bool has_jsrs () const { return (_flags & JVM_ACC_HAS_JSRS ) != 0; }
bool is_old () const { return (_flags & JVM_ACC_IS_OLD ) != 0; }
bool is_obsolete () const { return (_flags & JVM_ACC_IS_OBSOLETE ) != 0; }
bool is_deleted () const { return (_flags & JVM_ACC_IS_DELETED ) != 0; }
bool is_prefixed_native () const { return (_flags & JVM_ACC_IS_PREFIXED_NATIVE ) != 0; }
// Klass* flags
@ -195,6 +197,7 @@ class AccessFlags VALUE_OBJ_CLASS_SPEC {
void set_has_jsrs() { atomic_set_bits(JVM_ACC_HAS_JSRS); }
void set_is_old() { atomic_set_bits(JVM_ACC_IS_OLD); }
void set_is_obsolete() { atomic_set_bits(JVM_ACC_IS_OBSOLETE); }
void set_is_deleted() { atomic_set_bits(JVM_ACC_IS_DELETED); }
void set_is_prefixed_native() { atomic_set_bits(JVM_ACC_IS_PREFIXED_NATIVE); }
void clear_not_c1_compilable() { atomic_clear_bits(JVM_ACC_NOT_C1_COMPILABLE); }

5
hotspot/src/share/vm/utilities/globalDefinitions.hpp
View File

@ -1346,6 +1346,9 @@ inline intptr_t p2i(const void * p) {
#ifndef JULONG_FORMAT
#define JULONG_FORMAT UINT64_FORMAT
#endif
#ifndef JULONG_FORMAT_X
#define JULONG_FORMAT_X UINT64_FORMAT_X
#endif
// Format pointers which change size between 32- and 64-bit.
#ifdef _LP64
@ -1385,7 +1388,7 @@ inline intptr_t p2i(const void * p) {
// All C++ compilers that we know of have the vtbl pointer in the first
// word. If there are exceptions, this function needs to be made compiler
// specific.
static inline void* dereference_vptr(void* addr) {
static inline void* dereference_vptr(const void* addr) {
return *(void**)addr;
}

119
hotspot/test/runtime/7110720/Test7110720.sh
View File

@ -1,119 +0,0 @@
#
# Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
#
# @test Test7110720.sh
# @bug 7110720
# @summary improve VM configuration file loading
# @run shell Test7110720.sh
#
if [ "${TESTSRC}" = "" ]
then
TESTSRC=${PWD}
echo "TESTSRC not set. Using "${TESTSRC}" as default"
fi
echo "TESTSRC=${TESTSRC}"
## Adding common setup Variables for running shell tests.
. ${TESTSRC}/../../test_env.sh
# Jtreg sets TESTVMOPTS which may include -d64 which is
# required to test a 64-bit JVM on some platforms.
# If another test harness still creates HOME/JDK64BIT,
# we can recognise that.
# set platform-dependent variables
OS=`uname -s`
case "$OS" in
SunOS | Linux | Darwin )
FS="/"
RM=/bin/rm
CP=/bin/cp
MV=/bin/mv
## for solaris, linux it's HOME
FILE_LOCATION=$HOME
if [ -f ${FILE_LOCATION}${FS}JDK64BIT -a ${OS} = "SunOS" ]
then
TESTVMOPTS=`cat ${FILE_LOCATION}${FS}JDK64BIT`
fi
;;
Windows_* )
FS="\\"
RM=rm
CP=cp
MV=mv
;;
CYGWIN_* )
FS="/"
RM=rm
CP=cp
MV=mv
;;
* )
echo "Unrecognized system!"
exit 1;
;;
esac
JAVA=${TESTJAVA}${FS}bin${FS}java
# Don't test debug builds, they do read the config files:
${JAVA} ${TESTVMOPTS} -version 2>&1 | grep "debug" >/dev/null
if [ "$?" = "0" ]; then
echo Skipping test for debug build.
exit 0
fi
ok=yes
$RM -f .hotspot_compiler .hotspotrc
${JAVA} ${TESTVMOPTS} -version 2>&1 | grep "garbage in" >/dev/null
if [ "$?" = "0" ]; then
echo "FAILED: base case failure"
exit 1
fi
echo "garbage in, garbage out" > .hotspot_compiler
${JAVA} ${TESTVMOPTS} -version 2>&1 | grep "garbage in" >/dev/null
if [ "$?" = "0" ]; then
echo "FAILED: .hotspot_compiler was read"
ok=no
fi
$MV .hotspot_compiler hs_comp.txt
${JAVA} ${TESTVMOPTS} -XX:CompileCommandFile=hs_comp.txt -version 2>&1 | grep "garbage in" >/dev/null
if [ "$?" = "1" ]; then
echo "FAILED: explicit compiler command file not read"
ok=no
fi
$RM -f .hotspot_compiler hs_comp.txt
echo "garbage" > .hotspotrc
${JAVA} ${TESTVMOPTS} -version 2>&1 | grep "garbage" >/dev/null
if [ "$?" = "0" ]; then
echo "FAILED: .hotspotrc was read"
ok=no
fi
$MV .hotspotrc hs_flags.txt
${JAVA} ${TESTVMOPTS} -XX:Flags=hs_flags.txt -version 2>&1 | grep "garbage" >/dev/null
if [ "$?" = "1" ]; then
echo "FAILED: explicit flags file not read"
ok=no
fi
if [ "${ok}" = "no" ]; then
echo "Some tests failed."
exit 1
else
echo "Passed"
exit 0
fi

29
hotspot/test/runtime/CommandLine/CompilerConfigFileWarning.java
View File

@ -33,17 +33,28 @@ import com.oracle.java.testlibrary.*;
public class CompilerConfigFileWarning {
public static void main(String[] args) throws Exception {
if (Platform.isDebugBuild()) {
System.out.println("Skip on debug builds since we'll always read the file there");
return;
}
ProcessBuilder pb;
OutputAnalyzer output;
PrintWriter pw;
PrintWriter pw = new PrintWriter(".hotspot_compiler");
pw.println("aa");
pw = new PrintWriter("hs_comp.txt");
pw.println("aaa, aaa");
pw.close();
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("warning: .hotspot_compiler file is present but has been ignored. Run with -XX:CompileCommandFile=.hotspot_compiler to load the file.");
pb = ProcessTools.createJavaProcessBuilder("-XX:CompileCommandFile=hs_comp.txt", "-version");
output = new OutputAnalyzer(pb.start());
output.shouldContain("CompilerOracle: unrecognized line");
output.shouldContain("aaa aaa");
// Skip on debug builds since we'll always read the file there
if (!Platform.isDebugBuild()) {
pw = new PrintWriter(".hotspot_compiler");
pw.println("aa");
pw.close();
pb = ProcessTools.createJavaProcessBuilder("-version");
output = new OutputAnalyzer(pb.start());
output.shouldContain("warning: .hotspot_compiler file is present but has been ignored. Run with -XX:CompileCommandFile=.hotspot_compiler to load the file.");
}
}
}

29
hotspot/test/runtime/CommandLine/ConfigFileWarning.java
View File

@ -33,17 +33,28 @@ import com.oracle.java.testlibrary.*;
public class ConfigFileWarning {
public static void main(String[] args) throws Exception {
if (Platform.isDebugBuild()) {
System.out.println("Skip on debug builds since we'll always read the file there");
return;
}
PrintWriter pw;
ProcessBuilder pb;
OutputAnalyzer output;
PrintWriter pw = new PrintWriter(".hotspotrc");
pw.println("aa");
pw = new PrintWriter("hs_flags.txt");
pw.println("aaa");
pw.close();
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("warning: .hotspotrc file is present but has been ignored. Run with -XX:Flags=.hotspotrc to load the file.");
pb = ProcessTools.createJavaProcessBuilder("-XX:Flags=hs_flags.txt","-version");
output = new OutputAnalyzer(pb.start());
output.shouldContain("Unrecognized VM option 'aaa'");
output.shouldHaveExitValue(1);
// Skip on debug builds since we'll always read the file there
if (!Platform.isDebugBuild()) {
pw = new PrintWriter(".hotspotrc");
pw.println("aa");
pw.close();
pb = ProcessTools.createJavaProcessBuilder("-version");
output = new OutputAnalyzer(pb.start());
output.shouldContain("warning: .hotspotrc file is present but has been ignored. Run with -XX:Flags=.hotspotrc to load the file.");
}
}
}

49
hotspot/test/runtime/CommandLine/TestHexArguments.java Normal file
View File

@ -0,0 +1,49 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8042885
* @summary Make sure there is no error using hexadecimal format in vm options
* @author Yumin Qi
* @library /testlibrary
*/
import java.io.File;
import com.oracle.java.testlibrary.*;
public class TestHexArguments {
public static void main(String args[]) throws Exception {
String[] javaArgs = {"-XX:SharedBaseAddress=0x1D000000", "-version"};
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(true, javaArgs);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldNotContain("Could not create the Java Virtual Machine");
output.shouldHaveExitValue(0);
String[] javaArgs1 = {"-XX:SharedBaseAddress=1D000000", "-version"};
pb = ProcessTools.createJavaProcessBuilder(true, javaArgs1);
output = new OutputAnalyzer(pb.start());
output.shouldContain("Could not create the Java Virtual Machine");
}
}

85
hotspot/test/runtime/SharedArchiveFile/CdsWriteError.java
View File

@ -1,85 +0,0 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test CdsWriteError
* @summary Test how VM handles situation when it is impossible to write the
* CDS archive. VM is expected to exit gracefully and display the
* correct reason for the error.
* @library /testlibrary
* @run main CdsWriteError
* @bug 8032222
*/
import com.oracle.java.testlibrary.*;
import java.io.File;
public class CdsWriteError {
public static void main(String[] args) throws Exception {
if (Platform.isWindows()) {
System.out.println("This test is ignored on Windows. This test " +
"manipulates folder writable attribute, which is known to be " +
"often ignored by Windows");
return;
}
// This test has been unstable for Mac OSx (see JDK-8032222)
if (Platform.isOSX()) {
System.out.println("This test is skipped on Mac");
return;
}
String folderName = "tmp";
String fileName = folderName + File.separator + "empty.jsa";
// create an empty archive file and make it read only
File folder = new File(folderName);
if (!folder.mkdir())
throw new RuntimeException("Error when creating a tmp folder");
File cdsFile = new File(fileName);
if (!cdsFile.createNewFile())
throw new RuntimeException("Error when creating an empty CDS file");
if (!cdsFile.setWritable(false))
throw new RuntimeException("Error: could not set writable attribute on cds file");
if (!folder.setWritable(false))
throw new RuntimeException("Error: could not set writable attribute on the cds folder");
try {
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
"-XX:+UnlockDiagnosticVMOptions", "-XX:SharedArchiveFile=./" + fileName, "-Xshare:dump");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Unable to create shared archive file");
output.shouldHaveExitValue(1);
} finally {
// doing this, just in case, to make sure that files can be deleted by the harness
// on any subsequent run
folder.setWritable(true);
cdsFile.setWritable(true);
}
}
}

75
hotspot/test/runtime/classFileParserBug/TestEmptyBootstrapMethodsAttr.java Normal file
View File

@ -0,0 +1,75 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test TestEmptyBootstrapMethodsAttr
* @bug 8041918
* @library /testlibrary
* @summary Test empty bootstrap_methods table within BootstrapMethods attribute
* @compile TestEmptyBootstrapMethodsAttr.java
* @run main TestEmptyBootstrapMethodsAttr
*/
import java.io.File;
import com.oracle.java.testlibrary.*;
public class TestEmptyBootstrapMethodsAttr {
public static void main(String args[]) throws Throwable {
System.out.println("Regression test for bug 8041918");
String jarFile = System.getProperty("test.src") + File.separator + "emptynumbootstrapmethods.jar";
// ====== extract the test case
ProcessBuilder pb = new ProcessBuilder(new String[] { JDKToolFinder.getJDKTool("jar"), "xvf", jarFile } );
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0);
// Test case #1:
// Try loading class with empty bootstrap_methods table where no
// other attributes are following BootstrapMethods in attribute table.
String className = "emptynumbootstrapmethods1";
// ======= execute test case #1
// Expect a lack of main method, this implies that the class loaded correctly
// with an empty bootstrap_methods and did not generate a ClassFormatError.
pb = ProcessTools.createJavaProcessBuilder("-cp", ".", className);
output = new OutputAnalyzer(pb.start());
output.shouldNotContain("java.lang.ClassFormatError");
output.shouldContain("Main method not found in class " + className);
output.shouldHaveExitValue(1);
// Test case #2:
// Try loading class with empty bootstrap_methods table where an
// AnnotationDefault attribute follows the BootstrapMethods in the attribute table.
className = "emptynumbootstrapmethods2";
// ======= execute test case #2
// Expect a lack of main method, this implies that the class loaded correctly
// with an empty bootstrap_methods and did not generate ClassFormatError.
pb = ProcessTools.createJavaProcessBuilder("-cp", ".", className);
output = new OutputAnalyzer(pb.start());
output.shouldNotContain("java.lang.ClassFormatError");
output.shouldContain("Main method not found in class " + className);
output.shouldHaveExitValue(1);
}
}

BIN
hotspot/test/runtime/classFileParserBug/emptynumbootstrapmethods.jar Normal file
View File

Binary file not shown.

68
hotspot/test/runtime/classFileParserBug/emptynumbootstrapmethods1.jcod Normal file
View File

@ -0,0 +1,68 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* This test contains a BootstrapMethods attribute with an empty
* bootstrap_methods table. This yields a BootstrapMethods
* attribute length of 2 and should not cause a
* java.lang.ClassFormatError to be thrown.
*/
class emptynumbootstrapmethods1 {
0xCAFEBABE;
0; // minor version
51; // version
[12] { // Constant Pool
; // first element is empty
class #2; // #1 at 0x0A
Utf8 "emptynumbootstrapmethods1"; // #2 at 0x0D
class #4; // #3 at 0x1F
Utf8 "java/lang/Object"; // #4 at 0x22
MethodHandle 5b #9; // #5 at 0x35
NameAndType #7 #8; // #6 at 0x39
Utf8 "equals"; // #7 at 0x3E
Utf8 "(Ljava/lang/Object;)Z"; // #8 at 0x47
Method #3 #6; // #9 at 0x5F
Utf8 "equalsx"; // #10 at 0x3E
Utf8 "BootstrapMethods"; // #11 at 0x69
} // Constant Pool
0x0001; // access
#1;// this_cpx
#3;// super_cpx
[0] { // Interfaces
} // Interfaces
[0] { // fields
} // fields
[0] { // methods
} // methods
[1] { // Attributes
Attr(#11, 2) { // BootstrapMethods at 0x8A
[0] { // bootstrap_methods
}
} // end BootstrapMethods
} // Attributes
} // end class atrbsm00101m10p

89
hotspot/test/runtime/classFileParserBug/emptynumbootstrapmethods2.jcod Normal file
View File

@ -0,0 +1,89 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* This test contains a BootstrapMethods attribute with an empty
* bootstrap_methods table. This yields a BootstrapMethods
* attribute length of 2 and should not cause a
* java.lang.ClassFormatError to be thrown. To ensure that an empty
* bootstrap_methods table is parsed correctly, another attribute,
* AnnotationDefault, follows the BootstrapMethods attribute in
* the attribute table.
*/
class emptynumbootstrapmethods2 {
0xCAFEBABE;
0; // minor version
51; // version
[14] { // Constant Pool
; // first element is empty
class #2; // #1 at 0x0A
Utf8 "emptynumbootstrapmethods2"; // #2 at 0x0D
class #4; // #3 at 0x1F
Utf8 "java/lang/Object"; // #4 at 0x22
MethodHandle 5b #9; // #5 at 0x35
NameAndType #7 #8; // #6 at 0x39
Utf8 "equals"; // #7 at 0x3E
Utf8 "(Ljava/lang/Object;)Z"; // #8 at 0x47
Method #3 #6; // #9 at 0x5F
Utf8 "equalsx"; // #10 at 0x3E
Utf8 "BootstrapMethods"; // #11 at 0x69
Utf8 "AnnotationDefault"; // #12
Utf8 "LAnnotationDefaultI;"; // #13
} // Constant Pool
0x0001; // access
#1;// this_cpx
#3;// super_cpx
[0] { // Interfaces
} // Interfaces
[0] { // fields
} // fields
[0] { // methods
} // methods
[2] { // Attributes
Attr(#11, 2) { // BootstrapMethods at 0x8A
[0] { // bootstrap_methods
}
} // end BootstrapMethods
;
Attr(#12) { // AnnotationDefault
[] { // type annotations
{ // type annotation
0x00; // target_type
0x00; // type_parameter_index
[]b { // type_path
}
#13; // type_index
[] { // element_value_pairs
} // element_value_pairs
} // type annotation
} // type annotations
} // end AnnotationDefault
} // Attributes
} // end class atrbsm00101m10p