truffle: src/share/vm/classfile/classLoader.cpp comparison

comparison src/share/vm/classfile/classLoader.cpp @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	3cce976666d9 3a4e6c929bf3
children	d8041d695d19

comparison

equal deleted inserted replaced

-:ccb4f2af2319
+:cefad50507d8
 /*
-* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 _dir = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass);
 strcpy(_dir, dir);
 }
-ClassFileStream* ClassPathDirEntry::open_stream(const char* name) {
+ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {
 // construct full path name
 char path[JVM_MAXPATHLEN];
 if (jio_snprintf(path, sizeof(path), "%s%s%s", _dir, os::file_separator(), name) == -1) {
 return NULL;
 }
 (*ZipClose)(_zip);
 }
 FREE_C_HEAP_ARRAY(char, _zip_name, mtClass);
 }
-ClassFileStream* ClassPathZipEntry::open_stream(const char* name) {
+ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {
 // enable call to C land
 JavaThread* thread = JavaThread::current();
 ThreadToNativeFromVM ttn(thread);
 // check whether zip archive contains name
 jint filesize, name_len;
 if (ze == NULL) break;
 (*f)(ze->name, context);
 }
 }
-LazyClassPathEntry::LazyClassPathEntry(char* path, struct stat st) : ClassPathEntry() {
+LazyClassPathEntry::LazyClassPathEntry(char* path, const struct stat* st) : ClassPathEntry() {
 _path = strdup(path);
-_st = st;
+_st = *st;
 _meta_index = NULL;
 _resolved_entry = NULL;
+_has_error = false;
 }
 bool LazyClassPathEntry::is_jar_file() {
 return ((_st.st_mode & S_IFREG) == S_IFREG);
 }
-ClassPathEntry* LazyClassPathEntry::resolve_entry() {
+ClassPathEntry* LazyClassPathEntry::resolve_entry(TRAPS) {
 if (_resolved_entry != NULL) {
 return (ClassPathEntry*) _resolved_entry;
 }
 ClassPathEntry* new_entry = NULL;
-ClassLoader::create_class_path_entry(_path, _st, &new_entry, false);
+new_entry = ClassLoader::create_class_path_entry(_path, &_st, false, CHECK_NULL);
-assert(new_entry != NULL, "earlier code should have caught this");
 {
 ThreadCritical tc;
 if (_resolved_entry == NULL) {
 _resolved_entry = new_entry;
 return new_entry;
 assert(_resolved_entry != NULL, "bug in MT-safe resolution logic");
 delete new_entry;
 return (ClassPathEntry*) _resolved_entry;
 }
-ClassFileStream* LazyClassPathEntry::open_stream(const char* name) {
+ClassFileStream* LazyClassPathEntry::open_stream(const char* name, TRAPS) {
 if (_meta_index != NULL &&
 !_meta_index->may_contain(name)) {
 return NULL;
 }
-return resolve_entry()->open_stream(name);
+if (_has_error) {
+return NULL;
+}
+ClassPathEntry* cpe = resolve_entry(THREAD);
+if (cpe == NULL) {
+_has_error = true;
+return NULL;
+} else {
+return cpe->open_stream(name, THREAD);
+}
 }
 bool LazyClassPathEntry::is_lazy() {
 return true;
 }
 end++;
 }
 }
 }
-void ClassLoader::create_class_path_entry(char *path, struct stat st, ClassPathEntry **new_entry, bool lazy) {
+ClassPathEntry* ClassLoader::create_class_path_entry(char *path, const struct stat* st, bool lazy, TRAPS) {
 JavaThread* thread = JavaThread::current();
 if (lazy) {
-*new_entry = new LazyClassPathEntry(path, st);
+return new LazyClassPathEntry(path, st);
-return;
+}
-}
+ClassPathEntry* new_entry = NULL;
-if ((st.st_mode & S_IFREG) == S_IFREG) {
+if ((st->st_mode & S_IFREG) == S_IFREG) {
 // Regular file, should be a zip file
 // Canonicalized filename
 char canonical_path[JVM_MAXPATHLEN];
 if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {
 // This matches the classic VM
-EXCEPTION_MARK;
+THROW_MSG_(vmSymbols::java_io_IOException(), "Bad pathname", NULL);
-THROW_MSG(vmSymbols::java_io_IOException(), "Bad pathname");
 }
 char* error_msg = NULL;
 jzfile* zip;
 {
 // enable call to C land
 ThreadToNativeFromVM ttn(thread);
 HandleMark hm(thread);
 zip = (*ZipOpen)(canonical_path, &error_msg);
 }
 if (zip != NULL && error_msg == NULL) {
-*new_entry = new ClassPathZipEntry(zip, path);
+new_entry = new ClassPathZipEntry(zip, path);
 if (TraceClassLoading) {
 tty->print_cr("[Opened %s]", path);
 }
 } else {
 ResourceMark rm(thread);
 } else {
 int len = (int)(strlen(path) + strlen(error_msg) + 128);
 msg = NEW_RESOURCE_ARRAY(char, len); ;
 jio_snprintf(msg, len - 1, "error in opening JAR file <%s> %s", error_msg, path);
 }
-EXCEPTION_MARK;
+THROW_MSG_(vmSymbols::java_lang_ClassNotFoundException(), msg, NULL);
-THROW_MSG(vmSymbols::java_lang_ClassNotFoundException(), msg);
 }
 } else {
 // Directory
-*new_entry = new ClassPathDirEntry(path);
+new_entry = new ClassPathDirEntry(path);
 if (TraceClassLoading) {
 tty->print_cr("[Path %s]", path);
 }
 }
+return new_entry;
 }
 // Create a class path zip entry for a given path (return NULL if not found
 // or zip/JAR file cannot be opened)
 _last_entry = new_entry;
 }
 }
 }
-void ClassLoader::update_class_path_entry_list(const char *path,
+void ClassLoader::update_class_path_entry_list(char *path,
 bool check_for_duplicates) {
 struct stat st;
-if (os::stat((char *)path, &st) == 0) {
+if (os::stat(path, &st) == 0) {
 // File or directory found
 ClassPathEntry* new_entry = NULL;
-create_class_path_entry((char *)path, st, &new_entry, LazyBootClassLoader);
+Thread* THREAD = Thread::current();
+new_entry = create_class_path_entry(path, &st, LazyBootClassLoader, CHECK);
 // The kernel VM adds dynamically to the end of the classloader path and
 // doesn't reorder the bootclasspath which would break java.lang.Package
 // (see PackageInfo).
 // Add new entry to linked list
 if (!check_for_duplicates || !contains_entry(new_entry)) {
 PerfClassTraceTime vmtimer(perf_sys_class_lookup_time(),
 ((JavaThread*) THREAD)->get_thread_stat()->perf_timers_addr(),
 PerfClassTraceTime::CLASS_LOAD);
 ClassPathEntry* e = _first_entry;
 while (e != NULL) {
-stream = e->open_stream(name);
+stream = e->open_stream(name, CHECK_NULL);
 if (stream != NULL) {
 break;
 }
 e = e->next();
 ++classpath_index;
 // only used for debugging.
 return (len >= 6) && (strcasecmp(zip->name + len - 6, "rt.jar") == 0);
 }
 void LazyClassPathEntry::compile_the_world(Handle loader, TRAPS) {
-resolve_entry()->compile_the_world(loader, CHECK);
+ClassPathEntry* cpe = resolve_entry(THREAD);
+if (cpe != NULL) {
+cpe->compile_the_world(loader, CHECK);
+}
 }
 bool LazyClassPathEntry::is_rt_jar() {
-return resolve_entry()->is_rt_jar();
+Thread* THREAD = Thread::current();
+ClassPathEntry* cpe = resolve_entry(THREAD);
+return (cpe != NULL) ? cpe->is_jar_file() : false;
 }
 void ClassLoader::compile_the_world() {
 EXCEPTION_MARK;
 HandleMark hm(THREAD);
 if (HAS_PENDING_EXCEPTION &&
 !PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) {
 CLEAR_PENDING_EXCEPTION;
 }
 // The CHECK at the caller will propagate the exception out
+}
+/**
+* Returns if the given method should be compiled when doing compile-the-world.
+*
+* TODO:  This should be a private method in a CompileTheWorld class.
+*/
+static bool can_be_compiled(methodHandle m, int comp_level) {
+assert(CompileTheWorld, "must be");
+// It's not valid to compile a native wrapper for MethodHandle methods
+// that take a MemberName appendix since the bytecode signature is not
+// correct.
+vmIntrinsics::ID iid = m->intrinsic_id();
+if (MethodHandles::is_signature_polymorphic(iid) && MethodHandles::has_member_arg(iid)) {
+return false;
+}
+return CompilationPolicy::can_be_compiled(m, comp_level);
 }
 void ClassLoader::compile_the_world_in(char* name, Handle loader, TRAPS) {
 int len = (int)strlen(name);
 if (len > 6 && strcmp(".class", name + len - 6) == 0) {
 // Preload all classes to get around uncommon traps
 // Iterate over all methods in class
 int comp_level = CompilationPolicy::policy()->initial_compile_level();
 for (int n = 0; n < k->methods()->length(); n++) {
 methodHandle m (THREAD, k->methods()->at(n));
-if (CompilationPolicy::can_be_compiled(m, comp_level)) {
+if (can_be_compiled(m, comp_level)) {
 if (++_codecache_sweep_counter == CompileTheWorldSafepointInterval) {
 // Give sweeper a chance to keep up with CTW
 VM_ForceSafepoint op;
 VMThread::execute(&op);
 _codecache_sweep_counter = 0;
 // Force compilation
 CompileBroker::compile_method(m, InvocationEntryBci, comp_level,
 methodHandle(), 0, "CTW", THREAD);
 if (HAS_PENDING_EXCEPTION) {
 clear_pending_exception_if_not_oom(CHECK);
-tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name()->as_C_string());
+tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
 } else {
 _compile_the_world_method_counter++;
 }
 if (TieredCompilation && TieredStopAtLevel >= CompLevel_full_optimization) {
 // Clobber the first compile and force second tier compilation
 }
 CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_full_optimization,
 methodHandle(), 0, "CTW", THREAD);
 if (HAS_PENDING_EXCEPTION) {
 clear_pending_exception_if_not_oom(CHECK);
-tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name()->as_C_string());
+tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
 } else {
 _compile_the_world_method_counter++;
 }
 }
+} else {
+tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
 }
 nmethod* nm = m->code();
 if (nm != NULL) {
 // Throw out the code so that the code cache doesn't fill up

Mercurial > hg > truffle

comparison src/share/vm/classfile/classLoader.cpp @ 12355:cefad50507d8