hotspot/src/share/vm/interpreter/rewriter.cpp
author jwilhelm
Thu, 06 Jul 2017 01:50:26 +0200
changeset 46630 75aa3e39d02c
parent 46427 54713555867e
child 46727 6e4a84748e2c
permissions -rw-r--r--
8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8 8182656: Make the required changes in GC code to build on OSX 10 + Xcode 8 8182657: Make the required changes in Runtime code to build on OSX 10 + Xcode 8 8182658: Make the required changes in Compiler code to build on OSX 10 + Xcode 8 Reviewed-by: jwilhelm, ehelin, phh Contributed-by: phh <hohensee@amazon.com>, jwilhelm <jesper.wilhelmsson@oracle.com>
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42870
diff changeset
     2
 * Copyright (c) 1998, 2017, 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"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30117
diff changeset
    26
#include "gc/shared/gcLocker.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    27
#include "interpreter/bytecodes.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    28
#include "interpreter/interpreter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6062
diff changeset
    29
#include "interpreter/rewriter.hpp"
30117
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 22750
diff changeset
    30
#include "memory/metaspaceShared.hpp"
7397
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"
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
    33
#include "prims/methodHandles.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    35
// Computes a CPC map (new_index -> original_index) for constant pool entries
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// 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
    37
// Also computes a CP map (original_index -> new_index).
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    38
// Marks entries in CP which require additional processing.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    39
void Rewriter::compute_index_maps() {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    40
  const int length  = _pool->length();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    41
  init_maps(length);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
    42
  bool saw_mh_symbol = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  for (int i = 0; i < length; i++) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    44
    int tag = _pool->tag_at(i).value();
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    45
    switch (tag) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    46
      case JVM_CONSTANT_InterfaceMethodref:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
      case JVM_CONSTANT_Fieldref          : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
      case JVM_CONSTANT_Methodref         : // fall through
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    49
        add_cp_cache_entry(i);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    50
        break;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    51
      case JVM_CONSTANT_String:
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
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    54
        add_resolved_references_entry(i);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    55
        break;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
    56
      case JVM_CONSTANT_Utf8:
36819
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35492
diff changeset
    57
        if (_pool->symbol_at(i) == vmSymbols::java_lang_invoke_MethodHandle() ||
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35492
diff changeset
    58
            _pool->symbol_at(i) == vmSymbols::java_lang_invoke_VarHandle()) {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
    59
          saw_mh_symbol = true;
36819
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35492
diff changeset
    60
        }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
    61
        break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    64
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    65
  // Record limits of resolved reference map for constant pool cache indices
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    66
  record_map_limits();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    67
38031
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
    68
  guarantee((int) _cp_cache_map.length() - 1 <= (int) ((u2)-1),
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    69
            "all cp cache indexes fit in a u2");
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5882
diff changeset
    70
38031
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
    71
  if (saw_mh_symbol) {
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
    72
    _method_handle_invokers.at_grow(length, 0);
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
    73
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
    76
// Unrewrite the bytecodes if an error occurs.
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
    77
void Rewriter::restore_bytecodes() {
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
    78
  int len = _methods->length();
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
    79
  bool invokespecial_error = false;
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
    80
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
    81
  for (int i = len-1; i >= 0; i--) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    82
    Method* method = _methods->at(i);
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
    83
    scan_method(method, true, &invokespecial_error);
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
    84
    assert(!invokespecial_error, "reversing should not get an invokespecial error");
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
    85
  }
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
    86
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    88
// Creates a constant pool cache given a CPC map
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
    89
void Rewriter::make_constant_pool_cache(TRAPS) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    90
  ClassLoaderData* loader_data = _pool->pool_holder()->class_loader_data();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    91
  ConstantPoolCache* cache =
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
    92
      ConstantPoolCache::allocate(loader_data, _cp_cache_map,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
    93
                                  _invokedynamic_cp_cache_map,
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15799
diff changeset
    94
                                  _invokedynamic_references_map, CHECK);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    95
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    96
  // initialize object cache in constant pool
46427
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46362
diff changeset
    97
  _pool->set_cache(cache);
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46362
diff changeset
    98
  cache->set_constant_pool(_pool());
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46362
diff changeset
    99
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46362
diff changeset
   100
  // _resolved_references is stored in pool->cache(), so need to be done after
54713555867e 8171392: Move Klass pointers outside of ConstantPool entries so ConstantPool can be read-only
iklam
parents: 46362
diff changeset
   101
  // the above lines.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   102
  _pool->initialize_resolved_references(loader_data, _resolved_references_map,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   103
                                        _resolved_reference_limit,
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   104
                                        CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
// The new finalization semantics says that registration of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
// finalizable objects must be performed on successful return from the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
// Object.<init> constructor.  We could implement this trivially if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
// <init> were never rewritten but since JVMTI allows this to occur, a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
// more complicated solution is required.  A special return bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
// is used only by Object.<init> to signal the finalization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
// registration point.  Additionally local 0 must be preserved so it's
31587
e48945b7849c 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 30764
diff changeset
   116
// available to pass to the registration function.  For simplicity we
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
// require that local 0 is never overwritten so it's available as an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
// argument for registration.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
void Rewriter::rewrite_Object_init(methodHandle method, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  RawBytecodeStream bcs(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  while (!bcs.is_last_bytecode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
    Bytecodes::Code opcode = bcs.raw_next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
    switch (opcode) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
      case Bytecodes::_return: *bcs.bcp() = Bytecodes::_return_register_finalizer; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
      case Bytecodes::_istore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
      case Bytecodes::_lstore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
      case Bytecodes::_fstore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
      case Bytecodes::_dstore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
      case Bytecodes::_astore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
        if (bcs.get_index() != 0) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
        // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
      case Bytecodes::_istore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
      case Bytecodes::_lstore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
      case Bytecodes::_fstore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
      case Bytecodes::_dstore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
      case Bytecodes::_astore_0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
        THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
                  "can't overwrite local 0 in Object.<init>");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
        break;
46630
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46427
diff changeset
   143
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46427
diff changeset
   144
      default:
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46427
diff changeset
   145
        break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   151
// Rewrite a classfile-order CP index into a native-order CPC index.
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   152
void Rewriter::rewrite_member_reference(address bcp, int offset, bool reverse) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   153
  address p = bcp + offset;
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   154
  if (!reverse) {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   155
    int  cp_index    = Bytes::get_Java_u2(p);
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   156
    int  cache_index = cp_entry_to_cp_cache(cp_index);
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   157
    Bytes::put_native_u2(p, cache_index);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   158
    if (!_method_handle_invokers.is_empty())
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   159
      maybe_rewrite_invokehandle(p - 1, cp_index, cache_index, reverse);
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   160
  } else {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   161
    int cache_index = Bytes::get_native_u2(p);
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   162
    int pool_index = cp_cache_entry_pool_index(cache_index);
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   163
    Bytes::put_Java_u2(p, pool_index);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   164
    if (!_method_handle_invokers.is_empty())
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   165
      maybe_rewrite_invokehandle(p - 1, pool_index, cache_index, reverse);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   166
  }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   167
}
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   168
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   169
// If the constant pool entry for invokespecial is InterfaceMethodref,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   170
// we need to add a separate cpCache entry for its resolution, because it is
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   171
// different than the resolution for invokeinterface with InterfaceMethodref.
46362
974737822190 8168438: Fix comment in rewriter
coleenp
parents: 46329
diff changeset
   172
// These cannot share cpCache entries.
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   173
void Rewriter::rewrite_invokespecial(address bcp, int offset, bool reverse, bool* invokespecial_error) {
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   174
  address p = bcp + offset;
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   175
  if (!reverse) {
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   176
    int cp_index = Bytes::get_Java_u2(p);
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   177
    if (_pool->tag_at(cp_index).is_interface_method()) {
30117
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 22750
diff changeset
   178
      int cache_index = add_invokespecial_cp_cache_entry(cp_index);
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 22750
diff changeset
   179
      if (cache_index != (int)(jushort) cache_index) {
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 22750
diff changeset
   180
        *invokespecial_error = true;
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 22750
diff changeset
   181
      }
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 22750
diff changeset
   182
      Bytes::put_native_u2(p, cache_index);
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 22750
diff changeset
   183
    } else {
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   184
      rewrite_member_reference(bcp, offset, reverse);
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   185
    }
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   186
  } else {
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   187
    rewrite_member_reference(bcp, offset, reverse);
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   188
  }
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   189
}
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   190
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   191
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   192
// Adjust the invocation bytecode for a signature-polymorphic method (MethodHandle.invoke, etc.)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   193
void Rewriter::maybe_rewrite_invokehandle(address opc, int cp_index, int cache_index, bool reverse) {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   194
  if (!reverse) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   195
    if ((*opc) == (u1)Bytecodes::_invokevirtual ||
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   196
        // allow invokespecial as an alias, although it would be very odd:
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   197
        (*opc) == (u1)Bytecodes::_invokespecial) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   198
      assert(_pool->tag_at(cp_index).is_method(), "wrong index");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   199
      // Determine whether this is a signature-polymorphic method.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   200
      if (cp_index >= _method_handle_invokers.length())  return;
38031
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   201
      int status = _method_handle_invokers.at(cp_index);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   202
      assert(status >= -1 && status <= 1, "oob tri-state");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   203
      if (status == 0) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   204
        if (_pool->klass_ref_at_noresolve(cp_index) == vmSymbols::java_lang_invoke_MethodHandle() &&
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   205
            MethodHandles::is_signature_polymorphic_name(SystemDictionary::MethodHandle_klass(),
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   206
                                                         _pool->name_ref_at(cp_index))) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   207
          // we may need a resolved_refs entry for the appendix
13929
8da0dc50a6e4 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents: 13728
diff changeset
   208
          add_invokedynamic_resolved_references_entries(cp_index, cache_index);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   209
          status = +1;
36819
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35492
diff changeset
   210
        } else if (_pool->klass_ref_at_noresolve(cp_index) == vmSymbols::java_lang_invoke_VarHandle() &&
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35492
diff changeset
   211
                   MethodHandles::is_signature_polymorphic_name(SystemDictionary::VarHandle_klass(),
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35492
diff changeset
   212
                                                                _pool->name_ref_at(cp_index))) {
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35492
diff changeset
   213
          // we may need a resolved_refs entry for the appendix
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35492
diff changeset
   214
          add_invokedynamic_resolved_references_entries(cp_index, cache_index);
bca375d368ed 8149644: Integrate VarHandles
psandoz
parents: 35492
diff changeset
   215
          status = +1;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   216
        } else {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   217
          status = -1;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   218
        }
38031
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   219
        _method_handle_invokers.at(cp_index) = status;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   220
      }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   221
      // We use a special internal bytecode for such methods (if non-static).
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   222
      // The basic reason for this is that such methods need an extra "appendix" argument
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   223
      // to transmit the call site's intended call type.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   224
      if (status > 0) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   225
        (*opc) = (u1)Bytecodes::_invokehandle;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   226
      }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   227
    }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   228
  } else {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   229
    // Do not need to look at cp_index.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   230
    if ((*opc) == (u1)Bytecodes::_invokehandle) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   231
      (*opc) = (u1)Bytecodes::_invokevirtual;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   232
      // Ignore corner case of original _invokespecial instruction.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   233
      // This is safe because (a) the signature polymorphic method was final, and
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   234
      // (b) the implementation of MethodHandle will not call invokespecial on it.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   235
    }
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   236
  }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   237
}
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   238
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   239
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   240
void Rewriter::rewrite_invokedynamic(address bcp, int offset, bool reverse) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   241
  address p = bcp + offset;
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   242
  assert(p[-1] == Bytecodes::_invokedynamic, "not invokedynamic bytecode");
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   243
  if (!reverse) {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   244
    int cp_index = Bytes::get_Java_u2(p);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   245
    int cache_index = add_invokedynamic_cp_cache_entry(cp_index);
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   246
    int resolved_index = add_invokedynamic_resolved_references_entries(cp_index, cache_index);
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   247
    // Replace the trailing four bytes with a CPC index for the dynamic
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   248
    // call site.  Unlike other CPC entries, there is one per bytecode,
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   249
    // not just one per distinct CP entry.  In other words, the
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   250
    // CPC-to-CP relation is many-to-one for invokedynamic entries.
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   251
    // This means we must use a larger index size than u2 to address
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   252
    // all these entries.  That is the main reason invokedynamic
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   253
    // must have a five-byte instruction format.  (Of course, other JVM
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   254
    // implementations can use the bytes for other purposes.)
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   255
    // Note: We use native_u4 format exclusively for 4-byte indexes.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   256
    Bytes::put_native_u4(p, ConstantPool::encode_invokedynamic_index(cache_index));
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   257
    // add the bcp in case we need to patch this bytecode if we also find a
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   258
    // invokespecial/InterfaceMethodref in the bytecode stream
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   259
    _patch_invokedynamic_bcps->push(p);
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   260
    _patch_invokedynamic_refs->push(resolved_index);
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   261
  } else {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   262
    int cache_index = ConstantPool::decode_invokedynamic_index(
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   263
                        Bytes::get_native_u4(p));
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   264
    // We will reverse the bytecode rewriting _after_ adjusting them.
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   265
    // Adjust the cache index by offset to the invokedynamic entries in the
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   266
    // cpCache plus the delta if the invokedynamic bytecodes were adjusted.
22750
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   267
    int adjustment = cp_cache_delta() + _first_iteration_cp_cache_limit;
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   268
    int cp_index = invokedynamic_cp_cache_entry_pool_index(cache_index - adjustment);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   269
    assert(_pool->tag_at(cp_index).is_invoke_dynamic(), "wrong index");
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   270
    // zero out 4 bytes
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   271
    Bytes::put_Java_u4(p, 0);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   272
    Bytes::put_Java_u2(p, cp_index);
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   273
  }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   274
}
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   275
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   276
void Rewriter::patch_invokedynamic_bytecodes() {
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   277
  // If the end of the cp_cache is the same as after initializing with the
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   278
  // cpool, nothing needs to be done.  Invokedynamic bytecodes are at the
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   279
  // correct offsets. ie. no invokespecials added
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   280
  int delta = cp_cache_delta();
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   281
  if (delta > 0) {
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   282
    int length = _patch_invokedynamic_bcps->length();
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   283
    assert(length == _patch_invokedynamic_refs->length(),
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   284
           "lengths should match");
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   285
    for (int i = 0; i < length; i++) {
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   286
      address p = _patch_invokedynamic_bcps->at(i);
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   287
      int cache_index = ConstantPool::decode_invokedynamic_index(
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   288
                          Bytes::get_native_u4(p));
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   289
      Bytes::put_native_u4(p, ConstantPool::encode_invokedynamic_index(cache_index + delta));
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   290
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   291
      // invokedynamic resolved references map also points to cp cache and must
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   292
      // add delta to each.
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   293
      int resolved_index = _patch_invokedynamic_refs->at(i);
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   294
      for (int entry = 0; entry < ConstantPoolCacheEntry::_indy_resolved_references_entries; entry++) {
38031
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   295
        assert(_invokedynamic_references_map.at(resolved_index + entry) == cache_index,
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   296
             "should be the same index");
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   297
        _invokedynamic_references_map.at_put(resolved_index+entry,
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   298
                                             cache_index + delta);
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   299
      }
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   300
    }
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   301
  }
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   302
}
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   303
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   304
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   305
// Rewrite some ldc bytecodes to _fast_aldc
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   306
void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide,
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   307
                                 bool reverse) {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   308
  if (!reverse) {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   309
    assert((*bcp) == (is_wide ? Bytecodes::_ldc_w : Bytecodes::_ldc), "not ldc bytecode");
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   310
    address p = bcp + offset;
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   311
    int cp_index = is_wide ? Bytes::get_Java_u2(p) : (u1)(*p);
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   312
    constantTag tag = _pool->tag_at(cp_index).value();
15799
6aa92f9debd2 8000797: NPG: is_pseudo_string_at() doesn't work
coleenp
parents: 15099
diff changeset
   313
    if (tag.is_method_handle() || tag.is_method_type() || tag.is_string()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   314
      int ref_index = cp_entry_to_resolved_references(cp_index);
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   315
      if (is_wide) {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   316
        (*bcp) = Bytecodes::_fast_aldc_w;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   317
        assert(ref_index == (u2)ref_index, "index overflow");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   318
        Bytes::put_native_u2(p, ref_index);
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   319
      } else {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   320
        (*bcp) = Bytecodes::_fast_aldc;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   321
        assert(ref_index == (u1)ref_index, "index overflow");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   322
        (*p) = (u1)ref_index;
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   323
      }
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   324
    }
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   325
  } else {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   326
    Bytecodes::Code rewritten_bc =
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   327
              (is_wide ? Bytecodes::_fast_aldc_w : Bytecodes::_fast_aldc);
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   328
    if ((*bcp) == rewritten_bc) {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   329
      address p = bcp + offset;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   330
      int ref_index = is_wide ? Bytes::get_native_u2(p) : (u1)(*p);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   331
      int pool_index = resolved_references_entry_to_pool_index(ref_index);
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   332
      if (is_wide) {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   333
        (*bcp) = Bytecodes::_ldc_w;
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   334
        assert(pool_index == (u2)pool_index, "index overflow");
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   335
        Bytes::put_Java_u2(p, pool_index);
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   336
      } else {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   337
        (*bcp) = Bytecodes::_ldc;
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   338
        assert(pool_index == (u1)pool_index, "index overflow");
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   339
        (*p) = (u1)pool_index;
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   340
      }
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   341
    }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   342
  }
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   343
}
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   344
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   345
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
// Rewrites a method given the index_map information
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   347
void Rewriter::scan_method(Method* method, bool reverse, bool* invokespecial_error) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  int nof_jsrs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  bool has_monitor_bytecodes = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    // We cannot tolerate a GC in this block, because we've
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   354
    // cached the bytecodes in 'code_base'. If the Method*
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    // moves, the bytecodes will also move.
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 33593
diff changeset
   356
    NoSafepointVerifier nsv;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    Bytecodes::Code c;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    // Bytecodes and their length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
    const address code_base = method->code_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    const int code_length = method->code_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
    int bc_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
    for (int bci = 0; bci < code_length; bci += bc_length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
      address bcp = code_base + bci;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   366
      int prefix_length = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
      c = (Bytecodes::Code)(*bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
      // Since we have the code, see if we can get the length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
      // directly. Some more complicated bytecodes will report
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
      // a length of zero, meaning we need to make another method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
      // call to calculate the length.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
      bc_length = Bytecodes::length_for(c);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
      if (bc_length == 0) {
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7436
diff changeset
   375
        bc_length = Bytecodes::length_at(method, bcp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
        // length_at will put us at the bytecode after the one modified
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
        // by 'wide'. We don't currently examine any of the bytecodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
        // modified by wide, but in case we do in the future...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
        if (c == Bytecodes::_wide) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   381
          prefix_length = 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
          c = (Bytecodes::Code)bcp[1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
      assert(bc_length != 0, "impossible bytecode length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
      switch (c) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
        case Bytecodes::_lookupswitch   : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
#ifndef CC_INTERP
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7436
diff changeset
   391
          Bytecode_lookupswitch bc(method, bcp);
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 4567
diff changeset
   392
          (*bcp) = (
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7436
diff changeset
   393
            bc.number_of_pairs() < BinarySwitchThreshold
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
            ? Bytecodes::_fast_linearswitch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
            : Bytecodes::_fast_binaryswitch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
          );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
        }
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   400
        case Bytecodes::_fast_linearswitch:
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   401
        case Bytecodes::_fast_binaryswitch: {
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   402
#ifndef CC_INTERP
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   403
          (*bcp) = Bytecodes::_lookupswitch;
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   404
#endif
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   405
          break;
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   406
        }
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   407
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   408
        case Bytecodes::_invokespecial  : {
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   409
          rewrite_invokespecial(bcp, prefix_length+1, reverse, invokespecial_error);
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   410
          break;
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   411
        }
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   412
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   413
        case Bytecodes::_putstatic      :
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   414
        case Bytecodes::_putfield       : {
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   415
          if (!reverse) {
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   416
            // Check if any final field of the class given as parameter is modified
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   417
            // outside of initializer methods of the class. Fields that are modified
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   418
            // are marked with a flag. For marked fields, the compilers do not perform
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   419
            // constant folding (as the field can be changed after initialization).
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   420
            //
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   421
            // The check is performed after verification and only if verification has
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   422
            // succeeded. Therefore, the class is guaranteed to be well-formed.
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   423
            InstanceKlass* klass = method->method_holder();
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   424
            u2 bc_index = Bytes::get_Java_u2(bcp + prefix_length + 1);
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   425
            constantPoolHandle cp(method->constants());
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   426
            Symbol* ref_class_name = cp->klass_name_at(cp->klass_ref_index_at(bc_index));
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   427
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   428
            if (klass->name() == ref_class_name) {
39619
905b6eee37b3 8160551: assert(c == Bytecodes::_putfield) failed: must be putfield
coleenp
parents: 39421
diff changeset
   429
              Symbol* field_name = cp->name_ref_at(bc_index);
905b6eee37b3 8160551: assert(c == Bytecodes::_putfield) failed: must be putfield
coleenp
parents: 39421
diff changeset
   430
              Symbol* field_sig = cp->signature_ref_at(bc_index);
905b6eee37b3 8160551: assert(c == Bytecodes::_putfield) failed: must be putfield
coleenp
parents: 39421
diff changeset
   431
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   432
              fieldDescriptor fd;
42870
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   433
              if (klass->find_field(field_name, field_sig, &fd) != NULL) {
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   434
                if (fd.access_flags().is_final()) {
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   435
                  if (fd.access_flags().is_static()) {
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   436
                    if (!method->is_static_initializer()) {
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   437
                      fd.set_has_initialized_final_update(true);
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   438
                    }
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   439
                  } else {
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   440
                    if (!method->is_object_initializer()) {
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   441
                      fd.set_has_initialized_final_update(true);
525f24ac5db0 8171155: Scanning method file for initialized final field updates can fail for non-existent fields
zmajo
parents: 39619
diff changeset
   442
                    }
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   443
                  }
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   444
                }
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   445
              }
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   446
            }
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   447
          }
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   448
        }
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 38031
diff changeset
   449
        // fall through
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
        case Bytecodes::_getstatic      : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
        case Bytecodes::_getfield       : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
        case Bytecodes::_invokevirtual  : // fall through
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   453
        case Bytecodes::_invokestatic   :
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   454
        case Bytecodes::_invokeinterface:
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   455
        case Bytecodes::_invokehandle   : // if reverse=true
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   456
          rewrite_member_reference(bcp, prefix_length+1, reverse);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
          break;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   458
        case Bytecodes::_invokedynamic:
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   459
          rewrite_invokedynamic(bcp, prefix_length+1, reverse);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   460
          break;
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   461
        case Bytecodes::_ldc:
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   462
        case Bytecodes::_fast_aldc:  // if reverse=true
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   463
          maybe_rewrite_ldc(bcp, prefix_length+1, false, reverse);
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   464
          break;
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   465
        case Bytecodes::_ldc_w:
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 9971
diff changeset
   466
        case Bytecodes::_fast_aldc_w:  // if reverse=true
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   467
          maybe_rewrite_ldc(bcp, prefix_length+1, true, reverse);
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   468
          break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
        case Bytecodes::_jsr            : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
        case Bytecodes::_jsr_w          : nof_jsrs++;                   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
        case Bytecodes::_monitorenter   : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
        case Bytecodes::_monitorexit    : has_monitor_bytecodes = true; break;
46630
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46427
diff changeset
   473
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46427
diff changeset
   474
        default: break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  // Update access flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  if (has_monitor_bytecodes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
    method->set_has_monitor_bytecodes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  // The present of a jsr bytecode implies that the method might potentially
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  // have to be rewritten, so we run the oopMapGenerator on the method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  if (nof_jsrs > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
    method->set_has_jsrs();
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   488
    // Second pass will revisit this method.
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   489
    assert(method->has_jsrs(), "didn't we just set this?");
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   490
  }
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   491
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   493
// After constant pool is created, revisit methods containing jsrs.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   494
methodHandle Rewriter::rewrite_jsrs(methodHandle method, TRAPS) {
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   495
  ResourceMark rm(THREAD);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   496
  ResolveOopMapConflicts romc(method);
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   497
  methodHandle original_method = method;
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   498
  method = romc.do_potential_rewrite(CHECK_(methodHandle()));
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   499
  // Update monitor matching info.
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   500
  if (romc.monitor_safe()) {
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   501
    method->set_guaranteed_monitor_matching();
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   502
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  return method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
22750
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   507
void Rewriter::rewrite_bytecodes(TRAPS) {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   508
  assert(_pool->cache() == NULL, "constant pool cache must not be set yet");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   510
  // determine index maps for Method* rewriting
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   511
  compute_index_maps();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   513
  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
   514
    bool did_rewrite = false;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   515
    int i = _methods->length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    while (i-- > 0) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   517
      Method* method = _methods->at(i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
      if (method->intrinsic_id() == vmIntrinsics::_Object_init) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
        // rewrite the return bytecodes of Object.<init> to register the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
        // object for finalization if needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
        methodHandle m(THREAD, method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
        rewrite_Object_init(m, CHECK);
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   523
        did_rewrite = true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
    }
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2570
diff changeset
   527
    assert(did_rewrite, "must find Object::<init> to rewrite it");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   530
  // rewrite methods, in two passes
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   531
  int len = _methods->length();
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   532
  bool invokespecial_error = false;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   533
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   534
  for (int i = len-1; i >= 0; i--) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   535
    Method* method = _methods->at(i);
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   536
    scan_method(method, false, &invokespecial_error);
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   537
    if (invokespecial_error) {
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   538
      // If you get an error here, there is no reversing bytecodes
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   539
      // This exception is stored for this class and no further attempt is
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   540
      // made at verifying or rewriting.
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   541
      THROW_MSG(vmSymbols::java_lang_InternalError(),
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   542
                "This classfile overflows invokespecial for interfaces "
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   543
                "and cannot be loaded");
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   544
      return;
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   545
     }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   546
  }
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   547
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   548
  // May have to fix invokedynamic bytecodes if invokestatic/InterfaceMethodref
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   549
  // entries had to be added.
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   550
  patch_invokedynamic_bytecodes();
22750
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   551
}
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   552
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42870
diff changeset
   553
void Rewriter::rewrite(InstanceKlass* klass, TRAPS) {
30117
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 22750
diff changeset
   554
  if (!DumpSharedSpaces) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42870
diff changeset
   555
    assert(!MetaspaceShared::is_in_shared_space(klass), "archive methods must not be rewritten at run time");
30117
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 22750
diff changeset
   556
  }
22750
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   557
  ResourceMark rm(THREAD);
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   558
  Rewriter     rw(klass, klass->constants(), klass->methods(), CHECK);
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   559
  // (That's all, folks.)
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   560
}
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   561
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42870
diff changeset
   562
Rewriter::Rewriter(InstanceKlass* klass, const constantPoolHandle& cpool, Array<Method*>* methods, TRAPS)
22750
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   563
  : _klass(klass),
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   564
    _pool(cpool),
38031
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   565
    _methods(methods),
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   566
    _cp_map(cpool->length()),
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   567
    _cp_cache_map(cpool->length() / 2),
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   568
    _reference_map(cpool->length()),
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   569
    _resolved_references_map(cpool->length() / 2),
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   570
    _invokedynamic_references_map(cpool->length() / 2),
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   571
    _method_handle_invokers(cpool->length()),
e0b822facc03 8149374: Replace C1-specific collection classes with universal collection classes
fzhinkin
parents: 36819
diff changeset
   572
    _invokedynamic_cp_cache_map(cpool->length() / 4)
22750
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   573
{
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   574
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   575
  // Rewrite bytecodes - exception here exits.
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   576
  rewrite_bytecodes(CHECK);
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   577
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   578
  // Stress restoring bytecodes
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   579
  if (StressRewriter) {
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   580
    restore_bytecodes();
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   581
    rewrite_bytecodes(CHECK);
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   582
  }
21557
55115e0708f1 8025937: assert(existing_f1 == NULL || existing_f1 == f1) failed: illegal field change
coleenp
parents: 15928
diff changeset
   583
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   584
  // allocate constant pool cache, now that we've seen all the bytecodes
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   585
  make_constant_pool_cache(THREAD);
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   586
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   587
  // Restore bytecodes to their unrewritten state if there are exceptions
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   588
  // rewriting bytecodes or allocating the cpCache
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   589
  if (HAS_PENDING_EXCEPTION) {
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   590
    restore_bytecodes();
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   591
    return;
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   592
  }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   593
15099
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   594
  // Relocate after everything, but still do this under the is_rewritten flag,
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   595
  // so methods with jsrs in custom class lists in aren't attempted to be
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   596
  // rewritten in the RO section of the shared archive.
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   597
  // Relocated bytecodes don't have to be restored, only the cp cache entries
22750
a3c879b18f22 8033528: assert(0 <= i && i < length()) failed: index out of bounds
coleenp
parents: 21734
diff changeset
   598
  int len = _methods->length();
9971
d496ecd7b9de 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 9116
diff changeset
   599
  for (int i = len-1; i >= 0; i--) {
15099
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   600
    methodHandle m(THREAD, _methods->at(i));
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   601
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2105
diff changeset
   602
    if (m->has_jsrs()) {
15099
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   603
      m = rewrite_jsrs(m, THREAD);
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   604
      // Restore bytecodes to their unrewritten state if there are exceptions
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   605
      // relocating bytecodes.  If some are relocated, that is ok because that
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   606
      // doesn't affect constant pool to cpCache rewriting.
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   607
      if (HAS_PENDING_EXCEPTION) {
21734
440a9598dc23 8028347: Rewriter::scan_method asserts with array oob in RT_Baseline
coleenp
parents: 21557
diff changeset
   608
        restore_bytecodes();
15099
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   609
        return;
b31d40895bbb 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents: 13929
diff changeset
   610
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
      // Method might have gotten rewritten.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   612
      methods->at_put(i, m());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
}