*** old/src/share/vm/classfile/classLoader.cpp	Wed Apr  1 14:57:05 2015
--- new/src/share/vm/classfile/classLoader.cpp	Wed Apr  1 14:57:04 2015

*** 155,168 ****
--- 155,164 ----
  ClassPathEntry::ClassPathEntry() {
    set_next(NULL);
  }
  
  
  bool ClassPathEntry::is_lazy() {
    return false;
  }
  
  ClassPathDirEntry::ClassPathDirEntry(const char* dir) : ClassPathEntry() {
    char* copy = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass);
    strcpy(copy, dir);
    _dir = copy;
  }

*** 276,359 ****
--- 272,281 ----
      if (ze == NULL) break;
      (*f)(ze->name, context);
    }
  }
  
  LazyClassPathEntry::LazyClassPathEntry(const char* path, const struct stat* st, bool throw_exception) : ClassPathEntry() {
    _path = os::strdup_check_oom(path);
    _st = *st;
    _resolved_entry = NULL;
    _has_error = false;
    _throw_exception = throw_exception;
  }
  
  LazyClassPathEntry::~LazyClassPathEntry() {
    os::free((void*)_path);
  }
  
  bool LazyClassPathEntry::is_jar_file() {
    size_t len = strlen(_path);
    if (len < 4 || strcmp(_path + len - 4, ".jar") != 0) return false;
    return ((_st.st_mode & S_IFREG) == S_IFREG);
  }
  
  ClassPathEntry* LazyClassPathEntry::resolve_entry(TRAPS) {
    if (_resolved_entry != NULL) {
      return (ClassPathEntry*) _resolved_entry;
    }
    ClassPathEntry* new_entry = NULL;
    new_entry = ClassLoader::create_class_path_entry(_path, &_st, false, _throw_exception, CHECK_NULL);
    if (!_throw_exception && new_entry == NULL) {
      assert(!HAS_PENDING_EXCEPTION, "must be");
      return NULL;
    }
    {
      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, TRAPS) {
    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;
  }
  
  u1* LazyClassPathEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) {
    if (_has_error) {
      return NULL;
    }
    ClassPathEntry* cpe = resolve_entry(THREAD);
    if (cpe == NULL) {
      _has_error = true;
      return NULL;
    } else if (cpe->is_jar_file()) {
      return ((ClassPathZipEntry*)cpe)->open_entry(name, filesize, nul_terminate,THREAD);
    } else {
      ShouldNotReachHere();
      *filesize = 0;
      return NULL;
    }
  }
  
  ClassPathImageEntry::ClassPathImageEntry(char* name) : ClassPathEntry(), _image(new ImageFile(name)) {
    bool opened = _image->open();
    if (!opened) {
      _image = NULL;
    }

*** 537,551 ****
--- 459,470 ----
      }
    }
  }
  
  ClassPathEntry* ClassLoader::create_class_path_entry(const char *path, const struct stat* st,
-                                                      bool lazy, bool throw_exception, TRAPS) {
    JavaThread* thread = JavaThread::current();
    if (lazy) {
      return new LazyClassPathEntry(path, st, throw_exception);
    }
    ClassPathEntry* new_entry = NULL;
    if ((st->st_mode & S_IFREG) == S_IFREG) {
      // Regular file, should be a zip or image file
      // Canonicalized filename
      char canonical_path[JVM_MAXPATHLEN];

*** 664,674 ****
--- 583,593 ----
    struct stat st;
    if (os::stat(path, &st) == 0) {
      // File or directory found
      ClassPathEntry* new_entry = NULL;
      Thread* THREAD = Thread::current();
-     new_entry = create_class_path_entry(path, &st, LazyBootClassLoader, throw_exception, CHECK_(false));
      if (new_entry == NULL) {
        return false;
      }
      // The kernel VM adds dynamically to the end of the classloader path and
      // doesn't reorder the bootclasspath which would break java.lang.Package

*** 1317,1339 ****
--- 1236,1245 ----
  
  bool ClassPathZipEntry::is_jrt() {
    return false;
  }
  
  void LazyClassPathEntry::compile_the_world(Handle loader, TRAPS) {
    ClassPathEntry* cpe = resolve_entry(THREAD);
    if (cpe != NULL) {
      cpe->compile_the_world(loader, CHECK);
    }
  }
  
  bool LazyClassPathEntry::is_jrt() {
    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);
    ResourceMark rm(THREAD);
    // Make sure we don't run with background compilation