hotspot/src/share/vm/interpreter/interpreterRuntime.cpp
author stefank
Wed, 05 Jul 2017 11:33:17 +0200
changeset 46625 edefffab74e2
parent 46620 750c6edff33b
child 46691 cecf240c87a0
permissions -rw-r--r--
8183552: Move align functions to align.hpp Reviewed-by: stuefe, pliden
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: 42664
diff changeset
     2
 * Copyright (c) 1997, 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: 5420
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    25
#include "precompiled.hpp"
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28196
diff changeset
    26
#include "classfile/javaClasses.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    27
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    28
#include "classfile/vmSymbols.hpp"
31382
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
    29
#include "code/codeCache.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    30
#include "compiler/compileBroker.hpp"
14626
0cf4eccf130f 8003240: x86: move MacroAssembler into separate file
twisti
parents: 14490
diff changeset
    31
#include "compiler/disassembler.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30599
diff changeset
    32
#include "gc/shared/collectedHeap.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    33
#include "interpreter/interpreter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    34
#include "interpreter/interpreterRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    35
#include "interpreter/linkResolver.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    36
#include "interpreter/templateTable.hpp"
35216
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 35071
diff changeset
    37
#include "logging/log.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    38
#include "memory/oopFactory.hpp"
37248
11a660dbbb8e 8132524: Missing includes to resourceArea.hpp
jprovino
parents: 37179
diff changeset
    39
#include "memory/resourceArea.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    40
#include "memory/universe.inline.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    41
#include "oops/constantPool.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    42
#include "oops/instanceKlass.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    43
#include "oops/methodData.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    44
#include "oops/objArrayKlass.hpp"
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28196
diff changeset
    45
#include "oops/objArrayOop.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    46
#include "oops/oop.inline.hpp"
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7915
diff changeset
    47
#include "oops/symbol.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    48
#include "prims/jvmtiExport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    49
#include "prims/nativeLookup.hpp"
40655
9f644073d3a0 8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents: 39699
diff changeset
    50
#include "runtime/atomic.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    51
#include "runtime/biasedLocking.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    52
#include "runtime/compilationPolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    53
#include "runtime/deoptimization.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    54
#include "runtime/fieldDescriptor.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    55
#include "runtime/handles.inline.hpp"
25715
d5a8dbdc5150 8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories.
goetz
parents: 25351
diff changeset
    56
#include "runtime/icache.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    57
#include "runtime/interfaceSupport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    58
#include "runtime/java.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    59
#include "runtime/jfieldIDWorkaround.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    60
#include "runtime/osThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    61
#include "runtime/sharedRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    62
#include "runtime/stubRoutines.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    63
#include "runtime/synchronizer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    64
#include "runtime/threadCritical.hpp"
46625
edefffab74e2 8183552: Move align functions to align.hpp
stefank
parents: 46620
diff changeset
    65
