hotspot/src/share/vm/classfile/moduleEntry.cpp
author coleenp
Thu, 18 May 2017 08:17:52 -0400
changeset 46475 75902cea18af
parent 46458 3c12af929e7d
child 46729 c62d2e8b2728
permissions -rw-r--r--
8166848: Performance bug: SystemDictionary - optimization Summary: Check instead that a bucket isn't 10x the average Reviewed-by: iklam, gziemski, sspitsyn
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
     1
/*
44084
501b6d07e6dd 8168914: Crash in ClassLoaderData/JNIHandleBlock::oops_do during concurrent marking
ehelin
parents: 42866
diff changeset
     2
 * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
     4
 *
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
     7
 * published by the Free Software Foundation.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
     8
 *
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    13
 * accompanied this code).
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    14
 *
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    18
 *
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    21
 * questions.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    22
 *
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    23
 */
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    24
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    25
#include "precompiled.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    26
#include "classfile/classLoaderData.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    27
#include "classfile/javaClasses.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    28
#include "classfile/moduleEntry.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    29
#include "logging/log.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    30
#include "memory/resourceArea.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    31
#include "oops/symbol.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    32
#include "prims/jni.h"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    33
#include "runtime/handles.inline.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    34
#include "runtime/safepoint.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    35
#include "trace/traceMacros.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    36
#include "utilities/events.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    37
#include "utilities/growableArray.hpp"
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    38
#include "utilities/hashtable.inline.hpp"
37503
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
    39
