hotspot/src/share/vm/ci/ciObjectFactory.cpp
author coleenp
Mon, 24 Jun 2013 18:55:46 -0400
changeset 18439 725ce18186b3
parent 13974 791cba24758f
child 19710 2f8ca425504e
permissions -rw-r--r--
8016325: JVM hangs verifying system dictionary Summary: Minimize redundant verifications of Klasses. Reviewed-by: hseigel, jmasa
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
     2
 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    26
#include "ci/ciCallSite.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    27
#include "ci/ciInstance.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    28
#include "ci/ciInstanceKlass.hpp"
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
    29
#include "ci/ciMemberName.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    30
#include "ci/ciMethod.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    31
#include "ci/ciMethodData.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    32
#include "ci/ciMethodHandle.hpp"
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
    33
#include "ci/ciMethodType.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    34
#include "ci/ciNullObject.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    35
#include "ci/ciObjArray.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    36
#include "ci/ciObjArrayKlass.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    37
#include "ci/ciObject.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    38
#include "ci/ciObjectFactory.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    39
#include "ci/ciSymbol.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    40
#include "ci/ciTypeArray.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    41
#include "ci/ciTypeArrayKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    42
#include "ci/ciUtilities.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    43
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    44
#include "gc_interface/collectedHeap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    45
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    46
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    47
#include "oops/oop.inline2.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5882
diff changeset
    48