#include "utilities/align.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    66
#include "utilities/events.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    67
#ifdef COMPILER2
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    68
#include "opto/runtime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7114
diff changeset
    69
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
class UnlockFlagSaver {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    JavaThread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    bool _do_not_unlock;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    UnlockFlagSaver(JavaThread* t) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
      _thread = t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
      _do_not_unlock = t->do_not_unlock_if_synchronized();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
      t->set_do_not_unlock_if_synchronized(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
    ~UnlockFlagSaver() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
      _thread->set_do_not_unlock_if_synchronized(_do_not_unlock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
// State accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
void InterpreterRuntime::set_bcp_and_mdp(address bcp, JavaThread *thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  last_frame(thread).interpreter_frame_set_bcp(bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  if (ProfileInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    // ProfileTraps uses MDOs independently of ProfileInterpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    // That is why we must check both ProfileInterpreter and mdo != NULL.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
    94
    MethodData* mdo = last_frame(thread).interpreter_frame_method()->method_data();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    if (mdo != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
      NEEDS_CLEANUP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
      last_frame(thread).interpreter_frame_set_mdp(mdo->bci_to_dp(last_frame(thread).interpreter_frame_bci()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
// Constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
IRT_ENTRY(void, InterpreterRuntime::ldc(JavaThread* thread, bool wide))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // access constant pool
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   108
  ConstantPool* pool = method(thread)->constants();
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 5420
diff changeset
   109
  int index = wide ? get_index_u2(thread, Bytecodes::_ldc_w) : get_index_u1(thread, Bytecodes::_ldc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  constantTag tag = pool->tag_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   112
  assert (tag.is_unresolved_klass() || tag.is_klass(), "wrong ldc call");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   113
  Klass* klass = pool->klass_at(index, CHECK);
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8676
diff changeset
   114
    oop java_class = klass->java_mirror();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    thread->set_vm_result(java_class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   118
IRT_ENTRY(void, InterpreterRuntime::resolve_ldc(JavaThread* thread, Bytecodes::Code bytecode)) {
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   119
  assert(bytecode == Bytecodes::_fast_aldc ||
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   120
         bytecode == Bytecodes::_fast_aldc_w, "wrong bc");
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   121
  ResourceMark rm(thread);
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   122
  methodHandle m (thread, method(thread));
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7411
diff changeset
   123
  Bytecode_loadconstant ldc(m, bci(thread));
9960
43fe83652b18 7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents: 9116
diff changeset
   124
  oop result = ldc.resolve_constant(CHECK);
43fe83652b18 7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents: 9116
diff changeset
   125
#ifdef ASSERT
43fe83652b18 7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents: 9116
diff changeset
   126
  {
43fe83652b18 7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents: 9116
diff changeset
   127
    // The bytecode wrappers aren't GC-safe so construct a new one
43fe83652b18 7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents: 9116
diff changeset
   128
    Bytecode_loadconstant ldc2(m, bci(thread));
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   129
    oop coop = m->constants()->resolved_references()->obj_at(ldc2.cache_index());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   130
    assert(result == coop, "expected result for assembly code");
9960
43fe83652b18 7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents: 9116
diff changeset
   131
  }
43fe83652b18 7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents: 9116
diff changeset
   132
#endif
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   133
  thread->set_vm_result(result);
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   134
}
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   135
IRT_END
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   136
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
// Allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   141
IRT_ENTRY(void, InterpreterRuntime::_new(JavaThread* thread, ConstantPool* pool, int index))
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42664
diff changeset
   142
  Klass* k = pool->klass_at(index, CHECK);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42664
diff changeset
   143
  InstanceKlass* klass = InstanceKlass::cast(k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // Make sure we are not instantiating an abstract klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  klass->check_valid_for_instantiation(true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // Make sure klass is initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  klass->initialize(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // At this point the class may not be fully initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // because of recursive initialization. If it is fully
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // initialized & has_finalized is not set, we rewrite
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // it into its fast version (Note: no locking is needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  // here since this is an atomic byte write and can be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // done more than once).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // Note: In case of classes with has_finalized we don't
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  //       rewrite since that saves us an extra check in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  //       the fast version which then would call the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  //       slow version anyway (and do a call back into
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  //       Java).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  //       If we have a breakpoint, then we don't rewrite
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  //       because the _breakpoint bytecode would be lost.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  oop obj = klass->allocate_instance(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  thread->set_vm_result(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
IRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  oop obj = oopFactory::new_typeArray(type, size, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  thread->set_vm_result(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   176
IRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size))
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   177
  Klass*    klass = pool->klass_at(index, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  objArrayOop obj = oopFactory::new_objArray(klass, size, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  thread->set_vm_result(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
IRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* first_size_address))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // We may want to pass in more arguments - could make this slightly faster
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   185
  ConstantPool* constants = method(thread)->constants();
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 5420
diff changeset
   186
  int          i = get_index_u2(thread, Bytecodes::_multianewarray);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   187
  Klass* klass = constants->klass_at(i, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  int   nof_dims = number_of_dimensions(thread);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   189
  assert(klass->is_klass(), "not a class");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  assert(nof_dims >= 1, "multianewarray rank must be nonzero");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  // We must create an array of jints to pass to multi_allocate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  const int small_dims = 10;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  jint dim_array[small_dims];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  jint *dims = &dim_array[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  if (nof_dims > small_dims) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    dims = (jint*) NEW_RESOURCE_ARRAY(jint, nof_dims);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  for (int index = 0; index < nof_dims; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    // offset from first_size_address is addressed as local[index]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    int n = Interpreter::local_offset_in_bytes(index)/jintSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    dims[index] = first_size_address[n];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  }
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13740
diff changeset
   205
  oop obj = ArrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  thread->set_vm_result(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
IRT_ENTRY(void, InterpreterRuntime::register_finalizer(JavaThread* thread, oopDesc* obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  assert(obj->is_oop(), "must be a valid oop");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   212
  assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   213
  InstanceKlass::register_finalizer(instanceOop(obj), CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
// Quicken instance-of and check-cast bytecodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
IRT_ENTRY(void, InterpreterRuntime::quicken_io_cc(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  // Force resolving; quicken the bytecode
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 5420
diff changeset
   220
  int which = get_index_u2(thread, Bytecodes::_checkcast);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   221
  ConstantPool* cpool = method(thread)->constants();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  // We'd expect to assert that we're only here to quicken bytecodes, but in a multithreaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  // program we might have seen an unquick'd bytecode in the interpreter but have another
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  // thread quicken the bytecode before we get here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  // assert( cpool->tag_at(which).is_unresolved_klass(), "should only come here to quicken bytecodes" );
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   226
  Klass* klass = cpool->klass_at(which, CHECK);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   227
  thread->set_vm_result_2(klass);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
// Exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
22836
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   234
void InterpreterRuntime::note_trap_inner(JavaThread* thread, int reason,
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   235
                                         methodHandle trap_method, int trap_bci, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  if (trap_method.not_null()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   237
    MethodData* trap_mdo = trap_method->method_data();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   238
    if (trap_mdo == NULL) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   239
      Method::build_interpreter_method_data(trap_method, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
      if (HAS_PENDING_EXCEPTION) {
22836
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   241
        assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())),
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   242
               "we expect only an OOM error here");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
        CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
      }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   245
      trap_mdo = trap_method->method_data();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
      // and fall through...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   248
    if (trap_mdo != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
      // Update per-method count of trap events.  The interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
      // is updating the MDO to simulate the effect of compiler traps.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
      Deoptimization::update_method_data_from_interpreter(trap_mdo, trap_bci, reason);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
22836
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   256
// Assume the compiler is (or will be) interested in this event.
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   257
// If necessary, create an MDO to hold the information, and record it.
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   258
void InterpreterRuntime::note_trap(JavaThread* thread, int reason, TRAPS) {
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   259
  assert(ProfileTraps, "call me only if profiling");
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   260
  methodHandle trap_method(thread, method(thread));
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   261
  int trap_bci = trap_method->bci_from(bcp(thread));
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   262
  note_trap_inner(thread, reason, trap_method, trap_bci, THREAD);
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   263
}
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   264
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   265
#ifdef CC_INTERP
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   266
// As legacy note_trap, but we have more arguments.
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   267
IRT_ENTRY(void, InterpreterRuntime::note_trap(JavaThread* thread, int reason, Method *method, int trap_bci))
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   268
  methodHandle trap_method(method);
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   269
  note_trap_inner(thread, reason, trap_method, trap_bci, THREAD);
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   270
IRT_END
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   271
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   272
// Class Deoptimization is not visible in BytecodeInterpreter, so we need a wrapper
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   273
// for each exception.
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   274
void InterpreterRuntime::note_nullCheck_trap(JavaThread* thread, Method *method, int trap_bci)
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   275
  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_null_check, method, trap_bci); }
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   276
void InterpreterRuntime::note_div0Check_trap(JavaThread* thread, Method *method, int trap_bci)
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   277
  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_div0_check, method, trap_bci); }
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   278
void InterpreterRuntime::note_rangeCheck_trap(JavaThread* thread, Method *method, int trap_bci)
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   279
  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_range_check, method, trap_bci); }
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   280
void InterpreterRuntime::note_classCheck_trap(JavaThread* thread, Method *method, int trap_bci)
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   281
  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_class_check, method, trap_bci); }
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   282
void InterpreterRuntime::note_arrayCheck_trap(JavaThread* thread, Method *method, int trap_bci)
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   283
  { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_array_check, method, trap_bci); }
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   284
#endif // CC_INTERP
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   285
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 19266
diff changeset
   286
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   287
static Handle get_preinitialized_exception(Klass* k, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  // get klass
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   289
  InstanceKlass* klass = InstanceKlass::cast(k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  assert(klass->is_initialized(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
         "this klass should have been initialized during VM initialization");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  // create instance - do not call constructor since we may have no
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  // (java) stack space left (should assert constructor is empty)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  Handle exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  oop exception_oop = klass->allocate_instance(CHECK_(exception));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  exception = Handle(THREAD, exception_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  if (StackTraceInThrowable) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    java_lang_Throwable::fill_in_stack_trace(exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  return exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
// Special handling for stack overflow: since we don't have any (java) stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
// space left we use the pre-allocated & pre-initialized StackOverflowError
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
// klass to create an stack overflow error instance.  We do not call its
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
// constructor for the same reason (it is empty, anyway).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
IRT_ENTRY(void, InterpreterRuntime::throw_StackOverflowError(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  Handle exception = get_preinitialized_exception(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
                                 SystemDictionary::StackOverflowError_klass(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
                                 CHECK);
31335
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 30764
diff changeset
   311
  // Increment counter for hs_err file reporting
60081f497e75 8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents: 30764
diff changeset
   312
  Atomic::inc(&Exceptions::_stack_overflow_errors);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  THROW_HANDLE(exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
37435
e7aff5e5eff9 8146093: [sparc only] compiler/interpreter/7116216/StackOverflow.java Program terminates with signal 11, Segmentation fault. in __1cLRegisterMap2t6MpnKJavaThread_b_v_ ()
fparain
parents: 37248
diff changeset
   316
IRT_ENTRY(void, InterpreterRuntime::throw_delayed_StackOverflowError(JavaThread* thread))
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33638
diff changeset
   317
  Handle exception = get_preinitialized_exception(
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33638
diff changeset
   318
                                 SystemDictionary::StackOverflowError_klass(),
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33638
diff changeset
   319
                                 CHECK);
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33638
diff changeset
   320
  java_lang_Throwable::set_message(exception(),
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33638
diff changeset
   321
          Universe::delayed_stack_overflow_error_message());
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33638
diff changeset
   322
  // Increment counter for hs_err file reporting
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33638
diff changeset
   323
  Atomic::inc(&Exceptions::_stack_overflow_errors);
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33638
diff changeset
   324
  THROW_HANDLE(exception);
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33638
diff changeset
   325
IRT_END
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
IRT_ENTRY(void, InterpreterRuntime::create_exception(JavaThread* thread, char* name, char* message))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  // lookup exception klass
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7915
diff changeset
   329
  TempNewSymbol s = SymbolTable::new_symbol(name, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  if (ProfileTraps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    if (s == vmSymbols::java_lang_ArithmeticException()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
      note_trap(thread, Deoptimization::Reason_div0_check, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    } else if (s == vmSymbols::java_lang_NullPointerException()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
      note_trap(thread, Deoptimization::Reason_null_check, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // create exception
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7915
diff changeset
   338
  Handle exception = Exceptions::new_exception(thread, s, message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  thread->set_vm_result(exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
IRT_ENTRY(void, InterpreterRuntime::create_klass_exception(JavaThread* thread, char* name, oopDesc* obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  ResourceMark rm(thread);
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 13961
diff changeset
   345
  const char* klass_name = obj->klass()->external_name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  // lookup exception klass
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7915
diff changeset
   347
  TempNewSymbol s = SymbolTable::new_symbol(name, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  if (ProfileTraps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    note_trap(thread, Deoptimization::Reason_class_check, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  // create exception, with klass name as detail message
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7915
diff changeset
   352
  Handle exception = Exceptions::new_exception(thread, s, klass_name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  thread->set_vm_result(exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
IRT_ENTRY(void, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException(JavaThread* thread, char* name, jint index))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  char message[jintAsStringSize];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  // lookup exception klass
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7915
diff changeset
   360
  TempNewSymbol s = SymbolTable::new_symbol(name, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  if (ProfileTraps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
    note_trap(thread, Deoptimization::Reason_range_check, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  // create exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  sprintf(message, "%d", index);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7915
diff changeset
   366
  THROW_MSG(s, message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
IRT_ENTRY(void, InterpreterRuntime::throw_ClassCastException(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  JavaThread* thread, oopDesc* obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  char* message = SharedRuntime::generate_class_cast_message(
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36392
diff changeset
   374
    thread, obj->klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  if (ProfileTraps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    note_trap(thread, Deoptimization::Reason_class_check, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  // create exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  THROW_MSG(vmSymbols::java_lang_ClassCastException(), message);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
// exception_handler_for_exception(...) returns the continuation address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
// the exception oop (via TLS) and sets the bci/bcp for the continuation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
// The exception oop is returned to make sure it is preserved over GC (it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
// is only on the stack if the exception was thrown explicitly via athrow).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
// During this operation, the expression stack contains the values for the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
// bci where the exception happened. If the exception was propagated back
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
// from a call, the expression stack contains the values for the bci at the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
// invoke w/o arguments (i.e., as if one were inside the call).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
IRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThread* thread, oopDesc* exception))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  Handle             h_exception(thread, exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  methodHandle       h_method   (thread, method(thread));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  constantPoolHandle h_constants(thread, h_method->constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  bool               should_repeat;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  int                handler_bci;
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5702
diff changeset
   399
  int                current_bci = bci(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
28039
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   401
  if (thread->frames_to_pop_failed_realloc() > 0) {
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   402
    // Allocation of scalar replaced object used in this frame
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   403
    // failed. Unconditionally pop the frame.
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   404
    thread->dec_frames_to_pop_failed_realloc();
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   405
    thread->set_vm_result(h_exception());
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   406
    // If the method is synchronized we already unlocked the monitor
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   407
    // during deoptimization so the interpreter needs to skip it when
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   408
    // the frame is popped.
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   409
    thread->set_do_not_unlock_if_synchronized(true);
28196
6ba2bd76ea84 8067231: Zero builds fails after JDK-6898462
roland
parents: 28039
diff changeset
   410
#ifdef CC_INTERP
6ba2bd76ea84 8067231: Zero builds fails after JDK-6898462
roland
parents: 28039
diff changeset
   411
    return (address) -1;
6ba2bd76ea84 8067231: Zero builds fails after JDK-6898462
roland
parents: 28039
diff changeset
   412
#else
28039
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   413
    return Interpreter::remove_activation_entry();
28196
6ba2bd76ea84 8067231: Zero builds fails after JDK-6898462
roland
parents: 28039
diff changeset
   414
#endif
28039
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   415
  }
bf5a8340bf8a 6898462: The escape analysis with G1 cause crash assertion src/share/vm/runtime/vframeArray.cpp:94
roland
parents: 27420
diff changeset
   416
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  // Need to do this check first since when _do_not_unlock_if_synchronized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  // is set, we don't want to trigger any classloading which may make calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  // into java, or surprisingly find a matching exception handler for bci 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  // since at this moment the method hasn't been "officially" entered yet.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  if (thread->do_not_unlock_if_synchronized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
    assert(current_bci == 0,  "bci isn't zero for do_not_unlock_if_synchronized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
    thread->set_vm_result(exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
    return (address) -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    return Interpreter::remove_activation_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
    should_repeat = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
    // assertions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
    assert(h_exception.not_null(), "NULL exceptions should be handled by athrow");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
    assert(h_exception->is_oop(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
    // Check that exception is a subclass of Throwable, otherwise we have a VerifyError
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
   440
    if (!(h_exception->is_a(SystemDictionary::Throwable_klass()))) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
      if (ExitVMOnVerifyError) vm_exit(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
      ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
    // tracing
35216
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 35071
diff changeset
   447
    if (log_is_enabled(Info, exceptions)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
      ResourceMark rm(thread);
35216
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 35071
diff changeset
   449
      stringStream tempst;
35477
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35463
diff changeset
   450
      tempst.print("interpreter method <%s>\n"
35216
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 35071
diff changeset
   451
                   " at bci %d for thread " INTPTR_FORMAT,
71c463a17b3b 8141211: Convert TraceExceptions to Unified Logging
rprotacio
parents: 35071
diff changeset
   452
                   h_method->print_value_string(), current_bci, p2i(thread));
35477
7a00b08d27bc 8144953: runtime/CommandLine/TraceExceptionsTest.java fails when exception is thrown in compiled code
rprotacio
parents: 35463
diff changeset
   453
      Exceptions::log_exception(h_exception, tempst);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
// Don't go paging in something which won't be used.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   456
//     else if (extable->length() == 0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
//       // disabled for now - interpreter is not using shortcut yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
//       // (shortcut is not to call runtime if we have no exception handlers)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
//       // warning("performance bug: should not call runtime if method has no exception handlers");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
//     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
    // for AbortVMOnException flag
33208
5ec6ffa63c57 8136577: Make AbortVMOnException available in product builds
poonam
parents: 33148
diff changeset
   462
    Exceptions::debug_check_abort(h_exception);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
    // exception handler lookup
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42664
diff changeset
   465
    Klass* klass = h_exception->klass();
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42664
diff changeset
   466
    handler_bci = Method::fast_exception_handler_bci_for(h_method, klass, current_bci, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
      // We threw an exception while trying to find the exception handler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
      // Transfer the new exception to the exception handle which will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
      // be set into thread local storage, and do another lookup for an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
      // exception handler for this exception, this time starting at the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
      // BCI of the exception handler which caused the exception to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
      // thrown (bug 4307310).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
      h_exception = Handle(THREAD, PENDING_EXCEPTION);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
      if (handler_bci >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
        current_bci = handler_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
        should_repeat = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  } while (should_repeat == true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   483
#if INCLUDE_JVMCI
33632
038347770a9e 8139170: JVMCI refresh
twisti
parents: 33230
diff changeset
   484
  if (EnableJVMCI && h_method->method_data() != NULL) {
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   485
    ResourceMark rm(thread);
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   486
    ProfileData* pdata = h_method->method_data()->allocate_bci_to_data(current_bci, NULL);
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   487
    if (pdata != NULL && pdata->is_BitData()) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   488
      BitData* bit_data = (BitData*) pdata;
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   489
      bit_data->set_exception_seen();
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   490
    }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   491
  }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   492
#endif
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32178
diff changeset
   493
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  // notify JVMTI of an exception throw; JVMTI will detect if this is a first
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  // time throw or a stack unwinding throw and accordingly notify the debugger
4761
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4571
diff changeset
   496
  if (JvmtiExport::can_post_on_exceptions()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
    JvmtiExport::post_exception_throw(thread, h_method(), bcp(thread), h_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  address continuation = (address)(intptr_t) handler_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  address continuation = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  address handler_pc = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  if (handler_bci < 0 || !thread->reguard_stack((address) &continuation)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
    // Forward exception to callee (leaving bci/bcp untouched) because (a) no
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
    // handler in this method, or (b) after a stack overflow there is not yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
    // enough stack space available to reprotect the stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
#ifndef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
    continuation = Interpreter::remove_activation_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
#endif
37272
c427db4ea8c4 8148639: Some MethodCounter fields can be excluded when not including C2
cjplummer
parents: 36508
diff changeset
   513
#if COMPILER2_OR_JVMCI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
    // Count this for compilation purposes
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
   515
    h_method->interpreter_throwout_increment(THREAD);
37272
c427db4ea8c4 8148639: Some MethodCounter fields can be excluded when not including C2
cjplummer
parents: 36508
diff changeset
   516
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
    // handler in this method => change bci/bcp to handler bci/bcp and continue there
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
    handler_pc = h_method->code_base() + handler_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
#ifndef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
    set_bcp_and_mdp(handler_pc, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
    continuation = Interpreter::dispatch_table(vtos)[*handler_pc];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  // notify debugger of an exception catch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  // (this is good for exceptions caught in native methods as well)
4761
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4571
diff changeset
   527
  if (JvmtiExport::can_post_on_exceptions()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
    JvmtiExport::notice_unwind_due_to_exception(thread, h_method(), handler_pc, h_exception(), (handler_pc != NULL));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  thread->set_vm_result(h_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  return continuation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
IRT_ENTRY(void, InterpreterRuntime::throw_pending_exception(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  assert(thread->has_pending_exception(), "must only ne called if there's an exception pending");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  // nothing to do - eventually we should remove this code entirely (see comments @ call sites)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
IRT_ENTRY(void, InterpreterRuntime::throw_AbstractMethodError(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  THROW(vmSymbols::java_lang_AbstractMethodError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
IRT_ENTRY(void, InterpreterRuntime::throw_IncompatibleClassChangeError(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  THROW(vmSymbols::java_lang_IncompatibleClassChangeError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
// Fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   556
void InterpreterRuntime::resolve_get_put(JavaThread* thread, Bytecodes::Code bytecode) {
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   557
  Thread* THREAD = thread;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  // resolve field
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   559
  fieldDescriptor info;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  constantPoolHandle pool(thread, method(thread)->constants());
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 37480
diff changeset
   561
  methodHandle m(thread, method(thread));
30117
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 29081
diff changeset
   562
  bool is_put    = (bytecode == Bytecodes::_putfield  || bytecode == Bytecodes::_nofast_putfield ||
cce2cdac56dc 8074345: Enable RewriteBytecodes when VM runs with CDS
minqi
parents: 29081
diff changeset
   563
                    bytecode == Bytecodes::_putstatic);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  bool is_static = (bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
    JvmtiHideSingleStepping jhss(thread);
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   568
    LinkResolver::resolve_field_access(info, pool, get_index_u2_cpcache(thread, bytecode),
39421
a9652c919db8 8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents: 37480
diff changeset
   569
                                       m, bytecode, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  } // end JvmtiHideSingleStepping
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  // check if link resolution caused cpCache to be updated
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   573
  ConstantPoolCacheEntry* cp_cache_entry = cache_entry(thread);
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   574
  if (cp_cache_entry->is_resolved(bytecode)) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  // compute auxiliary field attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  TosState state  = as_TosState(info.field_type());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
41050
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   579
  // Resolution of put instructions on final fields is delayed. That is required so that
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   580
  // exceptions are thrown at the correct place (when the instruction is actually invoked).
39699
7a2a49fd5ee0 8160527: Check for final instance field updates can be omitted
zmajo
parents: 39421
diff changeset
   581
  // If we do not resolve an instruction in the current pass, leaving the put_code
7a2a49fd5ee0 8160527: Check for final instance field updates can be omitted
zmajo
parents: 39421
diff changeset
   582
  // set to zero will cause the next put instruction to the same field to reresolve.
41050
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   583
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   584
  // Resolution of put instructions to final instance fields with invalid updates (i.e.,
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   585
  // to final instance fields with updates originating from a method different than <init>)
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   586
  // is inhibited. A putfield instruction targeting an instance final field must throw
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   587
  // an IllegalAccessError if the instruction is not in an instance
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   588
  // initializer method <init>. If resolution were not inhibited, a putfield
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   589
  // in an initializer method could be resolved in the initializer. Subsequent
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   590
  // putfield instructions to the same field would then use cached information.
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   591
  // As a result, those instructions would not pass through the VM. That is,
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   592
  // checks in resolve_field_access() would not be executed for those instructions
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   593
  // and the required IllegalAccessError would not be thrown.
39699
7a2a49fd5ee0 8160527: Check for final instance field updates can be omitted
zmajo
parents: 39421
diff changeset
   594
  //
7a2a49fd5ee0 8160527: Check for final instance field updates can be omitted
zmajo
parents: 39421
diff changeset
   595
  // Also, we need to delay resolving getstatic and putstatic instructions until the
7a2a49fd5ee0 8160527: Check for final instance field updates can be omitted
zmajo
parents: 39421
diff changeset
   596
  // class is initialized.  This is required so that access to the static
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  // field will call the initialization function every time until the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  // is completely initialized ala. in 2.17.5 in JVM Specification.
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   599
  InstanceKlass* klass = InstanceKlass::cast(info.field_holder());
41050
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   600
  bool uninitialized_static = is_static && !klass->is_initialized();
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   601
  bool has_initialized_final_update = info.field_holder()->major_version() >= 53 &&
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   602
                                      info.has_initialized_final_update();
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   603
  assert(!(has_initialized_final_update && !info.access_flags().is_final()), "Fields with initialized final updates must be final");
39699
7a2a49fd5ee0 8160527: Check for final instance field updates can be omitted
zmajo
parents: 39421
diff changeset
   604
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  Bytecodes::Code get_code = (Bytecodes::Code)0;
41050
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   606
  Bytecodes::Code put_code = (Bytecodes::Code)0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
  if (!uninitialized_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
    get_code = ((is_static) ? Bytecodes::_getstatic : Bytecodes::_getfield);
41050
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   609
    if ((is_put && !has_initialized_final_update) || !info.access_flags().is_final()) {
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   610
      put_code = ((is_static) ? Bytecodes::_putstatic : Bytecodes::_putfield);
1a952c00b8e4 8163880: Constant pool caching of fields inhibited/delayed unnecessarily
zmajo
parents: 40655
diff changeset
   611
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   614
  cp_cache_entry->set_field(
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
    get_code,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
    put_code,
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   617
    info.field_holder(),
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   618
    info.index(),
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   619
    info.offset(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
    state,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
    info.access_flags().is_final(),
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   622
    info.access_flags().is_volatile(),
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   623
    pool->pool_holder()
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  );
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   625
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
// Synchronization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
// The interpreter's synchronization code is factored out so that it can
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
// be shared by method invocation and synchronized blocks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
//%note synchronization_3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
//%note monitor_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  thread->last_frame().interpreter_frame_verify_monitor(elem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  if (PrintBiasedLockingStatistics) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
  Handle h_obj(thread, elem->obj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
         "must be NULL or an object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  if (UseBiasedLocking) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
    // Retry fast entry if bias is revoked to avoid unnecessary inflation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
    ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  assert(Universe::heap()->is_in_reserved_or_null(elem->obj()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
         "must be NULL or an object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  thread->last_frame().interpreter_frame_verify_monitor(elem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
//%note monitor_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorexit(JavaThread* thread, BasicObjectLock* elem))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
  thread->last_frame().interpreter_frame_verify_monitor(elem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  Handle h_obj(thread, elem->obj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
         "must be NULL or an object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  if (elem == NULL || h_obj()->is_unlocked()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
    THROW(vmSymbols::java_lang_IllegalMonitorStateException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  ObjectSynchronizer::slow_exit(h_obj(), elem->lock(), thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  // Free entry. This must be done here, since a pending exception might be installed on
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  // exit. If it is not cleared, the exception handling code will try to unlock the monitor again.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
  elem->set_obj(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  thread->last_frame().interpreter_frame_verify_monitor(elem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
IRT_ENTRY(void, InterpreterRuntime::throw_illegal_monitor_state_exception(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
  THROW(vmSymbols::java_lang_IllegalMonitorStateException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
IRT_ENTRY(void, InterpreterRuntime::new_illegal_monitor_state_exception(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  // Returns an illegal exception to install into the current thread. The
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  // pending_exception flag is cleared so normal exception handling does not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  // trigger. Any current installed exception will be overwritten. This
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  // method will be called during an exception unwind.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  assert(!HAS_PENDING_EXCEPTION, "no pending exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  Handle exception(thread, thread->vm_result());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  assert(exception() != NULL, "vm result should be set");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  thread->set_vm_result(NULL); // clear vm result before continuing (may cause memory leaks and assert failures)
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
   696
  if (!exception->is_a(SystemDictionary::ThreadDeath_klass())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
    exception = get_preinitialized_exception(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
                       SystemDictionary::IllegalMonitorStateException_klass(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
                       CATCH);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  thread->set_vm_result(exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
// Invokes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   708
IRT_ENTRY(Bytecodes::Code, InterpreterRuntime::get_original_bytecode_at(JavaThread* thread, Method* method, address bcp))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  return method->orig_bytecode_at(method->bci_from(bcp));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   712
IRT_ENTRY(void, InterpreterRuntime::set_original_bytecode_at(JavaThread* thread, Method* method, address bcp, Bytecodes::Code new_code))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  method->set_orig_bytecode_at(method->bci_from(bcp), new_code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   716
IRT_ENTRY(void, InterpreterRuntime::_breakpoint(JavaThread* thread, Method* method, address bcp))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  JvmtiExport::post_raw_breakpoint(thread, method, bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   720
void InterpreterRuntime::resolve_invoke(JavaThread* thread, Bytecodes::Code bytecode) {
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   721
  Thread* THREAD = thread;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  // extract receiver from the outgoing argument list if necessary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  Handle receiver(thread, NULL);
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   724
  if (bytecode == Bytecodes::_invokevirtual || bytecode == Bytecodes::_invokeinterface ||
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   725
      bytecode == Bytecodes::_invokespecial) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
    ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
    methodHandle m (thread, method(thread));
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7411
diff changeset
   728
    Bytecode_invoke call(m, bci(thread));
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7915
diff changeset
   729
    Symbol* signature = call.signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
    receiver = Handle(thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
                  thread->last_frame().interpreter_callee_receiver(signature));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
    assert(Universe::heap()->is_in_reserved_or_null(receiver()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
           "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
    assert(receiver.is_null() ||
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   735
           !Universe::heap()->is_in_reserved(receiver->klass()),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
           "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  // resolve method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  CallInfo info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  constantPoolHandle pool(thread, method(thread)->constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
    JvmtiHideSingleStepping jhss(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
    LinkResolver::resolve_invoke(info, receiver, pool,
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   746
                                 get_index_u2_cpcache(thread, bytecode), bytecode,
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   747
                                 CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
    if (JvmtiExport::can_hotswap_or_post_breakpoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
      int retry_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
      while (info.resolved_method()->is_old()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
        // It is very unlikely that method is redefined more than 100 times
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
        // in the middle of resolve. If it is looping here more than 100 times
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
        // means then there could be a bug here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
        guarantee((retry_count++ < 100),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
                  "Could not resolve to latest version of redefined method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
        // method is redefined in the middle of resolve so re-try.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
        LinkResolver::resolve_invoke(info, receiver, pool,
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   758
                                     get_index_u2_cpcache(thread, bytecode), bytecode,
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   759
                                     CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
  } // end JvmtiHideSingleStepping
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
  // check if link resolution caused cpCache to be updated
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   765
  ConstantPoolCacheEntry* cp_cache_entry = cache_entry(thread);
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   766
  if (cp_cache_entry->is_resolved(bytecode)) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   768
#ifdef ASSERT
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   769
  if (bytecode == Bytecodes::_invokeinterface) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
    if (info.resolved_method()->method_holder() ==
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
   771
                                            SystemDictionary::Object_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
      // NOTE: THIS IS A FIX FOR A CORNER CASE in the JVM spec
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   773
      // (see also CallInfo::set_interface for details)
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   774
      assert(info.call_kind() == CallInfo::vtable_call ||
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   775
             info.call_kind() == CallInfo::direct_call, "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
      methodHandle rm = info.resolved_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
      assert(rm->is_final() || info.has_vtable_index(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
             "should have been set already");
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   779
    } else if (!info.resolved_method()->has_itable_index()) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   780
      // Resolved something like CharSequence.toString.  Use vtable not itable.
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   781
      assert(info.call_kind() != CallInfo::itable_call, "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
      // Setup itable entry
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   784
      assert(info.call_kind() == CallInfo::itable_call, "");
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   785
      int index = info.resolved_method()->itable_index();
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   786
      assert(info.itable_index() == index, "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
    }
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   788
  } else if (bytecode == Bytecodes::_invokespecial) {
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   789
    assert(info.call_kind() == CallInfo::direct_call, "must be direct call");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  } else {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   791
    assert(info.call_kind() == CallInfo::direct_call ||
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   792
           info.call_kind() == CallInfo::vtable_call, "");
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   793
  }
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   794
#endif
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   795
  // Get sender or sender's host_klass, and only set cpCache entry to resolved if
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   796
  // it is not an interface.  The receiver for invokespecial calls within interface
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   797
  // methods must be checked for every call.
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   798
  InstanceKlass* sender = pool->pool_holder();
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   799
  sender = sender->is_anonymous() ? sender->host_klass() : sender;
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   800
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   801
  switch (info.call_kind()) {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   802
  case CallInfo::direct_call:
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   803
    cp_cache_entry->set_direct_call(
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   804
      bytecode,
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   805
      info.resolved_method(),
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 42664
diff changeset
   806
      sender->is_interface());
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   807
    break;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   808
  case CallInfo::vtable_call:
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   809
    cp_cache_entry->set_vtable_call(
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
      bytecode,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
      info.resolved_method(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
      info.vtable_index());
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   813
    break;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   814
  case CallInfo::itable_call:
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   815
    cp_cache_entry->set_itable_call(
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   816
      bytecode,
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   817
      info.resolved_method(),
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   818
      info.itable_index());
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   819
    break;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 19266
diff changeset
   820
  default:  ShouldNotReachHere();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   822
}
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   823
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   824
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   825
// First time execution:  Resolve symbols, create a permanent MethodType object.
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   826
void InterpreterRuntime::resolve_invokehandle(JavaThread* thread) {
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   827
  Thread* THREAD = thread;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   828
  const Bytecodes::Code bytecode = Bytecodes::_invokehandle;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   829
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   830
  // resolve method
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   831
  CallInfo info;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   832
  constantPoolHandle pool(thread, method(thread)->constants());
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   833
  {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   834
    JvmtiHideSingleStepping jhss(thread);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   835
    LinkResolver::resolve_invoke(info, Handle(), pool,
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   836
                                 get_index_u2_cpcache(thread, bytecode), bytecode,
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   837
                                 CHECK);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   838
  } // end JvmtiHideSingleStepping
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   839
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   840
  ConstantPoolCacheEntry* cp_cache_entry = cache_entry(thread);
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   841
  cp_cache_entry->set_method_handle(pool, info);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   842
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
4429
d7eb4e2099aa 6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents: 3696
diff changeset
   844
// First time execution:  Resolve symbols, create a permanent CallSite object.
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   845
void InterpreterRuntime::resolve_invokedynamic(JavaThread* thread) {
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   846
  Thread* THREAD = thread;
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   847
  const Bytecodes::Code bytecode = Bytecodes::_invokedynamic;
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   848
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   849
  //TO DO: consider passing BCI to Java.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   850
  //  int caller_bci = method(thread)->bci_from(bcp(thread));
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   851
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   852
  // resolve method
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   853
  CallInfo info;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   854
  constantPoolHandle pool(thread, method(thread)->constants());
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   855
  int index = get_index_u4(thread, bytecode);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   856
  {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   857
    JvmtiHideSingleStepping jhss(thread);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   858
    LinkResolver::resolve_invoke(info, Handle(), pool,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   859
                                 index, bytecode, CHECK);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13296
diff changeset
   860
  } // end JvmtiHideSingleStepping
6062
bab93afe9df7 6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents: 5883
diff changeset
   861
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   862
  ConstantPoolCacheEntry* cp_cache_entry = pool->invokedynamic_cp_cache_entry_at(index);
14393
93a4dcdbebfd 8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents: 13961
diff changeset
   863
  cp_cache_entry->set_dynamic_call(pool, info);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   864
}
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   865
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   866
// This function is the interface to the assembly code. It returns the resolved
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   867
// cpCache entry.  This doesn't safepoint, but the helper routines safepoint.
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   868
// This function will check for redefinition!
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   869
IRT_ENTRY(void, InterpreterRuntime::resolve_from_cache(JavaThread* thread, Bytecodes::Code bytecode)) {
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   870
  switch (bytecode) {
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   871
  case Bytecodes::_getstatic:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   872
  case Bytecodes::_putstatic:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   873
  case Bytecodes::_getfield:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   874
  case Bytecodes::_putfield:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   875
    resolve_get_put(thread, bytecode);
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   876
    break;
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   877
  case Bytecodes::_invokevirtual:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   878
  case Bytecodes::_invokespecial:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   879
  case Bytecodes::_invokestatic:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   880
  case Bytecodes::_invokeinterface:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   881
    resolve_invoke(thread, bytecode);
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   882
    break;
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   883
  case Bytecodes::_invokehandle:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   884
    resolve_invokehandle(thread);
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   885
    break;
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   886
  case Bytecodes::_invokedynamic:
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   887
    resolve_invokedynamic(thread);
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   888
    break;
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   889
  default:
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32178
diff changeset
   890
    fatal("unexpected bytecode: %s", Bytecodes::name(bytecode));
30132
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   891
    break;
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   892
  }
1f788eb36811 8076492: Make common code from template interpreter code
coleenp
parents: 30117
diff changeset
   893
}
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   894
IRT_END
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   895
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
// Miscellaneous
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   900
nmethod* InterpreterRuntime::frequency_counter_overflow(JavaThread* thread, address branch_bcp) {
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   901
  nmethod* nm = frequency_counter_overflow_inner(thread, branch_bcp);
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   902
  assert(branch_bcp != NULL || nm == NULL, "always returns null for non OSR requests");
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   903
  if (branch_bcp != NULL && nm != NULL) {
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   904
    // This was a successful request for an OSR nmethod.  Because
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   905
    // frequency_counter_overflow_inner ends with a safepoint check,
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   906
    // nm could have been unloaded so look it up again.  It's unsafe
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   907
    // to examine nm directly since it might have been freed and used
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   908
    // for something else.
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   909
    frame fr = thread->last_frame();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   910
    Method* method =  fr.interpreter_frame_method();
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   911
    int bci = method->bci_from(fr.interpreter_frame_bcp());
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   912
    nm = method->lookup_osr_nmethod_for(bci, CompLevel_none, false);
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   913
  }
12959
4d33f9be7e87 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents: 11572
diff changeset
   914
#ifndef PRODUCT
4d33f9be7e87 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents: 11572
diff changeset
   915
  if (TraceOnStackReplacement) {
4d33f9be7e87 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents: 11572
diff changeset
   916
    if (nm != NULL) {
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33105
diff changeset
   917
      tty->print("OSR entry @ pc: " INTPTR_FORMAT ": ", p2i(nm->osr_entry()));
12959
4d33f9be7e87 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents: 11572
diff changeset
   918
      nm->print();
4d33f9be7e87 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents: 11572
diff changeset
   919
    }
4d33f9be7e87 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents: 11572
diff changeset
   920
  }
4d33f9be7e87 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents: 11572
diff changeset
   921
#endif
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   922
  return nm;
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   923
}
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   924
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
IRT_ENTRY(nmethod*,
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 2570
diff changeset
   926
          InterpreterRuntime::frequency_counter_overflow_inner(JavaThread* thread, address branch_bcp))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  // use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
  // flag, in case this method triggers classloading which will call into Java.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
  UnlockFlagSaver fs(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  frame fr = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  assert(fr.is_interpreted_frame(), "must come from interpreter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  methodHandle method(thread, fr.interpreter_frame_method());
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   934
  const int branch_bci = branch_bcp != NULL ? method->bci_from(branch_bcp) : InvocationEntryBci;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   935
  const int bci = branch_bcp != NULL ? method->bci_from(fr.interpreter_frame_bcp()) : InvocationEntryBci;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   936
11572
84afef481892 7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents: 10967
diff changeset
   937
  assert(!HAS_PENDING_EXCEPTION, "Should not have any exceptions pending");
10014
a5c2141ee857 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 10004
diff changeset
   938
  nmethod* osr_nm = CompilationPolicy::policy()->event(method, method, branch_bci, bci, CompLevel_none, NULL, thread);
11572
84afef481892 7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents: 10967
diff changeset
   939
  assert(!HAS_PENDING_EXCEPTION, "Event handler should not throw any exceptions");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   941
  if (osr_nm != NULL) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   942
    // We may need to do on-stack replacement which requires that no
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   943
    // monitors in the activation are biased because their
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   944
    // BasicObjectLocks will need to migrate during OSR. Force
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   945
    // unbiasing of all monitors in the activation now (even though
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   946
    // the OSR nmethod might be invalidated) because we don't have a
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   947
    // safepoint opportunity later once the migration begins.
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   948
    if (UseBiasedLocking) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   949
      ResourceMark rm;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   950
      GrowableArray<Handle>* objects_to_revoke = new GrowableArray<Handle>();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   951
      for( BasicObjectLock *kptr = fr.interpreter_frame_monitor_end();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   952
           kptr < fr.interpreter_frame_monitor_begin();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   953
           kptr = fr.next_monitor_in_interpreter_frame(kptr) ) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   954
        if( kptr->obj() != NULL ) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   955
          objects_to_revoke->append(Handle(THREAD, kptr->obj()));
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   956
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
      }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   958
      BiasedLocking::revoke(objects_to_revoke);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   961
  return osr_nm;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   964
IRT_LEAF(jint, InterpreterRuntime::bcp_to_di(Method* method, address cur_bcp))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  assert(ProfileInterpreter, "must be profiling interpreter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  int bci = method->bci_from(cur_bcp);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   967
  MethodData* mdo = method->method_data();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
  if (mdo == NULL)  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
  return mdo->bci_to_di(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
7889
02144432d0e1 4930919: race condition in MDO creation at back branch locations
iveresov
parents: 7411
diff changeset
   972
IRT_ENTRY(void, InterpreterRuntime::profile_method(JavaThread* thread))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
  // use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  // flag, in case this method triggers classloading which will call into Java.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
  UnlockFlagSaver fs(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  assert(ProfileInterpreter, "must be profiling interpreter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  frame fr = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
  assert(fr.is_interpreted_frame(), "must come from interpreter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  methodHandle method(thread, fr.interpreter_frame_method());
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   981
  Method::build_interpreter_method_data(method, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
    assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), "we expect only an OOM error here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
    // and fall through...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
#ifdef ASSERT
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   991
IRT_LEAF(void, InterpreterRuntime::verify_mdp(Method* method, address bcp, address mdp))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  assert(ProfileInterpreter, "must be profiling interpreter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   994
  MethodData* mdo = method->method_data();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  assert(mdo != NULL, "must not be null");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  int bci = method->bci_from(bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  address mdp2 = mdo->bci_to_dp(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  if (mdp != mdp2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
    ResetNoHandleMark rnm; // In a LEAF entry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
    HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
    tty->print_cr("FAILED verify : actual mdp %p   expected mdp %p @ bci %d", mdp, mdp2, bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
    int current_di = mdo->dp_to_di(mdp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
    int expected_di  = mdo->dp_to_di(mdp2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
    tty->print_cr("  actual di %d   expected di %d", current_di, expected_di);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
    int expected_approx_bci = mdo->data_at(expected_di)->bci();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
    int approx_bci = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
    if (current_di >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
      approx_bci = mdo->data_at(current_di)->bci();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
    tty->print_cr("  actual bci is %d  expected bci %d", approx_bci, expected_approx_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
    mdo->print_on(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
    method->print_codes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  assert(mdp == mdp2, "wrong mdp");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
IRT_ENTRY(void, InterpreterRuntime::update_mdp_for_ret(JavaThread* thread, int return_bci))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  assert(ProfileInterpreter, "must be profiling interpreter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  HandleMark hm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  frame fr = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  assert(fr.is_interpreted_frame(), "must come from interpreter");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1027
  MethodData* h_mdo = fr.interpreter_frame_method()->method_data();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  // Grab a lock to ensure atomic access to setting the return bci and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
  // the displacement.  This can block and GC, invalidating all naked oops.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  MutexLocker ml(RetData_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  // ProfileData is essentially a wrapper around a derived oop, so we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  // need to take the lock before making any ProfileData structures.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  ProfileData* data = h_mdo->data_at(h_mdo->dp_to_di(fr.interpreter_frame_mdp()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
  RetData* rdata = data->as_RetData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
  address new_mdp = rdata->fixup_ret(return_bci, h_mdo);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
  fr.interpreter_frame_set_mdp(new_mdp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
  1041
IRT_ENTRY(MethodCounters*, InterpreterRuntime::build_method_counters(JavaThread* thread, Method* m))
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
  1042
  MethodCounters* mcs = Method::build_method_counters(m, thread);
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
  1043
  if (HAS_PENDING_EXCEPTION) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
  1044
    assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), "we expect only an OOM error here");
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
  1045
    CLEAR_PENDING_EXCEPTION;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
  1046
  }
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
  1047
  return mcs;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
  1048
IRT_END
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 15109
diff changeset
  1049
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
IRT_ENTRY(void, InterpreterRuntime::at_safepoint(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
  // We used to need an explict preserve_arguments here for invoke bytecodes. However,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  // stack traversal automatically takes care of preserving arguments for invoke, so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  // this is no longer needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  // IRT_END does an implicit safepoint check, hence we are guaranteed to block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  // if this is called during a safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  if (JvmtiExport::should_post_single_step()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
    // We are called during regular safepoints and when the VM is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
    // single stepping. If any thread is marked for single stepping,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
    // then we may have JVMTI work to do.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
    JvmtiExport::at_single_stepping_point(thread, method(thread), bcp(thread));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
IRT_ENTRY(void, InterpreterRuntime::post_field_access(JavaThread *thread, oopDesc* obj,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
ConstantPoolCacheEntry *cp_entry))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  // check the access_flags for the field in the klass
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8676
diff changeset
  1071
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1072
  InstanceKlass* ik = InstanceKlass::cast(cp_entry->f1_as_klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  int index = cp_entry->field_index();
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10521
diff changeset
  1074
  if ((ik->field_access_flags(index) & JVM_ACC_FIELD_ACCESS_WATCHED) == 0) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
  bool is_static = (obj == NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
  HandleMark hm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  Handle h_obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
    // non-static field accessors have an object, but we need a handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
    h_obj = Handle(thread, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42664
diff changeset
  1084
  InstanceKlass* cp_entry_f1 = InstanceKlass::cast(cp_entry->f1_as_klass());
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42664
diff changeset
  1085
  jfieldID fid = jfieldIDWorkaround::to_jfieldID(cp_entry_f1, cp_entry->f2_as_index(), is_static);
46430
45fd2f759802 8179625: [BACKOUT] of 8179305 Avoid repeated calls to JavaThread::last_frame in InterpreterRuntime
iklam
parents: 46424
diff changeset
  1086
  JvmtiExport::post_field_access(thread, method(thread), bcp(thread), cp_entry_f1, h_obj, fid);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
IRT_ENTRY(void, InterpreterRuntime::post_field_modification(JavaThread *thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  oopDesc* obj, ConstantPoolCacheEntry *cp_entry, jvalue *value))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42664
diff changeset
  1092
  Klass* k = cp_entry->f1_as_klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
  // check the access_flags for the field in the klass
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1095
  InstanceKlass* ik = InstanceKlass::cast(k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  int index = cp_entry->field_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
  // bail out if field modifications are not watched
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 10521
diff changeset
  1098
  if ((ik->field_access_flags(index) & JVM_ACC_FIELD_MODIFICATION_WATCHED) == 0) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
  char sig_type = '\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
  switch(cp_entry->flag_state()) {
37480
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 37449
diff changeset
  1103
    case btos: sig_type = 'B'; break;
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 37449
diff changeset
  1104
    case ztos: sig_type = 'Z'; break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
    case ctos: sig_type = 'C'; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
    case stos: sig_type = 'S'; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
    case itos: sig_type = 'I'; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
    case ftos: sig_type = 'F'; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
    case atos: sig_type = 'L'; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
    case ltos: sig_type = 'J'; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
    case dtos: sig_type = 'D'; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
    default:  ShouldNotReachHere(); return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  bool is_static = (obj == NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  HandleMark hm(thread);
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42664
diff changeset
  1117
  jfieldID fid = jfieldIDWorkaround::to_jfieldID(ik, cp_entry->f2_as_index(), is_static);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
  jvalue fvalue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
  fvalue = *value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  // Long/double values are stored unaligned and also noncontiguously with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
  // tagged stacks.  We can't just do a simple assignment even in the non-
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
  // J/D cases because a C++ compiler is allowed to assume that a jvalue is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
  // 8-byte aligned, and interpreter stack slots are only 4-byte aligned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
  // We assume that the two halves of longs/doubles are stored in interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
  // stack slots in platform-endian order.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
  jlong_accessor u;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
  jint* newval = (jint*)value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
  u.words[0] = newval[0];
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 4761
diff changeset
  1131
  u.words[1] = newval[Interpreter::stackElementWords]; // skip if tag
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  fvalue.j = u.long_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
#endif // _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  Handle h_obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
    // non-static field accessors have an object, but we need a handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
    h_obj = Handle(thread, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
46430
45fd2f759802 8179625: [BACKOUT] of 8179305 Avoid repeated calls to JavaThread::last_frame in InterpreterRuntime
iklam
parents: 46424
diff changeset
  1141
  JvmtiExport::post_raw_field_modification(thread, method(thread), bcp(thread), ik, h_obj,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
                                           fid, sig_type, &fvalue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
IRT_ENTRY(void, InterpreterRuntime::post_method_entry(JavaThread *thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
  JvmtiExport::post_method_entry(thread, InterpreterRuntime::method(thread), InterpreterRuntime::last_frame(thread));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
IRT_ENTRY(void, InterpreterRuntime::post_method_exit(JavaThread *thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
  JvmtiExport::post_method_exit(thread, InterpreterRuntime::method(thread), InterpreterRuntime::last_frame(thread));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
IRT_LEAF(int, InterpreterRuntime::interpreter_contains(address pc))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  return (Interpreter::contains(pc) ? 1 : 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
// Implementation of SignatureHandlerLibrary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
31382
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1163
#ifndef SHARING_FAST_NATIVE_FINGERPRINTS
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1164
// Dummy definition (else normalization method is defined in CPU
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1165
// dependant code)
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1166
uint64_t InterpreterRuntime::normalize_fast_native_fingerprint(uint64_t fingerprint) {
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1167
  return fingerprint;
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1168
}
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1169
#endif
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1170
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
address SignatureHandlerLibrary::set_handler_blob() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
  BufferBlob* handler_blob = BufferBlob::create("native signature handlers", blob_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  if (handler_blob == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  }
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6062
diff changeset
  1176
  address handler = handler_blob->code_begin();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  _handler_blob = handler_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
  _handler = handler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
  return handler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
void SignatureHandlerLibrary::initialize() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  if (_fingerprints != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
  if (set_handler_blob() == NULL) {
17087
f0b76c4c93a0 8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents: 17002
diff changeset
  1187
    vm_exit_out_of_memory(blob_size, OOM_MALLOC_ERROR, "native signature handlers");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  BufferBlob* bb = BufferBlob::create("Signature Handler Temp Buffer",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
                                      SignatureHandlerLibrary::buffer_size);
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6062
diff changeset
  1192
  _buffer = bb->code_begin();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12959
diff changeset
  1194
  _fingerprints = new(ResourceObj::C_HEAP, mtCode)GrowableArray<uint64_t>(32, true);
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12959
diff changeset
  1195
  _handlers     = new(ResourceObj::C_HEAP, mtCode)GrowableArray<address>(32, true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
address SignatureHandlerLibrary::set_handler(CodeBuffer* buffer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
  address handler   = _handler;
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6062
diff changeset
  1200
  int     insts_size = buffer->pure_insts_size();
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6062
diff changeset
  1201
  if (handler + insts_size > _handler_blob->code_end()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
    // get a new handler blob
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
    handler = set_handler_blob();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
  if (handler != NULL) {
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6062
diff changeset
  1206
    memcpy(handler, buffer->insts_begin(), insts_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
    pd_set_handler(handler);
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6062
diff changeset
  1208
    ICache::invalidate_range(handler, insts_size);
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6062
diff changeset
  1209
    _handler = handler + insts_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
  return handler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33230
diff changeset
  1214
void SignatureHandlerLibrary::add(const methodHandle& method) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
  if (method->signature_handler() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
    // use slow signature handler if we can't do better
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
    int handler_index = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
    // check if we can use customized (fast) signature handler
42664
29142a56c193 8168503: JEP 297: Unified arm32/arm64 Port
bobv
parents: 41050
diff changeset
  1219
    if (UseFastSignatureHandlers && method->size_of_parameters() <= Fingerprinter::max_size_of_parameters) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
      // use customized signature handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
      MutexLocker mu(SignatureHandlerLibrary_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
      // make sure data structure is initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
      initialize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
      // lookup method signature's fingerprint
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
      uint64_t fingerprint = Fingerprinter(method).fingerprint();
31382
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1226
      // allow CPU dependant code to optimize the fingerprints for the fast handler
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1227
      fingerprint = InterpreterRuntime::normalize_fast_native_fingerprint(fingerprint);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
      handler_index = _fingerprints->find(fingerprint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
      // create handler if necessary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
      if (handler_index < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
        ResourceMark rm;
46620
750c6edff33b 8178500: Replace usages of round_to and round_down with align_up and align_down
stefank
parents: 46458
diff changeset
  1232
        ptrdiff_t align_offset = align_up(_buffer, CodeEntryAlignment) - (address)_buffer;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
        CodeBuffer buffer((address)(_buffer + align_offset),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
                          SignatureHandlerLibrary::buffer_size - align_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
        InterpreterRuntime::SignatureHandlerGenerator(method, &buffer).generate(fingerprint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
        // copy into code heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
        address handler = set_handler(&buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
        if (handler == NULL) {
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1239
          // use slow signature handler (without memorizing it in the fingerprints)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
          // debugging suppport
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1242
          if (PrintSignatureHandlers && (handler != Interpreter::slow_signature_handler())) {
35542
9dccb7f9f656 8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents: 35071
diff changeset
  1243
            ttyLocker ttyl;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
            tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
            tty->print_cr("argument handler #%d for: %s %s (fingerprint = " UINT64_FORMAT ", %d bytes generated)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
                          _handlers->length(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
                          (method->is_static() ? "static" : "receiver"),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
                          method->name_and_sig_as_C_string(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
                          fingerprint,
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6062
diff changeset
  1250
                          buffer.insts_size());
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1251
            if (buffer.insts_size() > 0) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1252
              Disassembler::decode(handler, handler + buffer.insts_size());
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1253
            }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
            address rh_begin = Interpreter::result_handler(method()->result_type());
31382
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1256
            if (CodeCache::contains(rh_begin)) {
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1257
              // else it might be special platform dependent values
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1258
              tty->print_cr(" --- associated result handler ---");
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1259
              address rh_end = rh_begin;
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1260
              while (*(int*)rh_end != 0) {
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1261
                rh_end += sizeof(int);
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1262
              }
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1263
              Disassembler::decode(rh_begin, rh_end);
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1264
            } else {
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1265
              tty->print_cr(" associated result handler: " PTR_FORMAT, p2i(rh_begin));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
          // add handler to library
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
          _fingerprints->append(fingerprint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
          _handlers->append(handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
          // set handler index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
          assert(_fingerprints->length() == _handlers->length(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
          handler_index = _fingerprints->length() - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
      }
8109
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1277
      // Set handler under SignatureHandlerLibrary_lock
31382
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1278
      if (handler_index < 0) {
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1279
        // use generic signature handler
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1280
        method->set_signature_handler(Interpreter::slow_signature_handler());
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1281
      } else {
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1282
        // set handler
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1283
        method->set_signature_handler(_handlers->at(handler_index));
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1284
      }
8109
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1285
    } else {
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1286
      CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1287
      // use generic signature handler
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1288
      method->set_signature_handler(Interpreter::slow_signature_handler());
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1289
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
  }
7411
afcfb75ccae1 6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents: 7397
diff changeset
  1291
#ifdef ASSERT
8109
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1292
  int handler_index = -1;
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1293
  int fingerprint_index = -2;
7411
afcfb75ccae1 6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents: 7397
diff changeset
  1294
  {
afcfb75ccae1 6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents: 7397
diff changeset
  1295
    // '_handlers' and '_fingerprints' are 'GrowableArray's and are NOT synchronized
afcfb75ccae1 6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents: 7397
diff changeset
  1296
    // in any way if accessed from multiple threads. To avoid races with another
afcfb75ccae1 6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents: 7397
diff changeset
  1297
    // thread which may change the arrays in the above, mutex protected block, we
afcfb75ccae1 6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents: 7397
diff changeset
  1298
    // have to protect this read access here with the same mutex as well!
afcfb75ccae1 6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents: 7397
diff changeset
  1299
    MutexLocker mu(SignatureHandlerLibrary_lock);
8109
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1300
    if (_handlers != NULL) {
31382
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1301
      handler_index = _handlers->find(method->signature_handler());
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1302
      uint64_t fingerprint = Fingerprinter(method).fingerprint();
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1303
      fingerprint = InterpreterRuntime::normalize_fast_native_fingerprint(fingerprint);
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1304
      fingerprint_index = _fingerprints->find(fingerprint);
8d526a6991e1 8087133: Improve sharing of native wrappers in SignatureHandlerLibrary
bdelsart
parents: 31335
diff changeset
  1305
    }
8109
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1306
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
  assert(method->signature_handler() == Interpreter::slow_signature_handler() ||
7411
afcfb75ccae1 6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents: 7397
diff changeset
  1308
         handler_index == fingerprint_index, "sanity check");
8109
26c288ddbec3 7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents: 8107
diff changeset
  1309
#endif // ASSERT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1312
void SignatureHandlerLibrary::add(uint64_t fingerprint, address handler) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1313
  int handler_index = -1;
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1314
  // use customized signature handler
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1315
  MutexLocker mu(SignatureHandlerLibrary_lock);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1316
  // make sure data structure is initialized
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1317
  initialize();
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1318
  fingerprint = InterpreterRuntime::normalize_fast_native_fingerprint(fingerprint);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1319
  handler_index = _fingerprints->find(fingerprint);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1320
  // create handler if necessary
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1321
  if (handler_index < 0) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1322
    if (PrintSignatureHandlers && (handler != Interpreter::slow_signature_handler())) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1323
      tty->cr();
32178
568a8854ff71 8132969: C++11 requires a space between literal and identifier
ctornqvi
parents: 31620
diff changeset
  1324
      tty->print_cr("argument handler #%d at " PTR_FORMAT " for fingerprint " UINT64_FORMAT,
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1325
                    _handlers->length(),
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33105
diff changeset
  1326
                    p2i(handler),
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1327
                    fingerprint);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1328
    }
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1329
    _fingerprints->append(fingerprint);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1330
    _handlers->append(handler);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1331
  } else {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1332
    if (PrintSignatureHandlers) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1333
      tty->cr();
32178
568a8854ff71 8132969: C++11 requires a space between literal and identifier
ctornqvi
parents: 31620
diff changeset
  1334
      tty->print_cr("duplicate argument handler #%d for fingerprint " UINT64_FORMAT "(old: " PTR_FORMAT ", new : " PTR_FORMAT ")",
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1335
                    _handlers->length(),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1336
                    fingerprint,
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33105
diff changeset
  1337
                    p2i(_handlers->at(handler_index)),
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33105
diff changeset
  1338
                    p2i(handler));
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1339
    }
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1340
  }
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1341
}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31382
diff changeset
  1342
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
BufferBlob*              SignatureHandlerLibrary::_handler_blob = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
address                  SignatureHandlerLibrary::_handler      = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
GrowableArray<uint64_t>* SignatureHandlerLibrary::_fingerprints = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
GrowableArray<address>*  SignatureHandlerLibrary::_handlers     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
address                  SignatureHandlerLibrary::_buffer       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1351
IRT_ENTRY(void, InterpreterRuntime::prepare_native_call(JavaThread* thread, Method* method))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
  methodHandle m(thread, method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
  assert(m->is_native(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
  // lookup native function entry point if it doesn't exist
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
  bool in_base_library;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
  if (!m->has_native_function()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
    NativeLookup::lookup(m, in_base_library, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
  // make sure signature handler is installed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  SignatureHandlerLibrary::add(m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
  // The interpreter entry point checks the signature handler first,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
  // before trying to fetch the native entry point and klass mirror.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  // We must set the signature handler last, so that multiple processors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
  // preparing the same method will be sure to see non-null entry & mirror.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
10520
db9177a52cee 7085012: ARM: com/sun/jdi/PopSynchronousTest.java still fails
roland
parents: 10265
diff changeset
  1367
#if defined(IA32) || defined(AMD64) || defined(ARM)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
IRT_LEAF(void, InterpreterRuntime::popframe_move_outgoing_args(JavaThread* thread, void* src_address, void* dest_address))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
  if (src_address == dest_address) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  ResetNoHandleMark rnm; // In a LEAF entry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
  frame fr = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
  assert(fr.is_interpreted_frame(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
  jint bci = fr.interpreter_frame_bci();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
  methodHandle mh(thread, fr.interpreter_frame_method());
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7411
diff changeset
  1379
  Bytecode_invoke invoke(mh, bci);
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7411
diff changeset
  1380
  ArgumentSizeComputer asc(invoke.signature());
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7411
diff changeset
  1381
  int size_of_arguments = (asc.size() + (invoke.has_receiver() ? 1 : 0)); // receiver
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5882
diff changeset
  1382
  Copy::conjoint_jbytes(src_address, dest_address,
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 4761
diff changeset
  1383
                       size_of_arguments * Interpreter::stackElementSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
#endif
19266
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1386
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1387
#if INCLUDE_JVMTI
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1388
// This is a support of the JVMTI PopFrame interface.
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1389
// Make sure it is an invokestatic of a polymorphic intrinsic that has a member_name argument
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1390
// and return it as a vm_result so that it can be reloaded in the list of invokestatic parameters.
24678
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1391
// The member_name argument is a saved reference (in local#0) to the member_name.
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1392
// For backward compatibility with some JDK versions (7, 8) it can also be a direct method handle.
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1393
// FIXME: remove DMH case after j.l.i.InvokerBytecodeGenerator code shape is updated.
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1394
IRT_ENTRY(void, InterpreterRuntime::member_name_arg_or_null(JavaThread* thread, address member_name,
19266
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1395
                                                            Method* method, address bcp))
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1396
  Bytecodes::Code code = Bytecodes::code_at(method, bcp);
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1397
  if (code != Bytecodes::_invokestatic) {
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1398
    return;
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1399
  }
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1400
  ConstantPool* cpool = method->constants();
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1401
  int cp_index = Bytes::get_native_u2(bcp + 1) + ConstantPool::CPCACHE_INDEX_TAG;
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1402
  Symbol* cname = cpool->klass_name_at(cpool->klass_ref_index_at(cp_index));
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1403
  Symbol* mname = cpool->name_ref_at(cp_index);
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1404
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1405
  if (MethodHandles::has_member_arg(cname, mname)) {
24678
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1406
    oop member_name_oop = (oop) member_name;
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1407
    if (java_lang_invoke_DirectMethodHandle::is_instance(member_name_oop)) {
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1408
      // FIXME: remove after j.l.i.InvokerBytecodeGenerator code shape is updated.
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1409
      member_name_oop = java_lang_invoke_DirectMethodHandle::member(member_name_oop);
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1410
    }
9bb217f7f313 8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents: 24424
diff changeset
  1411
    thread->set_vm_result(member_name_oop);
30599
a8ade6f048fe 8076579: Popping a stack frame after exception breakpoint sets last method param to exception
sspitsyn
parents: 30132
diff changeset
  1412
  } else {
a8ade6f048fe 8076579: Popping a stack frame after exception breakpoint sets last method param to exception
sspitsyn
parents: 30132
diff changeset
  1413
    thread->set_vm_result(NULL);
19266
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1414
  }
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1415
IRT_END
bb0324cbe0aa 7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents: 17087
diff changeset
  1416
#endif // INCLUDE_JVMTI
37152
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1417
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1418
#ifndef PRODUCT
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1419
// This must be a IRT_LEAF function because the interpreter must save registers on x86 to
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1420
// call this, which changes rsp and makes the interpreter's expression stack not walkable.
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1421
// The generated code still uses call_VM because that will set up the frame pointer for
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1422
// bcp and method.
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1423
IRT_LEAF(intptr_t, InterpreterRuntime::trace_bytecode(JavaThread* thread, intptr_t preserve_this_value, intptr_t tos, intptr_t tos2))
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1424
  const frame f = thread->last_frame();
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1425
  assert(f.is_interpreted_frame(), "must be an interpreted frame");
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1426
  methodHandle mh(thread, f.interpreter_frame_method());
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1427
  BytecodeTracer::trace(mh, f.interpreter_frame_bcp(), tos, tos2);
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1428
  return preserve_this_value;
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1429
IRT_END
29e68f1d35bb 8152065: TraceBytecodes breaks the interpreter expression stack
coleenp
parents: 36392
diff changeset
  1430
#endif // !PRODUCT