#include "utilities/ostream.hpp"
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    40
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    41
ModuleEntry* ModuleEntryTable::_javabase_module = NULL;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    42
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    43
void ModuleEntry::set_location(Symbol* location) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    44
  if (_location != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    45
    // _location symbol's refcounts are managed by ModuleEntry,
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    46
    // must decrement the old one before updating.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    47
    _location->decrement_refcount();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    48
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    49
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    50
  _location = location;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    51
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    52
  if (location != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    53
    location->increment_refcount();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    54
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    55
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    56
42575
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    57
bool ModuleEntry::is_non_jdk_module() {
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    58
  ResourceMark rm;
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    59
  if (location() != NULL) {
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    60
    const char* loc = location()->as_C_string();
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    61
    if (strncmp(loc, "jrt:/java.", 10) != 0 && strncmp(loc, "jrt:/jdk.", 9) != 0) {
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    62
      return true;
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    63
    }
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    64
  }
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    65
  return false;
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    66
}
bd1618170c93 8165550: Add class loader names to ClassCastException message
rprotacio
parents: 42073
diff changeset
    67
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    68
void ModuleEntry::set_version(Symbol* version) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    69
  if (_version != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    70
    // _version symbol's refcounts are managed by ModuleEntry,
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    71
    // must decrement the old one before updating.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    72
    _version->decrement_refcount();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    73
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    74
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    75
  _version = version;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    76
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    77
  if (version != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    78
    version->increment_refcount();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    79
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    80
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    81
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    82
// Returns the shared ProtectionDomain
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    83
Handle ModuleEntry::shared_protection_domain() {
46271
979ebd346ecf 8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents: 42866
diff changeset
    84
  return Handle(Thread::current(), JNIHandles::resolve(_pd));
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    85
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    86
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    87
// Set the shared ProtectionDomain atomically
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    88
void ModuleEntry::set_shared_protection_domain(ClassLoaderData *loader_data,
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    89
                                               Handle pd_h) {
44084
501b6d07e6dd 8168914: Crash in ClassLoaderData/JNIHandleBlock::oops_do during concurrent marking
ehelin
parents: 42866
diff changeset
    90
  // Create a handle for the shared ProtectionDomain and save it atomically.
501b6d07e6dd 8168914: Crash in ClassLoaderData/JNIHandleBlock::oops_do during concurrent marking
ehelin
parents: 42866
diff changeset
    91
  // If someone beats us setting the _pd cache, the created handle is destroyed.
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    92
  jobject obj = loader_data->add_handle(pd_h);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    93
  if (Atomic::cmpxchg_ptr(obj, &_pd, NULL) != NULL) {
44084
501b6d07e6dd 8168914: Crash in ClassLoaderData/JNIHandleBlock::oops_do during concurrent marking
ehelin
parents: 42866
diff changeset
    94
    loader_data->remove_handle_unsafe(obj);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    95
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    96
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    97
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    98
// Returns true if this module can read module m
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
    99
bool ModuleEntry::can_read(ModuleEntry* m) const {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   100
  assert(m != NULL, "No module to lookup in this module's reads list");
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   101
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   102
  // Unnamed modules read everyone and all modules
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   103
  // read java.base.  If either of these conditions
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   104
  // hold, readability has been established.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   105
  if (!this->is_named() ||
41183
207b92e69457 8163406: The fixup_module_list must be protected by Module_lock when inserting new entries
lfoltan
parents: 39625
diff changeset
   106
      (m == ModuleEntryTable::javabase_moduleEntry())) {
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   107
    return true;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   108
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   109
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   110
  MutexLocker m1(Module_lock);
42866
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   111
  // This is a guard against possible race between agent threads that redefine
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   112
  // or retransform classes in this module. Only one of them is adding the
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   113
  // default read edges to the unnamed modules of the boot and app class loaders
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   114
  // with an upcall to jdk.internal.module.Modules.transformedByAgent.
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   115
  // At the same time, another thread can instrument the module classes by
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   116
  // injecting dependencies that require the default read edges for resolution.
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   117
  if (this->has_default_read_edges() && !m->is_named()) {
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   118
    ClassLoaderData* cld = m->loader_data();
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   119
    if (cld->is_the_null_class_loader_data() || cld->is_system_class_loader_data()) {
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   120
      return true; // default read edge
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   121
    }
97de8ed6c6b3 8139566: need proper sync for adding default read edges
sspitsyn
parents: 42639
diff changeset
   122
  }
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   123
  if (!has_reads_list()) {
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   124
    return false;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   125
  } else {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   126
    return _reads->contains(m);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   127
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   128
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   129
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   130
// Add a new module to this module's reads list
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   131
void ModuleEntry::add_read(ModuleEntry* m) {
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   132
  // Unnamed module is special cased and can read all modules
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   133
  if (!is_named()) {
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   134
    return;
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   135
  }
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   136
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   137
  MutexLocker m1(Module_lock);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   138
  if (m == NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   139
    set_can_read_all_unnamed();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   140
  } else {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   141
    if (_reads == NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   142
      // Lazily create a module's reads list
38733
2b65f4db449e 8156156: Add module specific NMT MemoryType
hseigel
parents: 38014
diff changeset
   143
      _reads = new (ResourceObj::C_HEAP, mtModule)GrowableArray<ModuleEntry*>(MODULE_READS_SIZE, true);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   144
    }
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   145
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   146
    // Determine, based on this newly established read edge to module m,
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   147
    // if this module's read list should be walked at a GC safepoint.
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   148
    set_read_walk_required(m->loader_data());
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   149
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   150
    // Establish readability to module m
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   151
    _reads->append_if_missing(m);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   152
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   153
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   154
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   155
// If the module's loader, that a read edge is being established to, is
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   156
// not the same loader as this module's and is not one of the 3 builtin
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   157
// class loaders, then this module's reads list must be walked at GC
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   158
// safepoint. Modules have the same life cycle as their defining class
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   159
// loaders and should be removed if dead.
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   160
void ModuleEntry::set_read_walk_required(ClassLoaderData* m_loader_data) {
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   161
  assert(is_named(), "Cannot call set_read_walk_required on unnamed module");
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   162
  assert_locked_or_safepoint(Module_lock);
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   163
  if (!_must_walk_reads &&
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   164
      loader_data() != m_loader_data &&
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   165
      !m_loader_data->is_builtin_class_loader_data()) {
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   166
    _must_walk_reads = true;
44993
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   167
    if (log_is_enabled(Trace, module)) {
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   168
      ResourceMark rm;
44993
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   169
      log_trace(module)("ModuleEntry::set_read_walk_required(): module %s reads list must be walked",
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   170
                        (name() != NULL) ? name()->as_C_string() : UNNAMED_MODULE);
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   171
    }
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   172
  }
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   173
}
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   174
46404
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   175
// Set whether the module is open, i.e. all its packages are unqualifiedly exported
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   176
void ModuleEntry::set_is_open(bool is_open) {
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   177
  assert_lock_strong(Module_lock);
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   178
  _is_open = is_open;
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   179
}
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   180
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   181
// Returns true if the module has a non-empty reads list. As such, the unnamed
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   182
// module will return false.
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   183
bool ModuleEntry::has_reads_list() const {
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   184
  assert_locked_or_safepoint(Module_lock);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   185
  return ((_reads != NULL) && !_reads->is_empty());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   186
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   187
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   188
// Purge dead module entries out of reads list.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   189
void ModuleEntry::purge_reads() {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   190
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   191
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   192
  if (_must_walk_reads && has_reads_list()) {
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   193
    // This module's _must_walk_reads flag will be reset based
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   194
    // on the remaining live modules on the reads list.
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   195
    _must_walk_reads = false;
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   196
44993
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   197
    if (log_is_enabled(Trace, module)) {
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   198
      ResourceMark rm;
44993
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   199
      log_trace(module)("ModuleEntry::purge_reads(): module %s reads list being walked",
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   200
                        (name() != NULL) ? name()->as_C_string() : UNNAMED_MODULE);
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   201
    }
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   202
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   203
    // Go backwards because this removes entries that are dead.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   204
    int len = _reads->length();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   205
    for (int idx = len - 1; idx >= 0; idx--) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   206
      ModuleEntry* module_idx = _reads->at(idx);
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   207
      ClassLoaderData* cld_idx = module_idx->loader_data();
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   208
      if (cld_idx->is_unloading()) {
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   209
        _reads->delete_at(idx);
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   210
      } else {
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   211
        // Update the need to walk this module's reads based on live modules
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   212
        set_read_walk_required(cld_idx);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   213
      }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   214
    }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   215
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   216
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   217
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   218
void ModuleEntry::module_reads_do(ModuleClosure* const f) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   219
  assert_locked_or_safepoint(Module_lock);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   220
  assert(f != NULL, "invariant");
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   221
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   222
  if (has_reads_list()) {
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   223
    int reads_len = _reads->length();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   224
    for (int i = 0; i < reads_len; ++i) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   225
      f->do_module(_reads->at(i));
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   226
    }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   227
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   228
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   229
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   230
void ModuleEntry::delete_reads() {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   231
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   232
  delete _reads;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   233
  _reads = NULL;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   234
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   235
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   236
ModuleEntry* ModuleEntry::create_unnamed_module(ClassLoaderData* cld) {
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   237
  // The java.lang.Module for this loader's
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   238
  // corresponding unnamed module can be found in the java.lang.ClassLoader object.
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   239
  oop module = java_lang_ClassLoader::unnamedModule(cld->class_loader());
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   240
  ModuleEntry* unnamed_module = new_unnamed_module_entry(Handle(Thread::current(), module), cld);
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   241
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   242
  // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   243
  // object.
46388
jwilhelm
parents: 46387 44520
diff changeset
   244
  java_lang_Module::set_module_entry(module, unnamed_module);
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   245
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   246
  return unnamed_module;
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   247
}
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   248
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   249
ModuleEntry* ModuleEntry::create_boot_unnamed_module(ClassLoaderData* cld) {
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   250
  // For the boot loader, the java.lang.Module for the unnamed module
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   251
  // is not known until a call to JVM_SetBootLoaderUnnamedModule is made. At
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   252
  // this point initially create the ModuleEntry for the unnamed module.
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   253
  ModuleEntry* unnamed_module = new_unnamed_module_entry(Handle(), cld);
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   254
  assert(unnamed_module != NULL, "boot loader unnamed module should not be null");
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   255
  return unnamed_module;
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   256
}
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   257
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   258
// When creating an unnamed module, this is called without holding the Module_lock.
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   259
// This is okay because the unnamed module gets created before the ClassLoaderData
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   260
// is available to other threads.
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   261
ModuleEntry* ModuleEntry::new_unnamed_module_entry(Handle module_handle, ClassLoaderData* cld) {
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   262
  ModuleEntry* entry = (ModuleEntry*) NEW_C_HEAP_ARRAY(char, sizeof(ModuleEntry), mtModule);
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   263
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   264
  // Initialize everything BasicHashtable would
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   265
  entry->set_next(NULL);
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   266
  entry->set_hash(0);
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   267
  entry->set_literal(NULL);
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   268
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   269
  // Initialize fields specific to a ModuleEntry
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   270
  entry->init();
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   271
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   272
  // Unnamed modules can read all other unnamed modules.
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   273
  entry->set_can_read_all_unnamed();
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   274
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   275
  if (!module_handle.is_null()) {
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   276
    entry->set_module(cld->add_handle(module_handle));
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   277
  }
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   278
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   279
  entry->set_loader_data(cld);
46404
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   280
  entry->_is_open = true;
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   281
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   282
  TRACE_INIT_ID(entry);
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   283
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   284
  return entry;
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   285
}
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   286
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   287
void ModuleEntry::delete_unnamed_module() {
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   288
  // Do not need unlink_entry() since the unnamed module is not in the hashtable
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   289
  FREE_C_HEAP_ARRAY(char, this);
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   290
}
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   291
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   292
ModuleEntryTable::ModuleEntryTable(int table_size)
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   293
  : Hashtable<Symbol*, mtModule>(table_size, sizeof(ModuleEntry))
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   294
{
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   295
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   296
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   297
ModuleEntryTable::~ModuleEntryTable() {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   298
  assert_locked_or_safepoint(Module_lock);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   299
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   300
  // Walk through all buckets and all entries in each bucket,
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   301
  // freeing each entry.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   302
  for (int i = 0; i < table_size(); ++i) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   303
    for (ModuleEntry* m = bucket(i); m != NULL;) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   304
      ModuleEntry* to_remove = m;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   305
      // read next before freeing.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   306
      m = m->next();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   307
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   308
      ResourceMark rm;
44993
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   309
      if (to_remove->name() != NULL) {
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   310
        log_info(module, unload)("unloading module %s", to_remove->name()->as_C_string());
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   311
      }
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   312
      log_debug(module)("ModuleEntryTable: deleting module: %s", to_remove->name() != NULL ?
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   313
                        to_remove->name()->as_C_string() : UNNAMED_MODULE);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   314
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   315
      // Clean out the C heap allocated reads list first before freeing the entry
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   316
      to_remove->delete_reads();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   317
      if (to_remove->name() != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   318
        to_remove->name()->decrement_refcount();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   319
      }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   320
      if (to_remove->version() != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   321
        to_remove->version()->decrement_refcount();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   322
      }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   323
      if (to_remove->location() != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   324
        to_remove->location()->decrement_refcount();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   325
      }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   326
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   327
      // Unlink from the Hashtable prior to freeing
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   328
      unlink_entry(to_remove);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   329
      FREE_C_HEAP_ARRAY(char, to_remove);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   330
    }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   331
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   332
  assert(number_of_entries() == 0, "should have removed all entries");
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   333
  assert(new_entry_free_list() == NULL, "entry present on ModuleEntryTable's free list");
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   334
  free_buckets();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   335
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   336
46404
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   337
ModuleEntry* ModuleEntryTable::new_entry(unsigned int hash, Handle module_handle,
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   338
                                         bool is_open, Symbol* name,
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   339
                                         Symbol* version, Symbol* location,
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   340
                                         ClassLoaderData* loader_data) {
39290
0cc9f5028562 8156871: Possible concurrency issue with JVM_AddModuleExports
lfoltan
parents: 38733
diff changeset
   341
  assert(Module_lock->owned_by_self(), "should have the Module_lock");
38733
2b65f4db449e 8156156: Add module specific NMT MemoryType
hseigel
parents: 38014
diff changeset
   342
  ModuleEntry* entry = (ModuleEntry*) NEW_C_HEAP_ARRAY(char, entry_size(), mtModule);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   343
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   344
  // Initialize everything BasicHashtable would
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   345
  entry->set_next(NULL);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   346
  entry->set_hash(hash);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   347
  entry->set_literal(name);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   348
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   349
  // Initialize fields specific to a ModuleEntry
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   350
  entry->init();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   351
  if (name != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   352
    name->increment_refcount();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   353
  } else {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   354
    // Unnamed modules can read all other unnamed modules.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   355
    entry->set_can_read_all_unnamed();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   356
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   357
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   358
  if (!module_handle.is_null()) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   359
    entry->set_module(loader_data->add_handle(module_handle));
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   360
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   361
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   362
  entry->set_loader_data(loader_data);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   363
  entry->set_version(version);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   364
  entry->set_location(location);
46404
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   365
  entry->set_is_open(is_open);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   366
42634
7459867ebf98 8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents: 42575
diff changeset
   367
  if (ClassLoader::is_in_patch_mod_entries(name)) {
7459867ebf98 8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents: 42575
diff changeset
   368
    entry->set_is_patched();
44993
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   369
    if (log_is_enabled(Trace, module, patch)) {
42634
7459867ebf98 8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents: 42575
diff changeset
   370
      ResourceMark rm;
44993
f61bcd80ec1f 8178380: Module system implementation refresh (5/2017)
alanb
parents: 44520
diff changeset
   371
      log_trace(module, patch)("Marked module %s as patched from --patch-module", name->as_C_string());
42634
7459867ebf98 8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents: 42575
diff changeset
   372
    }
7459867ebf98 8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents: 42575
diff changeset
   373
  }
7459867ebf98 8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents: 42575
diff changeset
   374
42639
762117d57d05 8170672: Event-based tracing to support classloader instances
mgronlun
parents: 42636
diff changeset
   375
  TRACE_INIT_ID(entry);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   376
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   377
  return entry;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   378
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   379
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   380
void ModuleEntryTable::add_entry(int index, ModuleEntry* new_entry) {
39290
0cc9f5028562 8156871: Possible concurrency issue with JVM_AddModuleExports
lfoltan
parents: 38733
diff changeset
   381
  assert(Module_lock->owned_by_self(), "should have the Module_lock");
38733
2b65f4db449e 8156156: Add module specific NMT MemoryType
hseigel
parents: 38014
diff changeset
   382
  Hashtable<Symbol*, mtModule>::add_entry(index, (HashtableEntry<Symbol*, mtModule>*)new_entry);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   383
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   384
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   385
ModuleEntry* ModuleEntryTable::locked_create_entry_or_null(Handle module_handle,
46404
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   386
                                                           bool is_open,
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   387
                                                           Symbol* module_name,
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   388
                                                           Symbol* module_version,
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   389
                                                           Symbol* module_location,
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   390
                                                           ClassLoaderData* loader_data) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   391
  assert(module_name != NULL, "ModuleEntryTable locked_create_entry_or_null should never be called for unnamed module.");
39290
0cc9f5028562 8156871: Possible concurrency issue with JVM_AddModuleExports
lfoltan
parents: 38733
diff changeset
   392
  assert(Module_lock->owned_by_self(), "should have the Module_lock");
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   393
  // Check if module already exists.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   394
  if (lookup_only(module_name) != NULL) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   395
    return NULL;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   396
  } else {
46404
ae62ba99a1a7 8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents: 46388
diff changeset
   397
    ModuleEntry* entry = new_entry(compute_hash(module_name), module_handle, is_open, module_name,
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   398
                                   module_version, module_location, loader_data);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   399
    add_entry(index_for(module_name), entry);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   400
    return entry;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   401
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   402
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   403
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   404
// lookup_only by Symbol* to find a ModuleEntry.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   405
ModuleEntry* ModuleEntryTable::lookup_only(Symbol* name) {
46387
c46632622b17 8176472: Lazily create ModuleEntryTable
rprotacio
parents: 46338
diff changeset
   406
  assert(name != NULL, "name cannot be NULL");
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   407
  int index = index_for(name);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   408
  for (ModuleEntry* m = bucket(index); m != NULL; m = m->next()) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   409
    if (m->name()->fast_compare(name) == 0) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   410
      return m;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   411
    }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   412
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   413
  return NULL;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   414
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   415
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   416
// Remove dead modules from all other alive modules' reads list.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   417
// This should only occur at class unloading.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   418
void ModuleEntryTable::purge_all_module_reads() {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   419
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   420
  for (int i = 0; i < table_size(); i++) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   421
    for (ModuleEntry* entry = bucket(i);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   422
                      entry != NULL;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   423
                      entry = entry->next()) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   424
      entry->purge_reads();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   425
    }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   426
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   427
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   428
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   429
void ModuleEntryTable::finalize_javabase(Handle module_handle, Symbol* version, Symbol* location) {
39290
0cc9f5028562 8156871: Possible concurrency issue with JVM_AddModuleExports
lfoltan
parents: 38733
diff changeset
   430
  assert(Module_lock->owned_by_self(), "should have the Module_lock");
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   431
  ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   432
  ModuleEntryTable* module_table = boot_loader_data->modules();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   433
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   434
  assert(module_table != NULL, "boot loader's ModuleEntryTable not defined");
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   435
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   436
  if (module_handle.is_null()) {
42636
aafc434ba580 8169734: Update uses of string "java.base" to macro
rprotacio
parents: 42634
diff changeset
   437
    fatal("Unable to finalize module definition for " JAVA_BASE_NAME);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   438
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   439
44520
0553e129e0ec 8177530: Module system implementation refresh (4/2017)
alanb
parents: 44084
diff changeset
   440
  // Set java.lang.Module, version and location for java.base
41183
207b92e69457 8163406: The fixup_module_list must be protected by Module_lock when inserting new entries
lfoltan
parents: 39625
diff changeset
   441
  ModuleEntry* jb_module = javabase_moduleEntry();
42636
aafc434ba580 8169734: Update uses of string "java.base" to macro
rprotacio
parents: 42634
diff changeset
   442
  assert(jb_module != NULL, JAVA_BASE_NAME " ModuleEntry not defined");
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   443
  jb_module->set_version(version);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   444
  jb_module->set_location(location);
41183
207b92e69457 8163406: The fixup_module_list must be protected by Module_lock when inserting new entries
lfoltan
parents: 39625
diff changeset
   445
  // Once java.base's ModuleEntry _module field is set with the known
44520
0553e129e0ec 8177530: Module system implementation refresh (4/2017)
alanb
parents: 44084
diff changeset
   446
  // java.lang.Module, java.base is considered "defined" to the VM.
41183
207b92e69457 8163406: The fixup_module_list must be protected by Module_lock when inserting new entries
lfoltan
parents: 39625
diff changeset
   447
  jb_module->set_module(boot_loader_data->add_handle(module_handle));
207b92e69457 8163406: The fixup_module_list must be protected by Module_lock when inserting new entries
lfoltan
parents: 39625
diff changeset
   448
44520
0553e129e0ec 8177530: Module system implementation refresh (4/2017)
alanb
parents: 44084
diff changeset
   449
  // Store pointer to the ModuleEntry for java.base in the java.lang.Module object.
0553e129e0ec 8177530: Module system implementation refresh (4/2017)
alanb
parents: 44084
diff changeset
   450
  java_lang_Module::set_module_entry(module_handle(), jb_module);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   451
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   452
44520
0553e129e0ec 8177530: Module system implementation refresh (4/2017)
alanb
parents: 44084
diff changeset
   453
// Within java.lang.Class instances there is a java.lang.Module field that must
0553e129e0ec 8177530: Module system implementation refresh (4/2017)
alanb
parents: 44084
diff changeset
   454
// be set with the defining module.  During startup, prior to java.base's definition,
0553e129e0ec 8177530: Module system implementation refresh (4/2017)
alanb
parents: 44084
diff changeset
   455
// classes needing their module field set are added to the fixup_module_list.
0553e129e0ec 8177530: Module system implementation refresh (4/2017)
alanb
parents: 44084
diff changeset
   456
// Their module field is set once java.base's java.lang.Module is known to the VM.
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   457
void ModuleEntryTable::patch_javabase_entries(Handle module_handle) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   458
  if (module_handle.is_null()) {
42636
aafc434ba580 8169734: Update uses of string "java.base" to macro
rprotacio
parents: 42634
diff changeset
   459
    fatal("Unable to patch the module field of classes loaded prior to "
44520
0553e129e0ec 8177530: Module system implementation refresh (4/2017)
alanb
parents: 44084
diff changeset
   460
          JAVA_BASE_NAME "'s definition, invalid java.lang.Module");
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   461
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   462
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   463
  // Do the fixups for the basic primitive types
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   464
  java_lang_Class::set_module(Universe::int_mirror(), module_handle());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   465
  java_lang_Class::set_module(Universe::float_mirror(), module_handle());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   466
  java_lang_Class::set_module(Universe::double_mirror(), module_handle());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   467
  java_lang_Class::set_module(Universe::byte_mirror(), module_handle());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   468
  java_lang_Class::set_module(Universe::bool_mirror(), module_handle());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   469
  java_lang_Class::set_module(Universe::char_mirror(), module_handle());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   470
  java_lang_Class::set_module(Universe::long_mirror(), module_handle());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   471
  java_lang_Class::set_module(Universe::short_mirror(), module_handle());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   472
  java_lang_Class::set_module(Universe::void_mirror(), module_handle());
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   473
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   474
  // Do the fixups for classes that have already been created.
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   475
  GrowableArray <Klass*>* list = java_lang_Class::fixup_module_field_list();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   476
  int list_length = list->length();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   477
  for (int i = 0; i < list_length; i++) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   478
    Klass* k = list->at(i);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   479
    assert(k->is_klass(), "List should only hold classes");
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46271
diff changeset
   480
    java_lang_Class::fixup_module_field(k, module_handle);
38014
8731fa11f766 8152949: Jigsaw crash when Klass in _fixup_module_field_list is unloaded
lfoltan
parents: 37503
diff changeset
   481
    k->class_loader_data()->dec_keep_alive();
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   482
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   483
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   484
  delete java_lang_Class::fixup_module_field_list();
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   485
  java_lang_Class::set_fixup_module_field_list(NULL);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   486
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   487
37503
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   488
void ModuleEntryTable::print(outputStream* st) {
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   489
  st->print_cr("Module Entry Table (table_size=%d, entries=%d)",
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   490
               table_size(), number_of_entries());
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   491
  for (int i = 0; i < table_size(); i++) {
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   492
    for (ModuleEntry* probe = bucket(i);
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   493
                              probe != NULL;
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   494
                              probe = probe->next()) {
37503
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   495
      probe->print(st);
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   496
    }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   497
  }
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   498
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   499
37503
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   500
void ModuleEntry::print(outputStream* st) {
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   501
  ResourceMark rm;
39625
8702e5b9bfed 8160356: invalid suffix on literal warning is occurred with GCC 6
kbarrett
parents: 39616
diff changeset
   502
  st->print_cr("entry " PTR_FORMAT " name %s module " PTR_FORMAT " loader %s version %s location %s strict %s next " PTR_FORMAT,
37503
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   503
               p2i(this),
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   504
               name() == NULL ? UNNAMED_MODULE : name()->as_C_string(),
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   505
               p2i(module()),
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   506
               loader_data()->loader_name(),
37503
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   507
               version() != NULL ? version()->as_C_string() : "NULL",
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   508
               location() != NULL ? location()->as_C_string() : "NULL",
77531df4dad3 8152845: Improve PackageEntry and ModuleEntry print methods for future logging
rprotacio
parents: 36508
diff changeset
   509
               BOOL_TO_STR(!can_read_all_unnamed()), p2i(next()));
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   510
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   511
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   512
void ModuleEntryTable::verify() {
46475
75902cea18af 8166848: Performance bug: SystemDictionary - optimization
coleenp
parents: 46458
diff changeset
   513
  verify_table<ModuleEntry>("Module Entry Table");
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   514
}
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   515
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   516
void ModuleEntry::verify() {
39616
f82b1f888578 8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents: 39290
diff changeset
   517
  guarantee(loader_data() != NULL, "A module entry must be associated with a loader.");
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents:
diff changeset
   518
}