#include "runtime/fieldType.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// ciObjectFactory
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// This class handles requests for the creation of new instances
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// of ciObject and its subclasses.  It contains a caching mechanism
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// which ensures that for each oop, at most one ciObject is created.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// This invariant allows more efficient implementation of ciObject.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// Implementation note: the oop->ciObject mapping is represented as
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
// a table stored in an array.  Even though objects are moved
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
// by the garbage collector, the compactor preserves their relative
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// order; address comparison of oops (in perm space) is safe so long
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// as we prohibit GC during our comparisons.  We currently use binary
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
// search to find the oop in the table, and inserting a new oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
// into the table may be costly.  If this cost ends up being
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
// problematic the underlying data structure can be switched to some
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
// sort of balanced binary tree.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    67
GrowableArray<ciMetadata*>* ciObjectFactory::_shared_ci_metadata = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
ciSymbol*                 ciObjectFactory::_shared_ci_symbols[vmSymbols::SID_LIMIT];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
int                       ciObjectFactory::_shared_ident_limit = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
volatile bool             ciObjectFactory::_initialized = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
// ciObjectFactory::ciObjectFactory
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
ciObjectFactory::ciObjectFactory(Arena* arena,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
                                 int expected_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  for (int i = 0; i < NON_PERM_BUCKETS; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    _non_perm_bucket[i] = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  _non_perm_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  _next_ident = _shared_ident_limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  _arena = arena;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    85
  _ci_metadata = new (arena) GrowableArray<ciMetadata*>(arena, expected_size, 0, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  // If the shared ci objects exist append them to this factory's objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    89
  if (_shared_ci_metadata != NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    90
    _ci_metadata->appendAll(_shared_ci_metadata);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  _unloaded_methods = new (arena) GrowableArray<ciMethod*>(arena, 4, 0, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  _unloaded_klasses = new (arena) GrowableArray<ciKlass*>(arena, 8, 0, NULL);
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
    95
  _unloaded_instances = new (arena) GrowableArray<ciInstance*>(arena, 4, 0, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  _return_addresses =
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    new (arena) GrowableArray<ciReturnAddress*>(arena, 8, 0, NULL);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    98
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    99
  _symbols = new (arena) GrowableArray<ciSymbol*>(arena, 100, 0, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
// ciObjectFactory::ciObjectFactory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
void ciObjectFactory::initialize() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  ASSERT_IN_VM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  JavaThread* thread = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  HandleMark  handle_mark(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  // This Arena is long lived and exists in the resource mark of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  // compiler thread that initializes the initial ciObjectFactory which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  // creates the shared ciObjects that all later ciObjectFactories use.
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10734
diff changeset
   112
  Arena* arena = new (mtCompiler) Arena();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  ciEnv initial(arena);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  ciEnv* env = ciEnv::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  env->_factory->init_shared_objects();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  _initialized = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
void ciObjectFactory::init_shared_objects() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  _next_ident = 1;  // start numbering CI objects at 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   126
    // Create the shared symbols, but not in _shared_ci_metadata.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
    for (i = vmSymbols::FIRST_SID; i < vmSymbols::SID_LIMIT; i++) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   129
      Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   130
      assert(vmSymbols::find_sid(vmsym) == i, "1-1 mapping");
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   131
      ciSymbol* sym = new (_arena) ciSymbol(vmsym, (vmSymbols::SID) i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
      init_ident_of(sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
      _shared_ci_symbols[i] = sym;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    for (i = vmSymbols::FIRST_SID; i < vmSymbols::SID_LIMIT; i++) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   137
      Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
      ciSymbol* sym = vm_symbol_at((vmSymbols::SID) i);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   139
      assert(sym->get_symbol() == vmsym, "oop must match");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   141
    assert(ciSymbol::void_class_signature()->get_symbol() == vmSymbols::void_class_signature(), "spot check");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   145
  _ci_metadata = new (_arena) GrowableArray<ciMetadata*>(_arena, 64, 0, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  for (int i = T_BOOLEAN; i <= T_CONFLICT; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    BasicType t = (BasicType)i;
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13929
diff changeset
   149
    if (type2name(t) != NULL && t != T_OBJECT && t != T_ARRAY && t != T_NARROWOOP && t != T_NARROWKLASS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
      ciType::_basic_types[t] = new (_arena) ciType(t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
      init_ident_of(ciType::_basic_types[t]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  ciEnv::_null_object_instance = new (_arena) ciNullObject();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  init_ident_of(ciEnv::_null_object_instance);
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
   157
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
   158
#define WK_KLASS_DEFN(name, ignore_s, opt)                              \
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
   159
  if (SystemDictionary::name() != NULL) \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   160
    ciEnv::_##name = get_metadata(SystemDictionary::name())->as_instance_klass();
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
   161
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
   162
  WK_KLASSES_DO(WK_KLASS_DEFN)
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
   163
#undef WK_KLASS_DEFN
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   165
  for (int len = -1; len != _ci_metadata->length(); ) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   166
    len = _ci_metadata->length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    for (int i2 = 0; i2 < len; i2++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   168
      ciMetadata* obj = _ci_metadata->at(i2);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   169
      assert (obj->is_metadata(), "what else would it be?");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
      if (obj->is_loaded() && obj->is_instance_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
        obj->as_instance_klass()->compute_nonstatic_fields();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   176
  ciEnv::_unloaded_cisymbol = ciObjectFactory::get_symbol(vmSymbols::dummy_symbol());
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
   177
  // Create dummy InstanceKlass and ObjArrayKlass object and assign them idents
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  ciEnv::_unloaded_ciinstance_klass = new (_arena) ciInstanceKlass(ciEnv::_unloaded_cisymbol, NULL, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  init_ident_of(ciEnv::_unloaded_ciinstance_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  ciEnv::_unloaded_ciobjarrayklass = new (_arena) ciObjArrayKlass(ciEnv::_unloaded_cisymbol, ciEnv::_unloaded_ciinstance_klass, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  init_ident_of(ciEnv::_unloaded_ciobjarrayklass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  assert(ciEnv::_unloaded_ciobjarrayklass->is_obj_array_klass(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   184
  get_metadata(Universe::boolArrayKlassObj());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   185
  get_metadata(Universe::charArrayKlassObj());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   186
  get_metadata(Universe::singleArrayKlassObj());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   187
  get_metadata(Universe::doubleArrayKlassObj());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   188
  get_metadata(Universe::byteArrayKlassObj());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   189
  get_metadata(Universe::shortArrayKlassObj());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   190
  get_metadata(Universe::intArrayKlassObj());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   191
  get_metadata(Universe::longArrayKlassObj());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  assert(_non_perm_count == 0, "no shared non-perm objects");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  // The shared_ident_limit is the first ident number that will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // be used for non-shared objects.  That is, numbers less than
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  // this limit are permanently assigned to shared CI objects,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  // while the higher numbers are recycled afresh by each new ciEnv.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  _shared_ident_limit = _next_ident;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   203
  _shared_ci_metadata = _ci_metadata;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   206
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   207
ciSymbol* ciObjectFactory::get_symbol(Symbol* key) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   208
  vmSymbols::SID sid = vmSymbols::find_sid(key);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   209
  if (sid != vmSymbols::NO_SID) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   210
    // do not pollute the main cache with it
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   211
    return vm_symbol_at(sid);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   212
  }
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   213
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   214
  assert(vmSymbols::find_sid(key) == vmSymbols::NO_SID, "");
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   215
  ciSymbol* s = new (arena()) ciSymbol(key, vmSymbols::NO_SID);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   216
  _symbols->push(s);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   217
  return s;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   218
}
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   219
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   220
// Decrement the refcount when done on symbols referenced by this compilation.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   221
void ciObjectFactory::remove_symbols() {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   222
  for (int i = 0; i < _symbols->length(); i++) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   223
    ciSymbol* s = _symbols->at(i);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   224
    s->get_symbol()->decrement_refcount();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   225
  }
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   226
  // Since _symbols is resource allocated we're not allowed to delete it
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   227
  // but it'll go away just the same.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   228
}
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   229
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
// ciObjectFactory::get
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
// Get the ciObject corresponding to some oop.  If the ciObject has
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
// already been created, it is returned.  Otherwise, a new ciObject
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
// is created.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
ciObject* ciObjectFactory::get(oop key) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  ASSERT_IN_VM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   239
  assert(key == NULL || Universe::heap()->is_in_reserved(key), "must be");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   240
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   241
  NonPermObject* &bucket = find_non_perm(key);
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   242
  if (bucket != NULL) {
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   243
    return bucket->object();
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   244
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   246
  // The ciObject does not yet exist.  Create it and insert it
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   247
  // into the cache.
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   248
  Handle keyHandle(key);
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   249
  ciObject* new_object = create_new_object(keyHandle());
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   250
  assert(keyHandle() == new_object->get_oop(), "must be properly recorded");
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   251
  init_ident_of(new_object);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   252
  assert(Universe::heap()->is_in_reserved(new_object->get_oop()), "must be");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   253
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   254
  // Not a perm-space object.
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   255
  insert_non_perm(bucket, keyHandle(), new_object);
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   256
  return new_object;
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   257
}
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   258
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   259
// ------------------------------------------------------------------
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   260
// ciObjectFactory::get
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   261
//
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   262
// Get the ciObject corresponding to some oop.  If the ciObject has
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   263
// already been created, it is returned.  Otherwise, a new ciObject
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   264
// is created.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   265
ciMetadata* ciObjectFactory::get_metadata(Metadata* key) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   266
  ASSERT_IN_VM;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   267
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   268
#ifdef ASSERT
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   269
  if (CIObjectFactoryVerify) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   270
    Metadata* last = NULL;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   271
    for (int j = 0; j< _ci_metadata->length(); j++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   272
      Metadata* o = _ci_metadata->at(j)->constant_encoding();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   273
      assert(last < o, "out of order");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   274
      last = o;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   275
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   276
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   277
#endif // ASSERT
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   278
  int len = _ci_metadata->length();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   279
  int index = find(key, _ci_metadata);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   280
#ifdef ASSERT
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   281
  if (CIObjectFactoryVerify) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   282
    for (int i=0; i<_ci_metadata->length(); i++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   283
      if (_ci_metadata->at(i)->constant_encoding() == key) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   284
        assert(index == i, " bad lookup");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   285
      }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   286
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   287
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   288
#endif
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   289
  if (!is_found_at(index, key, _ci_metadata)) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   290
    // The ciObject does not yet exist.  Create it and insert it
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   291
    // into the cache.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   292
    ciMetadata* new_object = create_new_object(key);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   293
    init_ident_of(new_object);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   294
    assert(new_object->is_metadata(), "must be");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   295
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   296
    if (len != _ci_metadata->length()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
      // creating the new object has recursively entered new objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
      // into the table.  We need to recompute our index.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   299
      index = find(key, _ci_metadata);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   301
    assert(!is_found_at(index, key, _ci_metadata), "no double insert");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   302
    insert(index, new_object, _ci_metadata);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    return new_object;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   305
  return _ci_metadata->at(index)->as_metadata();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
// ciObjectFactory::create_new_object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
// Create a new ciObject from an oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
// Implementation note: this functionality could be virtual behavior
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
// of the oop itself.  For now, we explicitly marshal the object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
ciObject* ciObjectFactory::create_new_object(oop o) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   318
  if (o->is_instance()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    instanceHandle h_i(THREAD, (instanceOop)o);
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8076
diff changeset
   320
    if (java_lang_invoke_CallSite::is_instance(o))
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   321
      return new (arena()) ciCallSite(h_i);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
   322
    else if (java_lang_invoke_MemberName::is_instance(o))
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
   323
      return new (arena()) ciMemberName(h_i);
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8076
diff changeset
   324
    else if (java_lang_invoke_MethodHandle::is_instance(o))
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   325
      return new (arena()) ciMethodHandle(h_i);
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   326
    else if (java_lang_invoke_MethodType::is_instance(o))
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   327
      return new (arena()) ciMethodType(h_i);
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   328
    else
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4566
diff changeset
   329
      return new (arena()) ciInstance(h_i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  } else if (o->is_objArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    objArrayHandle h_oa(THREAD, (objArrayOop)o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    return new (arena()) ciObjArray(h_oa);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  } else if (o->is_typeArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    typeArrayHandle h_ta(THREAD, (typeArrayOop)o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    return new (arena()) ciTypeArray(h_ta);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   336
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   337
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   338
  // The oop is of some type not supported by the compiler interface.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   339
  ShouldNotReachHere();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   340
  return NULL;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   341
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   342
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   343
// ------------------------------------------------------------------
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   344
// ciObjectFactory::create_new_object
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   345
//
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   346
// Create a new ciObject from a Metadata*.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   347
//
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   348
// Implementation note: this functionality could be virtual behavior
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   349
// of the oop itself.  For now, we explicitly marshal the object.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   350
ciMetadata* ciObjectFactory::create_new_object(Metadata* o) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   351
  EXCEPTION_CONTEXT;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   352
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   353
  if (o->is_klass()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   354
    KlassHandle h_k(THREAD, (Klass*)o);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   355
    Klass* k = (Klass*)o;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   356
    if (k->oop_is_instance()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   357
      return new (arena()) ciInstanceKlass(h_k);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   358
    } else if (k->oop_is_objArray()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   359
      return new (arena()) ciObjArrayKlass(h_k);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   360
    } else if (k->oop_is_typeArray()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   361
      return new (arena()) ciTypeArrayKlass(h_k);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   362
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   363
  } else if (o->is_method()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   364
    methodHandle h_m(THREAD, (Method*)o);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   365
    return new (arena()) ciMethod(h_m);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   366
  } else if (o->is_methodData()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   367
    // Hold methodHandle alive - might not be necessary ???
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   368
    methodHandle h_m(THREAD, ((MethodData*)o)->method());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   369
    return new (arena()) ciMethodData((MethodData*)o);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  // The oop is of some type not supported by the compiler interface.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
//------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
// ciObjectFactory::get_unloaded_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
// Get the ciMethod representing an unloaded/unfound method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
// Implementation note: unloaded methods are currently stored in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
// an unordered array, requiring a linear-time lookup for each
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
// unloaded method.  This may need to change.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
ciMethod* ciObjectFactory::get_unloaded_method(ciInstanceKlass* holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
                                               ciSymbol*        name,
10734
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   387
                                               ciSymbol*        signature,
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   388
                                               ciInstanceKlass* accessor) {
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   389
  ciSignature* that = NULL;
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   390
  for (int i = 0; i < _unloaded_methods->length(); i++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
    ciMethod* entry = _unloaded_methods->at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
    if (entry->holder()->equals(holder) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
        entry->name()->equals(name) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
        entry->signature()->as_symbol()->equals(signature)) {
10734
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   395
      // Short-circuit slow resolve.
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   396
      if (entry->signature()->accessing_klass() == accessor) {
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   397
        // We've found a match.
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   398
        return entry;
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   399
      } else {
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   400
        // Lazily create ciSignature
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   401
        if (that == NULL)  that = new (arena()) ciSignature(accessor, constantPoolHandle(), signature);
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   402
        if (entry->signature()->equals(that)) {
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   403
          // We've found a match.
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   404
          return entry;
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   405
        }
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   406
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  // This is a new unloaded method.  Create it and stick it in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  // the cache.
10734
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 8725
diff changeset
   412
  ciMethod* new_method = new (arena()) ciMethod(holder, name, signature, accessor);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  init_ident_of(new_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  _unloaded_methods->append(new_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  return new_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
//------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
// ciObjectFactory::get_unloaded_klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
// Get a ciKlass representing an unloaded klass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
// Implementation note: unloaded klasses are currently stored in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
// an unordered array, requiring a linear-time lookup for each
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
// unloaded klass.  This may need to change.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
ciKlass* ciObjectFactory::get_unloaded_klass(ciKlass* accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
                                             ciSymbol* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
                                             bool create_if_not_found) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  oop loader = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  oop domain = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  if (accessing_klass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
    loader = accessing_klass->loader();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
    domain = accessing_klass->protection_domain();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  for (int i=0; i<_unloaded_klasses->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
    ciKlass* entry = _unloaded_klasses->at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
    if (entry->name()->equals(name) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
        entry->loader() == loader &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
        entry->protection_domain() == domain) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
      // We've found a match.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
      return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  if (!create_if_not_found)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  // This is a new unloaded klass.  Create it and stick it in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  // the cache.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  ciKlass* new_klass = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
   455
  // Two cases: this is an unloaded ObjArrayKlass or an
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   456
  // unloaded InstanceKlass.  Deal with both.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  if (name->byte_at(0) == '[') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
    // Decompose the name.'
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   459
    FieldArrayInfo fd;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   460
    BasicType element_type = FieldType::get_array_info(name->get_symbol(),
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   461
                                                       fd, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
      CURRENT_THREAD_ENV->record_out_of_memory_failure();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
      return ciEnv::_unloaded_ciobjarrayklass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
    }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   467
    int dimension = fd.dimension();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
    assert(element_type != T_ARRAY, "unsuccessful decomposition");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
    ciKlass* element_klass = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    if (element_type == T_OBJECT) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
      ciEnv *env = CURRENT_THREAD_ENV;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   472
      ciSymbol* ci_name = env->get_symbol(fd.object_key());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
      element_klass =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
        env->get_klass_by_name(accessing_klass, ci_name, false)->as_instance_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
      assert(dimension > 1, "one dimensional type arrays are always loaded.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
      // The type array itself takes care of one of the dimensions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
      dimension--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
   481
      // The element klass is a TypeArrayKlass.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
      element_klass = ciTypeArrayKlass::make(element_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
    new_klass = new (arena()) ciObjArrayKlass(name, element_klass, dimension);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
    jobject loader_handle = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
    jobject domain_handle = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
    if (accessing_klass != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
      loader_handle = accessing_klass->loader_handle();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
      domain_handle = accessing_klass->protection_domain_handle();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
    new_klass = new (arena()) ciInstanceKlass(name, loader_handle, domain_handle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  init_ident_of(new_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  _unloaded_klasses->append(new_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  return new_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   500
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   501
//------------------------------------------------------------------
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   502
// ciObjectFactory::get_unloaded_instance
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   503
//
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   504
// Get a ciInstance representing an as-yet undetermined instance of a given class.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   505
//
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   506
ciInstance* ciObjectFactory::get_unloaded_instance(ciInstanceKlass* instance_klass) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   507
  for (int i=0; i<_unloaded_instances->length(); i++) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   508
    ciInstance* entry = _unloaded_instances->at(i);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   509
    if (entry->klass()->equals(instance_klass)) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   510
      // We've found a match.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   511
      return entry;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   512
    }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   513
  }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   514
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   515
  // This is a new unloaded instance.  Create it and stick it in
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   516
  // the cache.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   517
  ciInstance* new_instance = new (arena()) ciInstance(instance_klass);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   518
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   519
  init_ident_of(new_instance);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   520
  _unloaded_instances->append(new_instance);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   521
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   522
  // make sure it looks the way we want:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   523
  assert(!new_instance->is_loaded(), "");
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   524
  assert(new_instance->klass() == instance_klass, "");
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   525
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   526
  return new_instance;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   527
}
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   528
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   529
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   530
//------------------------------------------------------------------
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   531
// ciObjectFactory::get_unloaded_klass_mirror
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   532
//
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   533
// Get a ciInstance representing an unresolved klass mirror.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   534
//
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   535
// Currently, this ignores the parameters and returns a unique unloaded instance.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   536
ciInstance* ciObjectFactory::get_unloaded_klass_mirror(ciKlass*  type) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   537
  assert(ciEnv::_Class_klass != NULL, "");
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   538
  return get_unloaded_instance(ciEnv::_Class_klass->as_instance_klass());
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   539
}
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   540
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   541
//------------------------------------------------------------------
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   542
// ciObjectFactory::get_unloaded_method_handle_constant
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   543
//
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   544
// Get a ciInstance representing an unresolved method handle constant.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   545
//
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   546
// Currently, this ignores the parameters and returns a unique unloaded instance.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   547
ciInstance* ciObjectFactory::get_unloaded_method_handle_constant(ciKlass*  holder,
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   548
                                                                 ciSymbol* name,
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   549
                                                                 ciSymbol* signature,
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   550
                                                                 int       ref_kind) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   551
  if (ciEnv::_MethodHandle_klass == NULL)  return NULL;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   552
  return get_unloaded_instance(ciEnv::_MethodHandle_klass->as_instance_klass());
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   553
}
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   554
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   555
//------------------------------------------------------------------
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   556
// ciObjectFactory::get_unloaded_method_type_constant
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   557
//
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   558
// Get a ciInstance representing an unresolved method type constant.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   559
//
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   560
// Currently, this ignores the parameters and returns a unique unloaded instance.
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   561
ciInstance* ciObjectFactory::get_unloaded_method_type_constant(ciSymbol* signature) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   562
  if (ciEnv::_MethodType_klass == NULL)  return NULL;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   563
  return get_unloaded_instance(ciEnv::_MethodType_klass->as_instance_klass());
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   564
}
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   565
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   566
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   567
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
//------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
// ciObjectFactory::get_empty_methodData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
// Get the ciMethodData representing the methodData for a method with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
// none.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
ciMethodData* ciObjectFactory::get_empty_methodData() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  ciMethodData* new_methodData = new (arena()) ciMethodData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  init_ident_of(new_methodData);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  return new_methodData;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
//------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
// ciObjectFactory::get_return_address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
// Get a ciReturnAddress for a specified bci.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
ciReturnAddress* ciObjectFactory::get_return_address(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  for (int i=0; i<_return_addresses->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    ciReturnAddress* entry = _return_addresses->at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
    if (entry->bci() == bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
      // We've found a match.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
      return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  ciReturnAddress* new_ret_addr = new (arena()) ciReturnAddress(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  init_ident_of(new_ret_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
  _return_addresses->append(new_ret_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  return new_ret_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
// ciObjectFactory::init_ident_of
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   600
void ciObjectFactory::init_ident_of(ciBaseObject* obj) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  obj->set_ident(_next_ident++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
// ciObjectFactory::find
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
// Use binary search to find the position of this oop in the cache.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
// If there is no entry in the cache corresponding to this oop, return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
// the position at which the oop should be inserted.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   610
int ciObjectFactory::find(Metadata* key, GrowableArray<ciMetadata*>* objects) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  int min = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  int max = objects->length()-1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  // print_contents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  while (max >= min) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
    int mid = (max + min) / 2;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   618
    Metadata* value = objects->at(mid)->constant_encoding();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
    if (value < key) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
      min = mid + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
    } else if (value > key) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
      max = mid - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
      return mid;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  return min;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
// ciObjectFactory::is_found_at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
// Verify that the binary seach found the given key.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   634
bool ciObjectFactory::is_found_at(int index, Metadata* key, GrowableArray<ciMetadata*>* objects) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  return (index < objects->length() &&
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   636
          objects->at(index)->constant_encoding() == key);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
// ciObjectFactory::insert
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
// Insert a ciObject into the table at some index.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   644
void ciObjectFactory::insert(int index, ciMetadata* obj, GrowableArray<ciMetadata*>* objects) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  int len = objects->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  if (len == index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
    objects->append(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
    objects->append(objects->at(len-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    int pos;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
    for (pos = len-2; pos >= index; pos--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
      objects->at_put(pos+1,objects->at(pos));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
    objects->at_put(index, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
static ciObjectFactory::NonPermObject* emptyBucket = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
// ciObjectFactory::find_non_perm
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
// Use a small hash table, hashed on the klass of the key.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
// If there is no entry in the cache corresponding to this oop, return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
// the null tail of the bucket into which the oop should be inserted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
ciObjectFactory::NonPermObject* &ciObjectFactory::find_non_perm(oop key) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   667
  assert(Universe::heap()->is_in_reserved_or_null(key), "must be");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   668
  ciMetadata* klass = get_metadata(key->klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  NonPermObject* *bp = &_non_perm_bucket[(unsigned) klass->hash() % NON_PERM_BUCKETS];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  for (NonPermObject* p; (p = (*bp)) != NULL; bp = &p->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
    if (is_equal(p, key))  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  return (*bp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
// Code for for NonPermObject
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
inline ciObjectFactory::NonPermObject::NonPermObject(ciObjectFactory::NonPermObject* &bucket, oop key, ciObject* object) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
  assert(ciObjectFactory::is_initialized(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  _object = object;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  _next = bucket;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  bucket = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
// ciObjectFactory::insert_non_perm
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
// Insert a ciObject into the non-perm table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
void ciObjectFactory::insert_non_perm(ciObjectFactory::NonPermObject* &where, oop key, ciObject* obj) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   695
  assert(Universe::heap()->is_in_reserved_or_null(key), "must be");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
  assert(&where != &emptyBucket, "must not try to fill empty bucket");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  NonPermObject* p = new (arena()) NonPermObject(where, key, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  assert(where == p && is_equal(p, key) && p->object() == obj, "entry must match");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  assert(find_non_perm(key) == p, "must find the same spot");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  ++_non_perm_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
// ciObjectFactory::vm_symbol_at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
// Get the ciSymbol corresponding to some index in vmSymbols.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
ciSymbol* ciObjectFactory::vm_symbol_at(int index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  assert(index >= vmSymbols::FIRST_SID && index < vmSymbols::SID_LIMIT, "oob");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  return _shared_ci_symbols[index];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
// ------------------------------------------------------------------
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   712
// ciObjectFactory::metadata_do
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   713
void ciObjectFactory::metadata_do(void f(Metadata*)) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   714
  if (_ci_metadata == NULL) return;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   715
  for (int j = 0; j< _ci_metadata->length(); j++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   716
    Metadata* o = _ci_metadata->at(j)->constant_encoding();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   717
    f(o);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   718
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   719
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   720
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   721
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
// ciObjectFactory::print_contents_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
void ciObjectFactory::print_contents_impl() {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   724
  int len = _ci_metadata->length();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   725
  tty->print_cr("ciObjectFactory (%d) meta data contents:", len);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  for (int i=0; i<len; i++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   727
    _ci_metadata->at(i)->print();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
// ciObjectFactory::print_contents
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
void ciObjectFactory::print_contents() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  GUARDED_VM_ENTRY(print_contents_impl();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
// ciObjectFactory::print
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
// Print debugging information about the object factory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
void ciObjectFactory::print() {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   745
  tty->print("<ciObjectFactory oops=%d metadata=%d unloaded_methods=%d unloaded_instances=%d unloaded_klasses=%d>",
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   746
             _non_perm_count, _ci_metadata->length(), _unloaded_methods->length(),
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   747
             _unloaded_instances->length(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
             _unloaded_klasses->length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
}