hotspot/src/share/vm/interpreter/rewriter.cpp
author never
Thu, 13 Jan 2011 22:15:41 -0800
changeset 7913 dd096a83bdbb
parent 7436 dbc43da3d512
child 8296 b1c2163e4e59
permissions -rw-r--r--
4926272: methodOopDesc::method_from_bcp is unsafe Reviewed-by: coleenp, jrose, kvn, dcubed
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7436
diff changeset
     2
 * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4567
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4567
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4567
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    26
#include "interpreter/bytecodes.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    27
#include "interpreter/interpreter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    28
#include "interpreter/rewriter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    29
#include "memory/gcLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    30
#include "memory/oopFactory.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    31
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    32
#include "oops/generateOopMap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    33
#include "oops/objArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    34
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    35
#include "prims/methodComparator.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    37
// Computes a CPC map (new_index -> original_index) for constant pool entries
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// that are referred to by the interpreter at runtime via the constant pool cache.
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    39
// Also computes a CP map (original_index -> new_index).
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    40
// Marks entries in CP which require additional processing.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    41
void Rewriter::compute_index_maps() {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    42
  const int length  = _pool->length();
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    43
  init_cp_map(length);
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    44
  jint tag_mask = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  for (int i = 0; i < length; i++) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    46
    int tag = _pool->tag_at(i).value();
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    47
    tag_mask |= (1 << tag);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    48
    switch (tag) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    49
      case JVM_CONSTANT_InterfaceMethodref:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
      case JVM_CONSTANT_Fieldref          : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
      case JVM_CONSTANT_Methodref         : // fall through
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
    52
      case JVM_CONSTANT_MethodHandle      : // fall through
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
    53
      case JVM_CONSTANT_MethodType        : // fall through
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    54
      case JVM_CONSTANT_InvokeDynamic     : // fall through
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
    55
      case JVM_CONSTANT_InvokeDynamicTrans: // fall through
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    56
        add_cp_cache_entry(i);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    57
        break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    60
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    61
  guarantee((int)_cp_cache_map.length()-1 <= (int)((u2)-1),
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    62
            "all cp cache indexes fit in a u2");
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    63
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    64
  _have_invoke_dynamic = ((tag_mask & (1 << JVM_CONSTANT_InvokeDynamic)) != 0);
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
    65
  _have_invoke_dynamic |= ((tag_mask & (1 << JVM_CONSTANT_InvokeDynamicTrans)) != 0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    69
// Creates a constant pool cache given a CPC map
2006
f2d2f0f20063 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents: 1
diff changeset
    70
// This creates the constant pool cache initially in a state
f2d2f0f20063 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents: 1
diff changeset
    71
// that is unsafe for concurrent GC processing but sets it to
f2d2f0f20063 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents: 1
diff changeset
    72
// a safe mode before the constant pool cache is returned.
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    73
void Rewriter::make_constant_pool_cache(TRAPS) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    74
  const int length = _cp_cache_map.length();
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    75
  constantPoolCacheOop cache =
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    76
      oopFactory::new_constantPoolCache(length, methodOopDesc::IsUnsafeConc, CHECK);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    77
  cache->initialize(_cp_cache_map);
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    78
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
    79
  // Don't bother with the next pass if there is no JVM_CONSTANT_InvokeDynamic.
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    80
  if (_have_invoke_dynamic) {
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    81
    for (int i = 0; i < length; i++) {
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    82
      int pool_index = cp_cache_entry_pool_index(i);
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    83
      if (pool_index >= 0 &&
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    84
          _pool->tag_at(pool_index).is_invoke_dynamic()) {
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    85
        int bsm_index = _pool->invoke_dynamic_bootstrap_method_ref_index_at(pool_index);
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    86
        if (bsm_index != 0) {
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    87
          assert(_pool->tag_at(bsm_index).is_method_handle(), "must be a MH constant");
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    88
          // There is a CP cache entry holding the BSM for these calls.
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    89
          int bsm_cache_index = cp_entry_to_cp_cache(bsm_index);
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    90
          cache->entry_at(i)->initialize_bootstrap_method_index_in_cache(bsm_cache_index);
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    91
        } else {
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    92
          // There is no CP cache entry holding the BSM for these calls.
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    93
          // We will need to look for a class-global BSM, later.
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    94
          guarantee(AllowTransitionalJSR292, "");
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    95
        }
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    96
      }
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    97
    }
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    98
  }
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    99
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   100
  _pool->set_cache(cache);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   101
  cache->set_constant_pool(_pool());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
// The new finalization semantics says that registration of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
// finalizable objects must be performed on successful return from the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
// Object.<init> constructor.  We could implement this trivially if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
// <init> were never rewritten but since JVMTI allows this to occur, a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
// more complicated solution is required.  A special return bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
// is used only by Object.<init> to signal the finalization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
// registration point.  Additionally local 0 must be preserved so it's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
// available to pass to the registration function.  For simplicty we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
// require that local 0 is never overwritten so it's available as an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
// argument for registration.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
void Rewriter::rewrite_Object_init(methodHandle method, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  RawBytecodeStream bcs(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  while (!bcs.is_last_bytecode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    Bytecodes::Code opcode = bcs.raw_next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    switch (opcode) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
      case Bytecodes::_return: *bcs.bcp() = Bytecodes::_return_register_finalizer; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
      case Bytecodes::_istore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
      case Bytecodes::_lstore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
      case Bytecodes::_fstore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
      case Bytecodes::_dstore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
      case Bytecodes::_astore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
        if (bcs.get_index() != 0) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
        // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
      case Bytecodes::_istore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
      case Bytecodes::_lstore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
      case Bytecodes::_fstore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
      case Bytecodes::_dstore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
      case Bytecodes::_astore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
        THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
                  "can't overwrite local 0 in Object.<init>");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   145
// Rewrite a classfile-order CP index into a native-order CPC index.
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 4567
diff changeset
   146
void Rewriter::rewrite_member_reference(address bcp, int offset) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   147
  address p = bcp + offset;
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   148
  int  cp_index    = Bytes::get_Java_u2(p);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   149
  int  cache_index = cp_entry_to_cp_cache(cp_index);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   150
  Bytes::put_native_u2(p, cache_index);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   151
}
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   152
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   153
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 4567
diff changeset
   154
void Rewriter::rewrite_invokedynamic(address bcp, int offset) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   155
  address p = bcp + offset;
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   156
  assert(p[-1] == Bytecodes::_invokedynamic, "");
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   157
  int cp_index = Bytes::get_Java_u2(p);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   158
  int cpc  = maybe_add_cp_cache_entry(cp_index);  // add lazily
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 3273
diff changeset
   159
  int cpc2 = add_secondary_cp_cache_entry(cpc);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   160
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   161
  // Replace the trailing four bytes with a CPC index for the dynamic
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   162
  // call site.  Unlike other CPC entries, there is one per bytecode,
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   163
  // not just one per distinct CP entry.  In other words, the
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   164
  // CPC-to-CP relation is many-to-one for invokedynamic entries.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   165
  // This means we must use a larger index size than u2 to address
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   166
  // all these entries.  That is the main reason invokedynamic
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   167
  // must have a five-byte instruction format.  (Of course, other JVM
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   168
  // implementations can use the bytes for other purposes.)
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 3273
diff changeset
   169
  Bytes::put_native_u4(p, constantPoolCacheOopDesc::encode_secondary_index(cpc2));
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   170
  // Note: We use native_u4 format exclusively for 4-byte indexes.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   171
}
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   172
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   173
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   174
// Rewrite some ldc bytecodes to _fast_aldc
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   175
void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   176
  assert((*bcp) == (is_wide ? Bytecodes::_ldc_w : Bytecodes::_ldc), "");
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   177
  address p = bcp + offset;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   178
  int cp_index = is_wide ? Bytes::get_Java_u2(p) : (u1)(*p);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   179
  constantTag tag = _pool->tag_at(cp_index).value();
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   180
  if (tag.is_method_handle() || tag.is_method_type()) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   181
    int cache_index = cp_entry_to_cp_cache(cp_index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   182
    if (is_wide) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   183
      (*bcp) = Bytecodes::_fast_aldc_w;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   184
      assert(cache_index == (u2)cache_index, "");
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   185
      Bytes::put_native_u2(p, cache_index);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   186
    } else {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   187
      (*bcp) = Bytecodes::_fast_aldc;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   188
      assert(cache_index == (u1)cache_index, "");
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   189
      (*p) = (u1)cache_index;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   190
    }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   191
  }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   192
}
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   193
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   194
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
// Rewrites a method given the index_map information
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   196
void Rewriter::scan_method(methodOop method) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  int nof_jsrs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  bool has_monitor_bytecodes = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    // We cannot tolerate a GC in this block, because we've
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    // cached the bytecodes in 'code_base'. If the methodOop
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    // moves, the bytecodes will also move.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
    No_Safepoint_Verifier nsv;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    Bytecodes::Code c;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
    // Bytecodes and their length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    const address code_base = method->code_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    const int code_length = method->code_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    int bc_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    for (int bci = 0; bci < code_length; bci += bc_length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
      address bcp = code_base + bci;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   215
      int prefix_length = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
      c = (Bytecodes::Code)(*bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
      // Since we have the code, see if we can get the length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
      // directly. Some more complicated bytecodes will report
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
      // a length of zero, meaning we need to make another method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
      // call to calculate the length.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
      bc_length = Bytecodes::length_for(c);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
      if (bc_length == 0) {
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7436
diff changeset
   224
        bc_length = Bytecodes::length_at(method, bcp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
        // length_at will put us at the bytecode after the one modified
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
        // by 'wide'. We don't currently examine any of the bytecodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
        // modified by wide, but in case we do in the future...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
        if (c == Bytecodes::_wide) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   230
          prefix_length = 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
          c = (Bytecodes::Code)bcp[1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
      assert(bc_length != 0, "impossible bytecode length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
      switch (c) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
        case Bytecodes::_lookupswitch   : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
#ifndef CC_INTERP
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7436
diff changeset
   240
          Bytecode_lookupswitch bc(method, bcp);
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 4567
diff changeset
   241
          (*bcp) = (
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7436
diff changeset
   242
            bc.number_of_pairs() < BinarySwitchThreshold
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
            ? Bytecodes::_fast_linearswitch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
            : Bytecodes::_fast_binaryswitch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
          );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
        case Bytecodes::_getstatic      : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
        case Bytecodes::_putstatic      : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
        case Bytecodes::_getfield       : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
        case Bytecodes::_putfield       : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
        case Bytecodes::_invokevirtual  : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
        case Bytecodes::_invokespecial  : // fall through
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   255
        case Bytecodes::_invokestatic   :
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   256
        case Bytecodes::_invokeinterface:
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   257
          rewrite_member_reference(bcp, prefix_length+1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
          break;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   259
        case Bytecodes::_invokedynamic:
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 4567
diff changeset
   260
          rewrite_invokedynamic(bcp, prefix_length+1);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   261
          break;
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   262
        case Bytecodes::_ldc:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   263
          maybe_rewrite_ldc(bcp, prefix_length+1, false);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   264
          break;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   265
        case Bytecodes::_ldc_w:
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   266
          maybe_rewrite_ldc(bcp, prefix_length+1, true);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   267
          break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
        case Bytecodes::_jsr            : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
        case Bytecodes::_jsr_w          : nof_jsrs++;                   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
        case Bytecodes::_monitorenter   : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
        case Bytecodes::_monitorexit    : has_monitor_bytecodes = true; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  // Update access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  if (has_monitor_bytecodes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    method->set_has_monitor_bytecodes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  // The present of a jsr bytecode implies that the method might potentially
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  // have to be rewritten, so we run the oopMapGenerator on the method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  if (nof_jsrs > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    method->set_has_jsrs();
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   285
    // Second pass will revisit this method.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   286
    assert(method->has_jsrs(), "");
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   287
  }
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   288
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   290
// After constant pool is created, revisit methods containing jsrs.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   291
methodHandle Rewriter::rewrite_jsrs(methodHandle method, TRAPS) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   292
  ResolveOopMapConflicts romc(method);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   293
  methodHandle original_method = method;
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   294
  method = romc.do_potential_rewrite(CHECK_(methodHandle()));
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   295
  if (method() != original_method()) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   296
    // Insert invalid bytecode into original methodOop and set
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   297
    // interpreter entrypoint, so that a executing this method
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   298
    // will manifest itself in an easy recognizable form.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   299
    address bcp = original_method->bcp_from(0);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   300
    *bcp = (u1)Bytecodes::_shouldnotreachhere;
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   301
    int kind = Interpreter::method_kind(original_method);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   302
    original_method->set_interpreter_kind(kind);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   305
  // Update monitor matching info.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   306
  if (romc.monitor_safe()) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   307
    method->set_guaranteed_monitor_matching();
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   308
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  return method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
void Rewriter::rewrite(instanceKlassHandle klass, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  ResourceMark rm(THREAD);
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   316
  Rewriter     rw(klass, klass->constants(), klass->methods(), CHECK);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   317
  // (That's all, folks.)
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   318
}
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   319
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   320
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   321
void Rewriter::rewrite(instanceKlassHandle klass, constantPoolHandle cpool, objArrayHandle methods, TRAPS) {
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   322
  ResourceMark rm(THREAD);
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   323
  Rewriter     rw(klass, cpool, methods, CHECK);
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   324
  // (That's all, folks.)
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   325
}
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   326
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   327
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   328
Rewriter::Rewriter(instanceKlassHandle klass, constantPoolHandle cpool, objArrayHandle methods, TRAPS)
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   329
  : _klass(klass),
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   330
    _pool(cpool),
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4429
diff changeset
   331
    _methods(methods)
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   332
{
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   333
  assert(_pool->cache() == NULL, "constant pool cache must not be set yet");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  // determine index maps for methodOop rewriting
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   336
  compute_index_maps();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   338
  if (RegisterFinalizersAtInit && _klass->name() == vmSymbols::java_lang_Object()) {
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   339
    bool did_rewrite = false;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   340
    int i = _methods->length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    while (i-- > 0) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   342
      methodOop method = (methodOop)_methods->obj_at(i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
      if (method->intrinsic_id() == vmIntrinsics::_Object_init) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
        // rewrite the return bytecodes of Object.<init> to register the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
        // object for finalization if needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
        methodHandle m(THREAD, method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
        rewrite_Object_init(m, CHECK);
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   348
        did_rewrite = true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    }
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   352
    assert(did_rewrite, "must find Object::<init> to rewrite it");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   355
  // rewrite methods, in two passes
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   356
  int i, len = _methods->length();
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   357
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   358
  for (i = len; --i >= 0; ) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   359
    methodOop method = (methodOop)_methods->obj_at(i);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   360
    scan_method(method);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   361
  }
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   362
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   363
  // allocate constant pool cache, now that we've seen all the bytecodes
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   364
  make_constant_pool_cache(CHECK);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   365
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   366
  for (i = len; --i >= 0; ) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   367
    methodHandle m(THREAD, (methodOop)_methods->obj_at(i));
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   368
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   369
    if (m->has_jsrs()) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   370
      m = rewrite_jsrs(m, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
      // Method might have gotten rewritten.
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   372
      _methods->obj_at_put(i, m());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   374
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   375
    // Set up method entry points for compiler and interpreter.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   376
    m->link_method(m, CHECK);
5697
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   377
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   378
#ifdef ASSERT
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   379
    if (StressMethodComparator) {
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   380
      static int nmc = 0;
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   381
      for (int j = i; j >= 0 && j >= i-4; j--) {
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   382
        if ((++nmc % 1000) == 0)  tty->print_cr("Have run MethodComparator %d times...", nmc);
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   383
        bool z = MethodComparator::methods_EMCP(m(), (methodOop)_methods->obj_at(j));
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   384
        if (j == i && !z) {
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   385
          tty->print("MethodComparator FAIL: "); m->print(); m->print_codes();
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   386
          assert(z, "method must compare equal to itself");
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   387
        }
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   388
      }
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   389
    }
0cf7190475ee 6957080: MethodComparator needs stress testing
jrose
parents: 5688
diff changeset
   390
#endif //ASSERT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
}