hotspot/src/share/vm/oops/constantPoolOop.cpp
author coleenp
Fri, 09 Jan 2009 14:39:07 -0500
changeset 1892 6cb9181f6061
parent 1889 24b003a6fe46
parent 1623 a0dd9009e992
child 2105 347008ce7984
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
1623
a0dd9009e992 6785258: Update copyright year
xdono
parents: 1550
diff changeset
     2
 * Copyright 1997-2008 Sun Microsystems, Inc.  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
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
# include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
# include "incls/_constantPoolOop.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    28
void constantPoolOopDesc::set_flag_at(FlagBit fb) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    29
  const int MAX_STATE_CHANGES = 2;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    30
  for (int i = MAX_STATE_CHANGES + 10; i > 0; i--) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    31
    int oflags = _flags;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    32
    int nflags = oflags | (1 << (int)fb);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    33
    if (Atomic::cmpxchg(nflags, &_flags, oflags) == oflags)
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    34
      return;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    35
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    36
  assert(false, "failed to cmpxchg flags");
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    37
  _flags |= (1 << (int)fb);     // better than nothing
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    38
}
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
    39
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
klassOop constantPoolOopDesc::klass_at_impl(constantPoolHandle this_oop, int which, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  // A resolved constantPool entry will contain a klassOop, otherwise a symbolOop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  // tag is not updated atomicly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  oop entry = *(this_oop->obj_at_addr(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  if (entry->is_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
    // Already resolved - return entry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
    return (klassOop)entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  // Acquire lock on constant oop while doing update. After we get the lock, we check if another object
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  // already has updated the object
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  assert(THREAD->is_Java_thread(), "must be a Java thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  bool do_resolve = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  bool in_error = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  symbolHandle name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  Handle       loader;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  { ObjectLocker ol(this_oop, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    if (this_oop->tag_at(which).is_unresolved_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
      if (this_oop->tag_at(which).is_unresolved_klass_in_error()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
        in_error = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
        do_resolve = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
        name   = symbolHandle(THREAD, this_oop->unresolved_klass_at(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
        loader = Handle(THREAD, instanceKlass::cast(this_oop->pool_holder())->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  } // unlocking constantPool
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  // The original attempt to resolve this constant pool entry failed so find the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  // original error and throw it again (JVMS 5.4.3).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  if (in_error) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    symbolOop error = SystemDictionary::find_resolution_error(this_oop, which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    guarantee(error != (symbolOop)NULL, "tag mismatch with resolution error table");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    // exception text will be the class name
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    THROW_MSG_0(error, className);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  if (do_resolve) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    // this_oop must be unlocked during resolve_or_fail
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    Handle h_prot (THREAD, protection_domain);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    klassOop k_oop = SystemDictionary::resolve_or_fail(name, loader, h_prot, true, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    KlassHandle k;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    if (!HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
      k = KlassHandle(THREAD, k_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
      // Do access check for klasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
      verify_constant_pool_resolve(this_oop, k, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    // Failed to resolve class. We must record the errors so that subsequent attempts
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    // to resolve this constant pool entry fail with the same error (JVMS 5.4.3).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
      ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
      symbolHandle error(PENDING_EXCEPTION->klass()->klass_part()->name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
      bool throw_orig_error = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
        ObjectLocker ol (this_oop, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
        // some other thread has beaten us and has resolved the class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
        if (this_oop->tag_at(which).is_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
          CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
          entry = this_oop->resolved_klass_at(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
          return (klassOop)entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
        if (!PENDING_EXCEPTION->
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
              is_a(SystemDictionary::linkageError_klass())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
          // Just throw the exception and don't prevent these classes from
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
          // being loaded due to virtual machine errors like StackOverflow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
          // and OutOfMemoryError, etc, or if the thread was hit by stop()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
          // Needs clarification to section 5.4.3 of the VM spec (see 6308271)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
        else if (!this_oop->tag_at(which).is_unresolved_klass_in_error()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
          SystemDictionary::add_resolution_error(this_oop, which, error);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
          this_oop->tag_at_put(which, JVM_CONSTANT_UnresolvedClassInError);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
          // some other thread has put the class in error state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
          error = symbolHandle(SystemDictionary::find_resolution_error(this_oop, which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
          assert(!error.is_null(), "checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
          throw_orig_error = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
      } // unlocked
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
      if (throw_orig_error) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
        CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
        ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
        const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
        THROW_MSG_0(error, className);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
      return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    if (TraceClassResolution && !k()->klass_part()->oop_is_array()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
      // skip resolving the constant pool so that this code get's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
      // called the next time some bytecodes refer to this class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
      ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
      int line_number = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
      const char * source_file = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
      if (JavaThread::current()->has_last_Java_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
        // try to identify the method which called this function.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
        vframeStream vfst(JavaThread::current());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
        if (!vfst.at_end()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
          line_number = vfst.method()->line_number_from_bci(vfst.bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
          symbolOop s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
          if (s != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
            source_file = s->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
      if (k() != this_oop->pool_holder()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
        // only print something if the classes are different
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
        if (source_file != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
          tty->print("RESOLVE %s %s %s:%d\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
                     instanceKlass::cast(this_oop->pool_holder())->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
                     instanceKlass::cast(k())->external_name(), source_file, line_number);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
          tty->print("RESOLVE %s %s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
                     instanceKlass::cast(this_oop->pool_holder())->external_name(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
                     instanceKlass::cast(k())->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
      return k();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
      ObjectLocker ol (this_oop, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
      // Only updated constant pool - if it is resolved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
      do_resolve = this_oop->tag_at(which).is_unresolved_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
      if (do_resolve) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
        this_oop->klass_at_put(which, k());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  entry = this_oop->resolved_klass_at(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  assert(entry->is_klass(), "must be resolved at this point");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  return (klassOop)entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
// Does not update constantPoolOop - to avoid any exception throwing. Used
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
// by compiler and exception handling.  Also used to avoid classloads for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
// instanceof operations. Returns NULL if the class has not been loaded or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
// if the verification of constant pool failed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
klassOop constantPoolOopDesc::klass_at_if_loaded(constantPoolHandle this_oop, int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  oop entry = *this_oop->obj_at_addr(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  if (entry->is_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    return (klassOop)entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    assert(entry->is_symbol(), "must be either symbol or klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    Thread *thread = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    symbolHandle name (thread, (symbolOop)entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    oop loader = instanceKlass::cast(this_oop->pool_holder())->class_loader();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
    oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
    Handle h_prot (thread, protection_domain);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    Handle h_loader (thread, loader);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    klassOop k = SystemDictionary::find(name, h_loader, h_prot, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    if (k != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
      // Make sure that resolving is legal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
      EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
      KlassHandle klass(THREAD, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
      // return NULL if verification fails
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
      verify_constant_pool_resolve(this_oop, klass, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
      if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
        CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
        return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
      return klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
      return k;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
klassOop constantPoolOopDesc::klass_ref_at_if_loaded(constantPoolHandle this_oop, int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  return klass_at_if_loaded(this_oop, this_oop->klass_ref_index_at(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
// This is an interface for the compiler that allows accessing non-resolved entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
// in the constant pool - but still performs the validations tests. Must be used
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
// in a pre-parse of the compiler - to determine what it can do and not do.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
// Note: We cannot update the ConstantPool from the vm_thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
klassOop constantPoolOopDesc::klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int index, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  int which = this_oop->klass_ref_index_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  oop entry = *this_oop->obj_at_addr(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  if (entry->is_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
    return (klassOop)entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    assert(entry->is_symbol(), "must be either symbol or klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
    symbolHandle name (THREAD, (symbolOop)entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    oop loader = instanceKlass::cast(this_oop->pool_holder())->class_loader();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    oop protection_domain = Klass::cast(this_oop->pool_holder())->protection_domain();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    Handle h_loader(THREAD, loader);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    Handle h_prot  (THREAD, protection_domain);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    KlassHandle k(THREAD, SystemDictionary::find(name, h_loader, h_prot, THREAD));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    // Do access check for klasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
    if( k.not_null() ) verify_constant_pool_resolve(this_oop, k, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    return k();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
symbolOop constantPoolOopDesc::uncached_name_ref_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  jint ref_index = name_and_type_at(uncached_name_and_type_ref_index_at(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  int name_index = extract_low_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  return symbol_at(name_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
symbolOop constantPoolOopDesc::uncached_signature_ref_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  jint ref_index = name_and_type_at(uncached_name_and_type_ref_index_at(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  int signature_index = extract_high_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  return symbol_at(signature_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
int constantPoolOopDesc::uncached_name_and_type_ref_index_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  jint ref_index = field_or_method_at(which, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  return extract_high_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
int constantPoolOopDesc::uncached_klass_ref_index_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  jint ref_index = field_or_method_at(which, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  return extract_low_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
void constantPoolOopDesc::verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle k, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
 if (k->oop_is_instance() || k->oop_is_objArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    instanceKlassHandle holder (THREAD, this_oop->pool_holder());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    klassOop elem_oop = k->oop_is_instance() ? k() : objArrayKlass::cast(k())->bottom_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
    KlassHandle element (THREAD, elem_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    // The element type could be a typeArray - we only need the access check if it is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    // an reference to another class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    if (element->oop_is_instance()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
      LinkResolver::check_klass_accessability(holder, element, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
int constantPoolOopDesc::klass_ref_index_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  jint ref_index = field_or_method_at(which, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  return extract_low_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
int constantPoolOopDesc::name_and_type_ref_index_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  jint ref_index = field_or_method_at(which, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  return extract_high_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
int constantPoolOopDesc::name_ref_index_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  jint ref_index = name_and_type_at(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  return extract_low_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
int constantPoolOopDesc::signature_ref_index_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  jint ref_index = name_and_type_at(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  return extract_high_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
klassOop constantPoolOopDesc::klass_ref_at(int which, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  return klass_at(klass_ref_index_at(which), CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
symbolOop constantPoolOopDesc::klass_name_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  assert(tag_at(which).is_unresolved_klass() || tag_at(which).is_klass(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
         "Corrupted constant pool");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  // A resolved constantPool entry will contain a klassOop, otherwise a symbolOop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  // tag is not updated atomicly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  oop entry = *(obj_at_addr(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  if (entry->is_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
    // Already resolved - return entry's name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    return klassOop(entry)->klass_part()->name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    assert(entry->is_symbol(), "must be either symbol or klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    return (symbolOop)entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
symbolOop constantPoolOopDesc::klass_ref_at_noresolve(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  jint ref_index = klass_ref_index_at(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  return klass_at_noresolve(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
char* constantPoolOopDesc::string_at_noresolve(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // Test entry type in case string is resolved while in here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  oop entry = *(obj_at_addr(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  if (entry->is_symbol()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    return ((symbolOop)entry)->as_C_string();
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   348
  } else if (java_lang_String::is_instance(entry)) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   349
    return java_lang_String::as_utf8_string(entry);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  } else {
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   351
    return (char*)"<pseudo-string>";
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
symbolOop constantPoolOopDesc::name_ref_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  jint ref_index = name_and_type_at(name_and_type_ref_index_at(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  int name_index = extract_low_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  return symbol_at(name_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
symbolOop constantPoolOopDesc::signature_ref_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  jint ref_index = name_and_type_at(name_and_type_ref_index_at(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  int signature_index = extract_high_short_from_int(ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  return symbol_at(signature_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
BasicType constantPoolOopDesc::basic_type_for_signature_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  return FieldType::basic_type(symbol_at(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
void constantPoolOopDesc::resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  for (int index = 1; index < this_oop->length(); index++) { // Index 0 is unused
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    if (this_oop->tag_at(index).is_unresolved_string()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
      this_oop->string_at(index, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
oop constantPoolOopDesc::string_at_impl(constantPoolHandle this_oop, int which, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  oop entry = *(this_oop->obj_at_addr(which));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  if (entry->is_symbol()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
    ObjectLocker ol(this_oop, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
    if (this_oop->tag_at(which).is_unresolved_string()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
      // Intern string
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
      symbolOop sym = this_oop->unresolved_string_at(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
      entry = StringTable::intern(sym, CHECK_(constantPoolOop(NULL)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
      this_oop->string_at_put(which, entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
      // Another thread beat us and interned string, read string from constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
      entry = this_oop->resolved_string_at(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  assert(java_lang_String::is_instance(entry), "must be string");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   402
bool constantPoolOopDesc::is_pseudo_string_at(int which) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   403
  oop entry = *(obj_at_addr(which));
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   404
  if (entry->is_symbol())
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   405
    // Not yet resolved, but it will resolve to a string.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   406
    return false;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   407
  else if (java_lang_String::is_instance(entry))
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   408
    return false; // actually, it might be a non-interned or non-perm string
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   409
  else
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   410
    // truly pseudo
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   411
    return true;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   412
}
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   413
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1
diff changeset
   414
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
bool constantPoolOopDesc::klass_name_at_matches(instanceKlassHandle k,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
                                                int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  // Names are interned, so we can compare symbolOops directly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  symbolOop cp_name = klass_name_at(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  return (cp_name == k->name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
int constantPoolOopDesc::pre_resolve_shared_klasses(TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  int count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  for (int index = 1; index < tags()->length(); index++) { // Index 0 is unused
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
    if (tag_at(index).is_unresolved_string()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
      // Intern string
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
      symbolOop sym = unresolved_string_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
      oop entry = StringTable::intern(sym, CHECK_(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
      string_at_put(index, entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  return count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
// Iterate over symbols which are used as class, field, method names and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
// signatures (in preparation for writing to the shared archive).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
void constantPoolOopDesc::shared_symbols_iterate(OopClosure* closure) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  for (int index = 1; index < length(); index++) { // Index 0 is unused
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
    switch (tag_at(index).value()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
    case JVM_CONSTANT_UnresolvedClass:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
      closure->do_oop(obj_at_addr(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
    case JVM_CONSTANT_NameAndType:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
        int i = *int_at_addr(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
        closure->do_oop(obj_at_addr((unsigned)i >> 16));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
        closure->do_oop(obj_at_addr((unsigned)i & 0xffff));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
    case JVM_CONSTANT_Class:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
    case JVM_CONSTANT_InterfaceMethodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
    case JVM_CONSTANT_Fieldref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
    case JVM_CONSTANT_Methodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
    case JVM_CONSTANT_Integer:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
    case JVM_CONSTANT_Float:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
      // Do nothing!  Not an oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
      // These constant types do not reference symbols at this point.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
    case JVM_CONSTANT_String:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
      // Do nothing!  Not a symbol.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    case JVM_CONSTANT_UnresolvedString:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
    case JVM_CONSTANT_Utf8:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
      // These constants are symbols, but unless these symbols are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
      // actually to be used for something, we don't want to mark them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
    case JVM_CONSTANT_Long:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
    case JVM_CONSTANT_Double:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
      // Do nothing!  Not an oop. (But takes two pool entries.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
      ++index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
      ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
// Iterate over the [one] tags array (in preparation for writing to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
// shared archive).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
void constantPoolOopDesc::shared_tags_iterate(OopClosure* closure) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  closure->do_oop(tags_addr());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
// Iterate over String objects (in preparation for writing to the shared
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
// archive).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
void constantPoolOopDesc::shared_strings_iterate(OopClosure* closure) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  for (int index = 1; index < length(); index++) { // Index 0 is unused
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    switch (tag_at(index).value()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
    case JVM_CONSTANT_UnresolvedClass:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
    case JVM_CONSTANT_NameAndType:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
      // Do nothing!  Not a String.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
    case JVM_CONSTANT_Class:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
    case JVM_CONSTANT_InterfaceMethodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
    case JVM_CONSTANT_Fieldref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
    case JVM_CONSTANT_Methodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
    case JVM_CONSTANT_Integer:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    case JVM_CONSTANT_Float:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
      // Do nothing!  Not an oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
      // These constant types do not reference symbols at this point.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
    case JVM_CONSTANT_String:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
      closure->do_oop(obj_at_addr(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
    case JVM_CONSTANT_UnresolvedString:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
    case JVM_CONSTANT_Utf8:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
      // These constants are symbols, but unless these symbols are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
      // actually to be used for something, we don't want to mark them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
    case JVM_CONSTANT_Long:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    case JVM_CONSTANT_Double:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
      // Do nothing!  Not an oop. (But takes two pool entries.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
      ++index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
      ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
// Compare this constant pool's entry at index1 to the constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
// cp2's entry at index2.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
bool constantPoolOopDesc::compare_entry_to(int index1, constantPoolHandle cp2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
       int index2, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  jbyte t1 = tag_at(index1).value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  jbyte t2 = cp2->tag_at(index2).value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  // JVM_CONSTANT_UnresolvedClassInError is equal to JVM_CONSTANT_UnresolvedClass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  // when comparing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  if (t1 == JVM_CONSTANT_UnresolvedClassInError) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    t1 = JVM_CONSTANT_UnresolvedClass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  if (t2 == JVM_CONSTANT_UnresolvedClassInError) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
    t2 = JVM_CONSTANT_UnresolvedClass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  if (t1 != t2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    // Not the same entry type so there is nothing else to check. Note
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
    // that this style of checking will consider resolved/unresolved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    // class pairs and resolved/unresolved string pairs as different.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
    // From the constantPoolOop API point of view, this is correct
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
    // behavior. See constantPoolKlass::merge() to see how this plays
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    // out in the context of constantPoolOop merging.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  switch (t1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  case JVM_CONSTANT_Class:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
    klassOop k1 = klass_at(index1, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
    klassOop k2 = cp2->klass_at(index2, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
    if (k1 == k2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  case JVM_CONSTANT_ClassIndex:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    int recur1 = klass_index_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
    int recur2 = cp2->klass_index_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
    bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    if (match) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  case JVM_CONSTANT_Double:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
    jdouble d1 = double_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
    jdouble d2 = cp2->double_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
    if (d1 == d2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  case JVM_CONSTANT_Fieldref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  case JVM_CONSTANT_InterfaceMethodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  case JVM_CONSTANT_Methodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
    int recur1 = uncached_klass_ref_index_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
    int recur2 = cp2->uncached_klass_ref_index_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
    bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
    if (match) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
      recur1 = uncached_name_and_type_ref_index_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
      recur2 = cp2->uncached_name_and_type_ref_index_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
      match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
      if (match) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
        return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  case JVM_CONSTANT_Float:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
    jfloat f1 = float_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
    jfloat f2 = cp2->float_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    if (f1 == f2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  case JVM_CONSTANT_Integer:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
    jint i1 = int_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
    jint i2 = cp2->int_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
    if (i1 == i2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  case JVM_CONSTANT_Long:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
    jlong l1 = long_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    jlong l2 = cp2->long_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    if (l1 == l2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  case JVM_CONSTANT_NameAndType:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
    int recur1 = name_ref_index_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
    int recur2 = cp2->name_ref_index_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
    if (match) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
      recur1 = signature_ref_index_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
      recur2 = cp2->signature_ref_index_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
      match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
      if (match) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
        return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  case JVM_CONSTANT_String:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    oop s1 = string_at(index1, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
    oop s2 = cp2->string_at(index2, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
    if (s1 == s2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  case JVM_CONSTANT_StringIndex:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    int recur1 = string_index_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    int recur2 = cp2->string_index_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
    if (match) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  case JVM_CONSTANT_UnresolvedClass:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
    symbolOop k1 = unresolved_klass_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
    symbolOop k2 = cp2->unresolved_klass_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    if (k1 == k2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  case JVM_CONSTANT_UnresolvedString:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
    symbolOop s1 = unresolved_string_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
    symbolOop s2 = cp2->unresolved_string_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
    if (s1 == s2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  case JVM_CONSTANT_Utf8:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
    symbolOop s1 = symbol_at(index1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
    symbolOop s2 = cp2->symbol_at(index2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
    if (s1 == s2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  // Invalid is used as the tag for the second constant pool entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  // not be seen by itself.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  case JVM_CONSTANT_Invalid: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
} // end compare_entry_to()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
// Copy this constant pool's entries at start_i to end_i (inclusive)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
// to the constant pool to_cp's entries starting at to_i. A total of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
// (end_i - start_i) + 1 entries are copied.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
void constantPoolOopDesc::copy_cp_to(int start_i, int end_i,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
       constantPoolHandle to_cp, int to_i, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  int dest_i = to_i;  // leave original alone for debug purposes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  for (int src_i = start_i; src_i <= end_i; /* see loop bottom */ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
    copy_entry_to(src_i, to_cp, dest_i, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
    switch (tag_at(src_i).value()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
    case JVM_CONSTANT_Double:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
    case JVM_CONSTANT_Long:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
      // double and long take two constant pool entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
      src_i += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
      dest_i += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
      // all others take one constant pool entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
      src_i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
      dest_i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
} // end copy_cp_to()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
// Copy this constant pool's entry at from_i to the constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
// to_cp's entry at to_i.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
void constantPoolOopDesc::copy_entry_to(int from_i, constantPoolHandle to_cp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
       int to_i, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  switch (tag_at(from_i).value()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  case JVM_CONSTANT_Class:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
    klassOop k = klass_at(from_i, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
    to_cp->klass_at_put(to_i, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
  case JVM_CONSTANT_ClassIndex:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
    jint ki = klass_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
    to_cp->klass_index_at_put(to_i, ki);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  case JVM_CONSTANT_Double:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
    jdouble d = double_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
    to_cp->double_at_put(to_i, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
    // double takes two constant pool entries so init second entry's tag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
    to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  case JVM_CONSTANT_Fieldref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
    int class_index = uncached_klass_ref_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
    int name_and_type_index = uncached_name_and_type_ref_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
    to_cp->field_at_put(to_i, class_index, name_and_type_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  case JVM_CONSTANT_Float:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
    jfloat f = float_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
    to_cp->float_at_put(to_i, f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  case JVM_CONSTANT_Integer:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
    jint i = int_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
    to_cp->int_at_put(to_i, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  case JVM_CONSTANT_InterfaceMethodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    int class_index = uncached_klass_ref_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
    int name_and_type_index = uncached_name_and_type_ref_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
    to_cp->interface_method_at_put(to_i, class_index, name_and_type_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  case JVM_CONSTANT_Long:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    jlong l = long_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
    to_cp->long_at_put(to_i, l);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
    // long takes two constant pool entries so init second entry's tag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
    to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  case JVM_CONSTANT_Methodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
    int class_index = uncached_klass_ref_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
    int name_and_type_index = uncached_name_and_type_ref_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
    to_cp->method_at_put(to_i, class_index, name_and_type_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  case JVM_CONSTANT_NameAndType:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
    int name_ref_index = name_ref_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
    int signature_ref_index = signature_ref_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
    to_cp->name_and_type_at_put(to_i, name_ref_index, signature_ref_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  case JVM_CONSTANT_String:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    oop s = string_at(from_i, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
    to_cp->string_at_put(to_i, s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  case JVM_CONSTANT_StringIndex:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    jint si = string_index_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
    to_cp->string_index_at_put(to_i, si);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  case JVM_CONSTANT_UnresolvedClass:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
    symbolOop k = unresolved_klass_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
    to_cp->unresolved_klass_at_put(to_i, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  case JVM_CONSTANT_UnresolvedClassInError:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
    symbolOop k = unresolved_klass_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
    to_cp->unresolved_klass_at_put(to_i, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
    to_cp->tag_at_put(to_i, JVM_CONSTANT_UnresolvedClassInError);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  case JVM_CONSTANT_UnresolvedString:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
    symbolOop s = unresolved_string_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
    to_cp->unresolved_string_at_put(to_i, s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  case JVM_CONSTANT_Utf8:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
    symbolOop s = symbol_at(from_i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
    to_cp->symbol_at_put(to_i, s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  // Invalid is used as the tag for the second constant pool entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  // not be seen by itself.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  case JVM_CONSTANT_Invalid: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
    jbyte bad_value = tag_at(from_i).value(); // leave a breadcrumb
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  } break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
} // end copy_entry_to()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
// Search constant pool search_cp for an entry that matches this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
// constant pool's entry at pattern_i. Returns the index of a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
// matching entry or zero (0) if there is no matching entry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
int constantPoolOopDesc::find_matching_entry(int pattern_i,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
      constantPoolHandle search_cp, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  // index zero (0) is not used
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  for (int i = 1; i < search_cp->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
    bool found = compare_entry_to(pattern_i, search_cp, i, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
    if (found) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
      return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  return 0;  // entry not found; return unused index zero (0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
} // end find_matching_entry()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
const char* constantPoolOopDesc::printable_name_at(int which) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  constantTag tag = tag_at(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  if (tag.is_unresolved_string() || tag.is_string()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
    return string_at_noresolve(which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
  } else if (tag.is_klass() || tag.is_unresolved_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
    return klass_name_at(which)->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  } else if (tag.is_symbol()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
    return symbol_at(which)->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  return "";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
// JVMTI GetConstantPool support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
// For temporary use until code is stable.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
#define DBG(code)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
static const char* WARN_MSG = "Must not be such entry!";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
static void print_cpool_bytes(jint cnt, u1 *bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  jint size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
  u2   idx1, idx2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  for (jint idx = 1; idx < cnt; idx++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
    jint ent_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
    u1   tag  = *bytes++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
    size++;                       // count tag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
    printf("const #%03d, tag: %02d ", idx, tag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
    switch(tag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
      case JVM_CONSTANT_Invalid: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
        printf("Invalid");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
      case JVM_CONSTANT_Unicode: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
        printf("Unicode      %s", WARN_MSG);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
      case JVM_CONSTANT_Utf8: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
        u2 len = Bytes::get_Java_u2(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
        char str[128];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
        if (len > 127) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
           len = 127;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
        strncpy(str, (char *) (bytes+2), len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
        str[len] = '\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
        printf("Utf8          \"%s\"", str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
        ent_size = 2 + len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
      case JVM_CONSTANT_Integer: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
        u4 val = Bytes::get_Java_u4(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
        printf("int          %d", *(int *) &val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
        ent_size = 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
      case JVM_CONSTANT_Float: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
        u4 val = Bytes::get_Java_u4(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
        printf("float        %5.3ff", *(float *) &val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
        ent_size = 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
      case JVM_CONSTANT_Long: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
        u8 val = Bytes::get_Java_u8(bytes);
1889
24b003a6fe46 6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents: 1550
diff changeset
   965
        printf("long         "INT64_FORMAT, *(jlong *) &val);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
        ent_size = 8;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
        idx++; // Long takes two cpool slots
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
      case JVM_CONSTANT_Double: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
        u8 val = Bytes::get_Java_u8(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
        printf("double       %5.3fd", *(jdouble *)&val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
        ent_size = 8;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
        idx++; // Double takes two cpool slots
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
      case JVM_CONSTANT_Class: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
        idx1 = Bytes::get_Java_u2(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
        printf("class        #%03d", idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
        ent_size = 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
      case JVM_CONSTANT_String: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
        idx1 = Bytes::get_Java_u2(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
        printf("String       #%03d", idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
        ent_size = 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
      case JVM_CONSTANT_Fieldref: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
        idx1 = Bytes::get_Java_u2(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
        idx2 = Bytes::get_Java_u2(bytes+2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
        printf("Field        #%03d, #%03d", (int) idx1, (int) idx2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
        ent_size = 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
      case JVM_CONSTANT_Methodref: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
        idx1 = Bytes::get_Java_u2(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
        idx2 = Bytes::get_Java_u2(bytes+2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
        printf("Method       #%03d, #%03d", idx1, idx2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
        ent_size = 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
      case JVM_CONSTANT_InterfaceMethodref: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
        idx1 = Bytes::get_Java_u2(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
        idx2 = Bytes::get_Java_u2(bytes+2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
        printf("InterfMethod #%03d, #%03d", idx1, idx2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
        ent_size = 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
      case JVM_CONSTANT_NameAndType: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
        idx1 = Bytes::get_Java_u2(bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
        idx2 = Bytes::get_Java_u2(bytes+2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
        printf("NameAndType  #%03d, #%03d", idx1, idx2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
        ent_size = 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
      case JVM_CONSTANT_ClassIndex: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
        printf("ClassIndex  %s", WARN_MSG);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
      case JVM_CONSTANT_UnresolvedClass: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
        printf("UnresolvedClass: %s", WARN_MSG);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
      case JVM_CONSTANT_UnresolvedClassInError: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
        printf("UnresolvedClassInErr: %s", WARN_MSG);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
      case JVM_CONSTANT_StringIndex: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
        printf("StringIndex: %s", WARN_MSG);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
      case JVM_CONSTANT_UnresolvedString: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
        printf("UnresolvedString: %s", WARN_MSG);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
    printf(";\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
    bytes += ent_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
    size  += ent_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  printf("Cpool size: %d\n", size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
  fflush(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
} /* end print_cpool_bytes */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
// Returns size of constant pool entry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
jint constantPoolOopDesc::cpool_entry_size(jint idx) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
  switch(tag_at(idx).value()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
    case JVM_CONSTANT_Invalid:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
    case JVM_CONSTANT_Unicode:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
      return 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
    case JVM_CONSTANT_Utf8:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
      return 3 + symbol_at(idx)->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
    case JVM_CONSTANT_Class:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
    case JVM_CONSTANT_String:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
    case JVM_CONSTANT_ClassIndex:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
    case JVM_CONSTANT_UnresolvedClass:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
    case JVM_CONSTANT_UnresolvedClassInError:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
    case JVM_CONSTANT_StringIndex:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
    case JVM_CONSTANT_UnresolvedString:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
      return 3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
    case JVM_CONSTANT_Integer:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
    case JVM_CONSTANT_Float:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
    case JVM_CONSTANT_Fieldref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
    case JVM_CONSTANT_Methodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
    case JVM_CONSTANT_InterfaceMethodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
    case JVM_CONSTANT_NameAndType:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
      return 5;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
    case JVM_CONSTANT_Long:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
    case JVM_CONSTANT_Double:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
      return 9;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  assert(false, "cpool_entry_size: Invalid constant pool entry tag");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  return 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
} /* end cpool_entry_size */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
// SymbolHashMap is used to find a constant pool index from a string.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
// This function fills in SymbolHashMaps, one for utf8s and one for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
// class names, returns size of the cpool raw bytes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
jint constantPoolOopDesc::hash_entries_to(SymbolHashMap *symmap,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
                                          SymbolHashMap *classmap) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
  jint size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  for (u2 idx = 1; idx < length(); idx++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
    u2 tag = tag_at(idx).value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
    size += cpool_entry_size(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
    switch(tag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
      case JVM_CONSTANT_Utf8: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
        symbolOop sym = symbol_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
        symmap->add_entry(sym, idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
        DBG(printf("adding symbol entry %s = %d\n", sym->as_utf8(), idx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
      case JVM_CONSTANT_Class:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
      case JVM_CONSTANT_UnresolvedClass:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
      case JVM_CONSTANT_UnresolvedClassInError: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
        symbolOop sym = klass_name_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
        classmap->add_entry(sym, idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
        DBG(printf("adding class entry %s = %d\n", sym->as_utf8(), idx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
      case JVM_CONSTANT_Long:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
      case JVM_CONSTANT_Double: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
        idx++; // Both Long and Double take two cpool slots
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
  return size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
} /* end hash_utf8_entries_to */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
// Copy cpool bytes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
// Returns:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
//    0, in case of OutOfMemoryError
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
//   -1, in case of internal error
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
//  > 0, count of the raw cpool bytes that have been copied
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
int constantPoolOopDesc::copy_cpool_bytes(int cpool_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
                                          SymbolHashMap* tbl,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
                                          unsigned char *bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
  u2   idx1, idx2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
  jint size  = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
  jint cnt   = length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  unsigned char *start_bytes = bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  for (jint idx = 1; idx < cnt; idx++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
    u1   tag      = tag_at(idx).value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
    jint ent_size = cpool_entry_size(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
    assert(size + ent_size <= cpool_size, "Size mismatch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
    *bytes = tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
    DBG(printf("#%03hd tag=%03hd, ", idx, tag));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
    switch(tag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
      case JVM_CONSTANT_Invalid: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
        DBG(printf("JVM_CONSTANT_Invalid"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
      case JVM_CONSTANT_Unicode: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
        assert(false, "Wrong constant pool tag: JVM_CONSTANT_Unicode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
        DBG(printf("JVM_CONSTANT_Unicode"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
      case JVM_CONSTANT_Utf8: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
        symbolOop sym = symbol_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
        char*     str = sym->as_utf8();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
        // Warning! It's crashing on x86 with len = sym->utf8_length()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
        int       len = (int) strlen(str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
        Bytes::put_Java_u2((address) (bytes+1), (u2) len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
        for (int i = 0; i < len; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
            bytes[3+i] = (u1) str[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
        DBG(printf("JVM_CONSTANT_Utf8: %s ", str));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
      case JVM_CONSTANT_Integer: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
        jint val = int_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
        Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
      case JVM_CONSTANT_Float: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
        jfloat val = float_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
        Bytes::put_Java_u4((address) (bytes+1), *(u4*)&val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
      case JVM_CONSTANT_Long: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
        jlong val = long_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
        Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
        idx++;             // Long takes two cpool slots
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
      case JVM_CONSTANT_Double: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
        jdouble val = double_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
        Bytes::put_Java_u8((address) (bytes+1), *(u8*)&val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
        idx++;             // Double takes two cpool slots
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
      case JVM_CONSTANT_Class:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
      case JVM_CONSTANT_UnresolvedClass:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
      case JVM_CONSTANT_UnresolvedClassInError: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
        *bytes = JVM_CONSTANT_Class;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
        symbolOop sym = klass_name_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
        idx1 = tbl->symbol_to_value(sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
        assert(idx1 != 0, "Have not found a hashtable entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
        Bytes::put_Java_u2((address) (bytes+1), idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
        DBG(printf("JVM_CONSTANT_Class: idx=#%03hd, %s", idx1, sym->as_utf8()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
      case JVM_CONSTANT_String: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
        unsigned int hash;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
        char *str = string_at_noresolve(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
        symbolOop sym = SymbolTable::lookup_only(str, (int) strlen(str), hash);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
        idx1 = tbl->symbol_to_value(sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
        assert(idx1 != 0, "Have not found a hashtable entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
        Bytes::put_Java_u2((address) (bytes+1), idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
        DBG(printf("JVM_CONSTANT_String: idx=#%03hd, %s", idx1, str));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
      case JVM_CONSTANT_UnresolvedString: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
        *bytes = JVM_CONSTANT_String;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
        symbolOop sym = unresolved_string_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
        idx1 = tbl->symbol_to_value(sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
        assert(idx1 != 0, "Have not found a hashtable entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
        Bytes::put_Java_u2((address) (bytes+1), idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
        DBG(char *str = sym->as_utf8());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
        DBG(printf("JVM_CONSTANT_UnresolvedString: idx=#%03hd, %s", idx1, str));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
      case JVM_CONSTANT_Fieldref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
      case JVM_CONSTANT_Methodref:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
      case JVM_CONSTANT_InterfaceMethodref: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
        idx1 = uncached_klass_ref_index_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
        idx2 = uncached_name_and_type_ref_index_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
        Bytes::put_Java_u2((address) (bytes+1), idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
        Bytes::put_Java_u2((address) (bytes+3), idx2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
        DBG(printf("JVM_CONSTANT_Methodref: %hd %hd", idx1, idx2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
      case JVM_CONSTANT_NameAndType: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
        idx1 = name_ref_index_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
        idx2 = signature_ref_index_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
        Bytes::put_Java_u2((address) (bytes+1), idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
        Bytes::put_Java_u2((address) (bytes+3), idx2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
        DBG(printf("JVM_CONSTANT_NameAndType: %hd %hd", idx1, idx2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
      case JVM_CONSTANT_ClassIndex: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
        *bytes = JVM_CONSTANT_Class;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
        idx1 = klass_index_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
        Bytes::put_Java_u2((address) (bytes+1), idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
        DBG(printf("JVM_CONSTANT_ClassIndex: %hd", idx1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
      case JVM_CONSTANT_StringIndex: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
        *bytes = JVM_CONSTANT_String;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
        idx1 = string_index_at(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
        Bytes::put_Java_u2((address) (bytes+1), idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
        DBG(printf("JVM_CONSTANT_StringIndex: %hd", idx1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
    DBG(printf("\n"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
    bytes += ent_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
    size  += ent_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
  assert(size == cpool_size, "Size mismatch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  // Keep temorarily for debugging until it's stable.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
  DBG(print_cpool_bytes(cnt, start_bytes));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  return (int)(bytes - start_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
} /* end copy_cpool_bytes */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
void SymbolHashMap::add_entry(symbolOop sym, u2 value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
  char *str = sym->as_utf8();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
  unsigned int hash = compute_hash(str, sym->utf8_length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  unsigned int index = hash % table_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
  // check if already in map
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
  // we prefer the first entry since it is more likely to be what was used in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
  // the class file
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
  for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
    assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
    if (en->hash() == hash && en->symbol() == sym) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
        return;  // already there
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
  SymbolHashMapEntry* entry = new SymbolHashMapEntry(hash, sym, value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
  entry->set_next(bucket(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
  _buckets[index].set_entry(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
  assert(entry->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
SymbolHashMapEntry* SymbolHashMap::find_entry(symbolOop sym) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
  assert(sym != NULL, "SymbolHashMap::find_entry - symbol is NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
  char *str = sym->as_utf8();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
  int   len = sym->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
  unsigned int hash = SymbolHashMap::compute_hash(str, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
  unsigned int index = hash % table_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
  for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
    assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
    if (en->hash() == hash && en->symbol() == sym) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
      return en;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
}