hotspot/src/share/vm/runtime/sharedRuntime.cpp
author vladidan
Thu, 07 Feb 2013 20:40:14 -0500
changeset 15485 beb9d55124da
parent 15475 73896d91270c
parent 15482 470d0b0c09f1
child 17125 db7ed6249110
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11487
diff changeset
     2
 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    26
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    27
#include "classfile/vmSymbols.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    28
#include "code/compiledIC.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    29
#include "code/scopeDesc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    30
#include "code/vtableStubs.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    31
#include "compiler/abstractCompiler.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    32
#include "compiler/compileBroker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    33
#include "compiler/compilerOracle.hpp"
14626
0cf4eccf130f 8003240: x86: move MacroAssembler into separate file
twisti
parents: 14488
diff changeset
    34
#include "compiler/disassembler.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    35
#include "interpreter/interpreter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    36
#include "interpreter/interpreterRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    37
#include "memory/gcLocker.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    38
#include "memory/universe.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    39
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    40
#include "prims/forte.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    41
#include "prims/jvmtiExport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    42
#include "prims/jvmtiRedefineClassesTrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    43
#include "prims/methodHandles.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    44
#include "prims/nativeLookup.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    45
#include "runtime/arguments.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    46
#include "runtime/biasedLocking.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    47
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    48
#include "runtime/init.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    49
#include "runtime/interfaceSupport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    50
#include "runtime/javaCalls.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    51
#include "runtime/sharedRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    52
#include "runtime/stubRoutines.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    53
#include "runtime/vframe.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    54
#include "runtime/vframeArray.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    55
#include "utilities/copy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    56
#include "utilities/dtrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    57
#include "utilities/events.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    58
#include "utilities/hashtable.inline.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 15109
diff changeset
    59
#include "utilities/macros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    60
#include "utilities/xmlstream.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    61
#ifdef TARGET_ARCH_x86
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    62
# include "nativeInst_x86.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    63
# include "vmreg_x86.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    64
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    65
#ifdef TARGET_ARCH_sparc
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    66
# include "nativeInst_sparc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    67
# include "vmreg_sparc.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    68
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    69
#ifdef TARGET_ARCH_zero
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    70
# include "nativeInst_zero.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    71
# include "vmreg_zero.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    72
#endif
8107
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    73
#ifdef TARGET_ARCH_arm
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    74
# include "nativeInst_arm.hpp"
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    75
# include "vmreg_arm.inline.hpp"
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    76
#endif
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    77
#ifdef TARGET_ARCH_ppc
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    78
# include "nativeInst_ppc.hpp"
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    79
# include "vmreg_ppc.inline.hpp"
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8076
diff changeset
    80
#endif
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    81
#ifdef COMPILER1
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    82
#include "c1/c1_Runtime1.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    83
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    84
9976
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    85
// Shared stub locations
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    86
RuntimeStub*        SharedRuntime::_wrong_method_blob;
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    87
RuntimeStub*        SharedRuntime::_ic_miss_blob;
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    88
RuntimeStub*        SharedRuntime::_resolve_opt_virtual_call_blob;
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    89
RuntimeStub*        SharedRuntime::_resolve_virtual_call_blob;
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    90
RuntimeStub*        SharedRuntime::_resolve_static_call_blob;
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    91
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    92
DeoptimizationBlob* SharedRuntime::_deopt_blob;
13883
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
    93
SafepointBlob*      SharedRuntime::_polling_page_vectors_safepoint_handler_blob;
9976
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    94
SafepointBlob*      SharedRuntime::_polling_page_safepoint_handler_blob;
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    95
SafepointBlob*      SharedRuntime::_polling_page_return_handler_blob;
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    96
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    97
#ifdef COMPILER2
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    98
UncommonTrapBlob*   SharedRuntime::_uncommon_trap_blob;
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
    99
#endif // COMPILER2
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   100
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   101
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   102
//----------------------------generate_stubs-----------------------------------
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   103
void SharedRuntime::generate_stubs() {
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   104
  _wrong_method_blob                   = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method),         "wrong_method_stub");
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   105
  _ic_miss_blob                        = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_ic_miss), "ic_miss_stub");
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   106
  _resolve_opt_virtual_call_blob       = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_opt_virtual_call_C),  "resolve_opt_virtual_call");
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   107
  _resolve_virtual_call_blob           = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_virtual_call_C),      "resolve_virtual_call");
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   108
  _resolve_static_call_blob            = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_static_call_C),       "resolve_static_call");
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   109
13883
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   110
#ifdef COMPILER2
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   111
  // Vectors are generated only by C2.
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   112
  if (is_wide_vector(MaxVectorSize)) {
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   113
    _polling_page_vectors_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_VECTOR_LOOP);
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   114
  }
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   115
#endif // COMPILER2
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   116
  _polling_page_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_LOOP);
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   117
  _polling_page_return_handler_blob    = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_RETURN);
9976
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   118
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   119
  generate_deopt_blob();
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   120
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   121
#ifdef COMPILER2
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   122
  generate_uncommon_trap_blob();
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   123
#endif // COMPILER2
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   124
}
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   125
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
#include <math.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   128
#ifndef USDT2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
HS_DTRACE_PROBE_DECL4(hotspot, object__alloc, Thread*, char*, int, size_t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
HS_DTRACE_PROBE_DECL7(hotspot, method__entry, int,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
                      char*, int, char*, int, char*, int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
HS_DTRACE_PROBE_DECL7(hotspot, method__return, int,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
                      char*, int, char*, int, char*, int);
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   134
#endif /* !USDT2 */
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
// Implementation of SharedRuntime
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
// For statistics
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
int SharedRuntime::_ic_miss_ctr = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
int SharedRuntime::_wrong_method_ctr = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
int SharedRuntime::_resolve_static_ctr = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
int SharedRuntime::_resolve_virtual_ctr = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
int SharedRuntime::_resolve_opt_virtual_ctr = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
int SharedRuntime::_implicit_null_throws = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
int SharedRuntime::_implicit_div0_throws = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
int SharedRuntime::_throw_null_ctr = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
int SharedRuntime::_nof_normal_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
int SharedRuntime::_nof_optimized_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
int SharedRuntime::_nof_inlined_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
int SharedRuntime::_nof_megamorphic_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
int SharedRuntime::_nof_static_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
int SharedRuntime::_nof_inlined_static_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
int SharedRuntime::_nof_interface_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
int SharedRuntime::_nof_optimized_interface_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
int SharedRuntime::_nof_inlined_interface_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
int SharedRuntime::_nof_megamorphic_interface_calls = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
int SharedRuntime::_nof_removable_exceptions = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
int SharedRuntime::_new_instance_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
int SharedRuntime::_new_array_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
int SharedRuntime::_multi1_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
int SharedRuntime::_multi2_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
int SharedRuntime::_multi3_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
int SharedRuntime::_multi4_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
int SharedRuntime::_multi5_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
int SharedRuntime::_mon_enter_stub_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
int SharedRuntime::_mon_exit_stub_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
int SharedRuntime::_mon_enter_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
int SharedRuntime::_mon_exit_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
int SharedRuntime::_partial_subtype_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
int SharedRuntime::_jbyte_array_copy_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
int SharedRuntime::_jshort_array_copy_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
int SharedRuntime::_jint_array_copy_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
int SharedRuntime::_jlong_array_copy_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
int SharedRuntime::_oop_array_copy_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
int SharedRuntime::_checkcast_array_copy_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
int SharedRuntime::_unsafe_array_copy_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
int SharedRuntime::_generic_array_copy_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
int SharedRuntime::_slow_array_copy_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
int SharedRuntime::_find_handler_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
int SharedRuntime::_rethrow_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
int     SharedRuntime::_ICmiss_index                    = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
int     SharedRuntime::_ICmiss_count[SharedRuntime::maxICmiss_count];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
address SharedRuntime::_ICmiss_at[SharedRuntime::maxICmiss_count];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
9976
6fef34e63df1 7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents: 9630
diff changeset
   189
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
void SharedRuntime::trace_ic_miss(address at) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  for (int i = 0; i < _ICmiss_index; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    if (_ICmiss_at[i] == at) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
      _ICmiss_count[i]++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  int index = _ICmiss_index++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  if (_ICmiss_index >= maxICmiss_count) _ICmiss_index = maxICmiss_count - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  _ICmiss_at[index] = at;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  _ICmiss_count[index] = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
void SharedRuntime::print_ic_miss_histogram() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  if (ICMissHistogram) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
    tty->print_cr ("IC Miss Histogram:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    int tot_misses = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    for (int i = 0; i < _ICmiss_index; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
      tty->print_cr("  at: " INTPTR_FORMAT "  nof: %d", _ICmiss_at[i], _ICmiss_count[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
      tot_misses += _ICmiss_count[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    tty->print_cr ("Total IC misses: %7d", tot_misses);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 15109
diff changeset
   216
#if INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   217
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   218
// G1 write-barrier pre: executed before a pointer store.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   219
JRT_LEAF(void, SharedRuntime::g1_wb_pre(oopDesc* orig, JavaThread *thread))
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   220
  if (orig == NULL) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   221
    assert(false, "should be optimized out");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   222
    return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   223
  }
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 2732
diff changeset
   224
  assert(orig->is_oop(true /* ignore mark word */), "Error");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   225
  // store the original value that was in the field reference
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   226
  thread->satb_mark_queue().enqueue(orig);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   227
JRT_END
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   228
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   229
// G1 write-barrier post: executed after a pointer store.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   230
JRT_LEAF(void, SharedRuntime::g1_wb_post(void* card_addr, JavaThread* thread))
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   231
  thread->dirty_card_queue().enqueue(card_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   232
JRT_END
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   233
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 15109
diff changeset
   234
#endif // INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 375
diff changeset
   235
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
JRT_LEAF(jlong, SharedRuntime::lmul(jlong y, jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  return x * y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
JRT_LEAF(jlong, SharedRuntime::ldiv(jlong y, jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  if (x == min_jlong && y == CONST64(-1)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    return x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
    return x / y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
JRT_LEAF(jlong, SharedRuntime::lrem(jlong y, jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  if (x == min_jlong && y == CONST64(-1)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    return x % y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
const juint  float_sign_mask  = 0x7FFFFFFF;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
const juint  float_infinity   = 0x7F800000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
const julong double_sign_mask = CONST64(0x7FFFFFFFFFFFFFFF);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
const julong double_infinity  = CONST64(0x7FF0000000000000);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
JRT_LEAF(jfloat, SharedRuntime::frem(jfloat  x, jfloat  y))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
#ifdef _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // 64-bit Windows on amd64 returns the wrong values for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  // infinity operands.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  union { jfloat f; juint i; } xbits, ybits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  xbits.f = x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  ybits.f = y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  // x Mod Infinity == x unless x is infinity
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  if ( ((xbits.i & float_sign_mask) != float_infinity) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
       ((ybits.i & float_sign_mask) == float_infinity) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    return x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  return ((jfloat)fmod((double)x,(double)y));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
JRT_LEAF(jdouble, SharedRuntime::drem(jdouble x, jdouble y))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
#ifdef _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  union { jdouble d; julong l; } xbits, ybits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  xbits.d = x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  ybits.d = y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  // x Mod Infinity == x unless x is infinity
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  if ( ((xbits.l & double_sign_mask) != double_infinity) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
       ((ybits.l & double_sign_mask) == double_infinity) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    return x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  return ((jdouble)fmod((double)x,(double)y));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   296
#ifdef __SOFTFP__
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   297
JRT_LEAF(jfloat, SharedRuntime::fadd(jfloat x, jfloat y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   298
  return x + y;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   299
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   300
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   301
JRT_LEAF(jfloat, SharedRuntime::fsub(jfloat x, jfloat y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   302
  return x - y;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   303
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   304
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   305
JRT_LEAF(jfloat, SharedRuntime::fmul(jfloat x, jfloat y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   306
  return x * y;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   307
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   308
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   309
JRT_LEAF(jfloat, SharedRuntime::fdiv(jfloat x, jfloat y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   310
  return x / y;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   311
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   312
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   313
JRT_LEAF(jdouble, SharedRuntime::dadd(jdouble x, jdouble y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   314
  return x + y;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   315
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   316
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   317
JRT_LEAF(jdouble, SharedRuntime::dsub(jdouble x, jdouble y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   318
  return x - y;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   319
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   320
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   321
JRT_LEAF(jdouble, SharedRuntime::dmul(jdouble x, jdouble y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   322
  return x * y;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   323
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   324
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   325
JRT_LEAF(jdouble, SharedRuntime::ddiv(jdouble x, jdouble y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   326
  return x / y;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   327
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   328
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   329
JRT_LEAF(jfloat, SharedRuntime::i2f(jint x))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   330
  return (jfloat)x;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   331
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   332
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   333
JRT_LEAF(jdouble, SharedRuntime::i2d(jint x))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   334
  return (jdouble)x;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   335
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   336
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   337
JRT_LEAF(jdouble, SharedRuntime::f2d(jfloat x))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   338
  return (jdouble)x;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   339
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   340
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   341
JRT_LEAF(int,  SharedRuntime::fcmpl(float x, float y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   342
  return x>y ? 1 : (x==y ? 0 : -1);  /* x<y or is_nan*/
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   343
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   344
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   345
JRT_LEAF(int,  SharedRuntime::fcmpg(float x, float y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   346
  return x<y ? -1 : (x==y ? 0 : 1);  /* x>y or is_nan */
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   347
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   348
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   349
JRT_LEAF(int,  SharedRuntime::dcmpl(double x, double y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   350
  return x>y ? 1 : (x==y ? 0 : -1); /* x<y or is_nan */
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   351
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   352
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   353
JRT_LEAF(int,  SharedRuntime::dcmpg(double x, double y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   354
  return x<y ? -1 : (x==y ? 0 : 1);  /* x>y or is_nan */
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   355
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   356
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   357
// Functions to return the opposite of the aeabi functions for nan.
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   358
JRT_LEAF(int, SharedRuntime::unordered_fcmplt(float x, float y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   359
  return (x < y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   360
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   361
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   362
JRT_LEAF(int, SharedRuntime::unordered_dcmplt(double x, double y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   363
  return (x < y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   364
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   365
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   366
JRT_LEAF(int, SharedRuntime::unordered_fcmple(float x, float y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   367
  return (x <= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   368
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   369
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   370
JRT_LEAF(int, SharedRuntime::unordered_dcmple(double x, double y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   371
  return (x <= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   372
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   373
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   374
JRT_LEAF(int, SharedRuntime::unordered_fcmpge(float x, float y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   375
  return (x >= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   376
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   377
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   378
JRT_LEAF(int, SharedRuntime::unordered_dcmpge(double x, double y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   379
  return (x >= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   380
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   381
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   382
JRT_LEAF(int, SharedRuntime::unordered_fcmpgt(float x, float y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   383
  return (x > y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   384
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   385
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   386
JRT_LEAF(int, SharedRuntime::unordered_dcmpgt(double x, double y))
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   387
  return (x > y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   388
JRT_END
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   389
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   390
// Intrinsics make gcc generate code for these.
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   391
float  SharedRuntime::fneg(float f)   {
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   392
  return -f;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   393
}
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   394
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   395
double SharedRuntime::dneg(double f)  {
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   396
  return -f;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   397
}
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   398
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   399
#endif // __SOFTFP__
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   400
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   401
#if defined(__SOFTFP__) || defined(E500V2)
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   402
// Intrinsics make gcc generate code for these.
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   403
double SharedRuntime::dabs(double f)  {
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   404
  return (f <= (double)0.0) ? (double)0.0 - f : f;
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   405
}
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   406
6965
4ef36b2a6a3a 6989297: Integrate additional portability improvements
bobv
parents: 6463
diff changeset
   407
#endif
4ef36b2a6a3a 6989297: Integrate additional portability improvements
bobv
parents: 6463
diff changeset
   408
4ef36b2a6a3a 6989297: Integrate additional portability improvements
bobv
parents: 6463
diff changeset
   409
#if defined(__SOFTFP__) || defined(PPC)
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   410
double SharedRuntime::dsqrt(double f) {
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   411
  return sqrt(f);
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   412
}
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
   413
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
JRT_LEAF(jint, SharedRuntime::f2i(jfloat  x))
1884
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   416
  if (g_isnan(x))
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   417
    return 0;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   418
  if (x >= (jfloat) max_jint)
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   419
    return max_jint;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   420
  if (x <= (jfloat) min_jint)
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   421
    return min_jint;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   422
  return (jint) x;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
JRT_LEAF(jlong, SharedRuntime::f2l(jfloat  x))
1884
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   427
  if (g_isnan(x))
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   428
    return 0;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   429
  if (x >= (jfloat) max_jlong)
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   430
    return max_jlong;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   431
  if (x <= (jfloat) min_jlong)
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   432
    return min_jlong;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   433
  return (jlong) x;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
JRT_LEAF(jint, SharedRuntime::d2i(jdouble x))
1884
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   438
  if (g_isnan(x))
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   439
    return 0;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   440
  if (x >= (jdouble) max_jint)
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   441
    return max_jint;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   442
  if (x <= (jdouble) min_jint)
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   443
    return min_jint;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   444
  return (jint) x;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
JRT_LEAF(jlong, SharedRuntime::d2l(jdouble x))
1884
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   449
  if (g_isnan(x))
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   450
    return 0;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   451
  if (x >= (jdouble) max_jlong)
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   452
    return max_jlong;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   453
  if (x <= (jdouble) min_jlong)
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   454
    return min_jlong;
f61e87294c59 6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents: 1618
diff changeset
   455
  return (jlong) x;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
JRT_LEAF(jfloat, SharedRuntime::d2f(jdouble x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  return (jfloat)x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
JRT_LEAF(jfloat, SharedRuntime::l2f(jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  return (jfloat)x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
JRT_LEAF(jdouble, SharedRuntime::l2d(jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  return (jdouble)x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
// Exception handling accross interpreter/compiler boundaries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
// exception_handler_for_return_address(...) returns the continuation address.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
// The continuation address is the entry point of the exception handler of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
// previous frame depending on the return address.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
   479
address SharedRuntime::raw_exception_handler_for_return_address(JavaThread* thread, address return_address) {
8495
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   480
  assert(frame::verify_return_pc(return_address), err_msg("must be a return address: " INTPTR_FORMAT, return_address));
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   481
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   482
  // Reset method handle flag.
5252
58f23871a5b6 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 5050
diff changeset
   483
  thread->set_is_method_handle_return(false);
58f23871a5b6 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 5050
diff changeset
   484
8495
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   485
  // The fastest case first
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  CodeBlob* blob = CodeCache::find_blob(return_address);
8495
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   487
  nmethod* nm = (blob != NULL) ? blob->as_nmethod_or_null() : NULL;
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   488
  if (nm != NULL) {
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   489
    // Set flag if return address is a method handle call site.
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   490
    thread->set_is_method_handle_return(nm->is_method_handle_return(return_address));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
    // native nmethods don't have exception handlers
8495
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   492
    assert(!nm->is_native_method(), "no exception handler");
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   493
    assert(nm->header_begin() != nm->exception_begin(), "no exception handler");
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   494
    if (nm->is_deopt_pc(return_address)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
      return SharedRuntime::deopt_blob()->unpack_with_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    } else {
8495
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   497
      return nm->exception_begin();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  // Entry code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  if (StubRoutines::returns_to_call_stub(return_address)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
    return StubRoutines::catch_exception_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  // Interpreted code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  if (Interpreter::contains(return_address)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
    return Interpreter::rethrow_exception_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
8495
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   510
  guarantee(blob == NULL || !blob->is_runtime_stub(), "caller should have skipped stub");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  guarantee(!VtableStubs::contains(return_address), "NULL exceptions in vtables should have been handled already!");
8495
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   512
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  { ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
    tty->print_cr("No exception handler found for exception at " INTPTR_FORMAT " - potential problems:", return_address);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    tty->print_cr("a) exception happened in (new?) code stubs/buffers that is not handled here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    tty->print_cr("b) other problem");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
#endif // PRODUCT
8495
a4959965eaa3 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 8107
diff changeset
   520
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
   526
JRT_LEAF(address, SharedRuntime::exception_handler_for_return_address(JavaThread* thread, address return_address))
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
   527
  return raw_exception_handler_for_return_address(thread, return_address);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
   530
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
address SharedRuntime::get_poll_stub(address pc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  address stub;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  // Look up the code blob
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  CodeBlob *cb = CodeCache::find_blob(pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  // Should be an nmethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  assert( cb && cb->is_nmethod(), "safepoint polling: pc must refer to an nmethod" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  // Look up the relocation information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  assert( ((nmethod*)cb)->is_at_poll_or_poll_return(pc),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
    "safepoint polling: type must be poll" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  assert( ((NativeInstruction*)pc)->is_safepoint_poll(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
    "Only polling locations are used for safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  bool at_poll_return = ((nmethod*)cb)->is_at_poll_return(pc);
13883
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   547
  bool has_wide_vectors = ((nmethod*)cb)->has_wide_vectors();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  if (at_poll_return) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
    assert(SharedRuntime::polling_page_return_handler_blob() != NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
           "polling page return stub not created yet");
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
   551
    stub = SharedRuntime::polling_page_return_handler_blob()->entry_point();
13883
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   552
  } else if (has_wide_vectors) {
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   553
    assert(SharedRuntime::polling_page_vectors_safepoint_handler_blob() != NULL,
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   554
           "polling page vectors safepoint stub not created yet");
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13881
diff changeset
   555
    stub = SharedRuntime::polling_page_vectors_safepoint_handler_blob()->entry_point();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    assert(SharedRuntime::polling_page_safepoint_handler_blob() != NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
           "polling page safepoint stub not created yet");
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
   559
    stub = SharedRuntime::polling_page_safepoint_handler_blob()->entry_point();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  if( TraceSafepoint ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
    char buf[256];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    jio_snprintf(buf, sizeof(buf),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
                 "... found polling page %s exception at pc = "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
                 INTPTR_FORMAT ", stub =" INTPTR_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
                 at_poll_return ? "return" : "loop",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
                 (intptr_t)pc, (intptr_t)stub);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    tty->print_raw_cr(buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  return stub;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   576
oop SharedRuntime::retrieve_receiver( Symbol* sig, frame caller ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  assert(caller.is_interpreted_frame(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  int args_size = ArgumentSizeComputer(sig).size() + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  assert(args_size <= caller.interpreter_frame_expression_stack_size(), "receiver must be on interpreter stack");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  oop result = (oop) *caller.interpreter_frame_tos_at(args_size - 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  assert(Universe::heap()->is_in(result) && result->is_oop(), "receiver must be an oop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, Handle h_exception) {
4761
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4735
diff changeset
   587
  if (JvmtiExport::can_post_on_exceptions()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    vframeStream vfst(thread, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
    methodHandle method = methodHandle(thread, vfst.method());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
    address bcp = method()->bcp_from(vfst.bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
    JvmtiExport::post_exception_throw(thread, method(), bcp, h_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  Exceptions::_throw(thread, __FILE__, __LINE__, h_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   596
void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, Symbol* name, const char *message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  Handle h_exception = Exceptions::new_exception(thread, name, message);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  throw_and_post_jvmti_exception(thread, h_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
2136
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   601
// The interpreter code to call this tracing function is only
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   602
// called/generated when TraceRedefineClasses has the right bits
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   603
// set. Since obsolete methods are never compiled, we don't have
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   604
// to modify the compilers to generate calls to this function.
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   605
//
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   606
JRT_LEAF(int, SharedRuntime::rc_trace_method_entry(
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   607
    JavaThread* thread, Method* method))
2136
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   608
  assert(RC_TRACE_IN_RANGE(0x00001000, 0x00002000), "wrong call");
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   609
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   610
  if (method->is_obsolete()) {
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   611
    // We are calling an obsolete method, but this is not necessarily
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   612
    // an error. Our method could have been redefined just after we
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   613
    // fetched the Method* from the constant pool.
2136
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   614
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   615
    // RC_TRACE macro has an embedded ResourceMark
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   616
    RC_TRACE_WITH_THREAD(0x00001000, thread,
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   617
                         ("calling obsolete method '%s'",
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   618
                          method->name_and_sig_as_C_string()));
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   619
    if (RC_TRACE_ENABLED(0x00002000)) {
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   620
      // this option is provided to debug calls to obsolete methods
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   621
      guarantee(false, "faulting at call to an obsolete method.");
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   622
    }
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   623
  }
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   624
  return 0;
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   625
JRT_END
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1618
diff changeset
   626
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
// ret_pc points into caller; we are returning caller's exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
// for given exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
address SharedRuntime::compute_compiled_exc_handler(nmethod* nm, address ret_pc, Handle& exception,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
                                                    bool force_unwind, bool top_frame_only) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  assert(nm != NULL, "must exist");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  ScopeDesc* sd = nm->scope_desc_at(ret_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  // determine handler bci, if any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  int handler_bci = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  int scope_depth = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  if (!force_unwind) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    int bci = sd->bci();
10731
ffe24d6f0575 6865265: JVM crashes with "missing exception handler" error
kvn
parents: 10254
diff changeset
   642
    bool recursive_exception = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
      bool skip_scope_increment = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
      // exception handler lookup
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
      KlassHandle ek (THREAD, exception->klass());
15109
088b1ea04490 8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents: 14626
diff changeset
   647
      methodHandle mh(THREAD, sd->method());
088b1ea04490 8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents: 14626
diff changeset
   648
      handler_bci = Method::fast_exception_handler_bci_for(mh, ek, bci, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
      if (HAS_PENDING_EXCEPTION) {
10731
ffe24d6f0575 6865265: JVM crashes with "missing exception handler" error
kvn
parents: 10254
diff changeset
   650
        recursive_exception = true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
        // We threw an exception while trying to find the exception handler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
        // Transfer the new exception to the exception handle which will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
        // be set into thread local storage, and do another lookup for an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
        // exception handler for this exception, this time starting at the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
        // BCI of the exception handler which caused the exception to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
        // thrown (bugs 4307310 and 4546590). Set "exception" reference
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
        // argument to ensure that the correct exception is thrown (4870175).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
        exception = Handle(THREAD, PENDING_EXCEPTION);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
        CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
        if (handler_bci >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
          bci = handler_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
          handler_bci = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
          skip_scope_increment = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
      }
10731
ffe24d6f0575 6865265: JVM crashes with "missing exception handler" error
kvn
parents: 10254
diff changeset
   666
      else {
ffe24d6f0575 6865265: JVM crashes with "missing exception handler" error
kvn
parents: 10254
diff changeset
   667
        recursive_exception = false;
ffe24d6f0575 6865265: JVM crashes with "missing exception handler" error
kvn
parents: 10254
diff changeset
   668
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
      if (!top_frame_only && handler_bci < 0 && !skip_scope_increment) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
        sd = sd->sender();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
        if (sd != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
          bci = sd->bci();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
        ++scope_depth;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
      }
10731
ffe24d6f0575 6865265: JVM crashes with "missing exception handler" error
kvn
parents: 10254
diff changeset
   676
    } while (recursive_exception || (!top_frame_only && handler_bci < 0 && sd != NULL));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
  // found handling method => lookup exception handler
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
   680
  int catch_pco = ret_pc - nm->code_begin();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
  ExceptionHandlerTable table(nm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  HandlerTableEntry *t = table.entry_for(catch_pco, handler_bci, scope_depth);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  if (t == NULL && (nm->is_compiled_by_c1() || handler_bci != -1)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
    // Allow abbreviated catch tables.  The idea is to allow a method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    // to materialize its exceptions without committing to the exact
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
    // routing of exceptions.  In particular this is needed for adding
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
    // a synthethic handler to unlock monitors when inlining
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
    // synchonized methods since the unlock path isn't represented in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
    // the bytecodes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
    t = table.entry_for(catch_pco, -1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
5334
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5252
diff changeset
   694
#ifdef COMPILER1
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5252
diff changeset
   695
  if (t == NULL && nm->is_compiled_by_c1()) {
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5252
diff changeset
   696
    assert(nm->unwind_handler_begin() != NULL, "");
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5252
diff changeset
   697
    return nm->unwind_handler_begin();
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5252
diff changeset
   698
  }
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5252
diff changeset
   699
#endif
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5252
diff changeset
   700
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  if (t == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
    tty->print_cr("MISSING EXCEPTION HANDLER for pc " INTPTR_FORMAT " and handler bci %d", ret_pc, handler_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
    tty->print_cr("   Exception:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
    exception->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
    tty->print_cr(" Compiled exception table :");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
    table.print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
    nm->print_code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
    guarantee(false, "missing exception handler");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
   713
  return nm->code_begin() + t->pco();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
JRT_ENTRY(void, SharedRuntime::throw_AbstractMethodError(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  // These errors occur only at call sites
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_AbstractMethodError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
   721
JRT_ENTRY(void, SharedRuntime::throw_IncompatibleClassChangeError(JavaThread* thread))
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
   722
  // These errors occur only at call sites
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
   723
  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_IncompatibleClassChangeError(), "vtable stub");
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
   724
JRT_END
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
   725
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
JRT_ENTRY(void, SharedRuntime::throw_ArithmeticException(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ArithmeticException(), "/ by zero");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
JRT_ENTRY(void, SharedRuntime::throw_NullPointerException(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
JRT_ENTRY(void, SharedRuntime::throw_NullPointerException_at_call(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  // This entry point is effectively only used for NullPointerExceptions which occur at inline
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  // cache sites (when the callee activation is not yet set up) so we are at a call site
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
JRT_ENTRY(void, SharedRuntime::throw_StackOverflowError(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  // We avoid using the normal exception construction in this case because
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  // it performs an upcall to Java, and we're already out of stack space.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   743
  Klass* k = SystemDictionary::StackOverflowError_klass();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   744
  oop exception_oop = InstanceKlass::cast(k)->allocate_instance(CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  Handle exception (thread, exception_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  if (StackTraceInThrowable) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
    java_lang_Throwable::fill_in_stack_trace(exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  throw_and_post_jvmti_exception(thread, exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
address SharedRuntime::continuation_for_implicit_exception(JavaThread* thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
                                                           address pc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
                                                           SharedRuntime::ImplicitExceptionKind exception_kind)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  address target_pc = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  if (Interpreter::contains(pc)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
    // C++ interpreter doesn't throw implicit exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
    switch (exception_kind) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
      case IMPLICIT_NULL:           return Interpreter::throw_NullPointerException_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
      case IMPLICIT_DIVIDE_BY_ZERO: return Interpreter::throw_ArithmeticException_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
      case STACK_OVERFLOW:          return Interpreter::throw_StackOverflowError_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
      default:                      ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
#endif // !CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
    switch (exception_kind) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
      case STACK_OVERFLOW: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
        // Stack overflow only occurs upon frame setup; the callee is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
        // going to be unwound. Dispatch to a shared runtime stub
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
        // which will cause the StackOverflowError to be fabricated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
        // and processed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
        // For stack overflow in deoptimization blob, cleanup thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
        if (thread->deopt_mark() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
          Deoptimization::cleanup_deopt_info(thread, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
        }
11788
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11637
diff changeset
   781
        Events::log_exception(thread, "StackOverflowError at " INTPTR_FORMAT, pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
        return StubRoutines::throw_StackOverflowError_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
      case IMPLICIT_NULL: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
        if (VtableStubs::contains(pc)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
          // We haven't yet entered the callee frame. Fabricate an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
          // exception and begin dispatching it in the caller. Since
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
          // the caller was at a call site, it's safe to destroy all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
          // caller-saved registers, as these entry points do.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
          VtableStub* vt_stub = VtableStubs::stub_containing(pc);
1618
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1388
diff changeset
   792
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1388
diff changeset
   793
          // If vt_stub is NULL, then return NULL to signal handler to report the SEGV error.
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1388
diff changeset
   794
          if (vt_stub == NULL) return NULL;
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1388
diff changeset
   795
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
          if (vt_stub->is_abstract_method_error(pc)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
            assert(!vt_stub->is_vtable_stub(), "should never see AbstractMethodErrors from vtable-type VtableStubs");
11788
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11637
diff changeset
   798
            Events::log_exception(thread, "AbstractMethodError at " INTPTR_FORMAT, pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
            return StubRoutines::throw_AbstractMethodError_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
          } else {
11788
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11637
diff changeset
   801
            Events::log_exception(thread, "NullPointerException at vtable entry " INTPTR_FORMAT, pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
            return StubRoutines::throw_NullPointerException_at_call_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
          CodeBlob* cb = CodeCache::find_blob(pc);
1618
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1388
diff changeset
   806
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1388
diff changeset
   807
          // If code blob is NULL, then return NULL to signal handler to report the SEGV error.
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1388
diff changeset
   808
          if (cb == NULL) return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
          // Exception happened in CodeCache. Must be either:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
          // 1. Inline-cache check in C2I handler blob,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
          // 2. Inline-cache check in nmethod, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
          // 3. Implict null exception in nmethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
          if (!cb->is_nmethod()) {
5050
47ecd86932ce 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 5046
diff changeset
   816
            guarantee(cb->is_adapter_blob() || cb->is_method_handles_adapter_blob(),
1618
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1388
diff changeset
   817
                      "exception happened outside interpreter, nmethods and vtable stubs (1)");
11788
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11637
diff changeset
   818
            Events::log_exception(thread, "NullPointerException in code blob at " INTPTR_FORMAT, pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
            // There is no handler here, so we will simply unwind.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
            return StubRoutines::throw_NullPointerException_at_call_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
          // Otherwise, it's an nmethod.  Consult its exception handlers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
          nmethod* nm = (nmethod*)cb;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
          if (nm->inlinecache_check_contains(pc)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
            // exception happened inside inline-cache check code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
            // => the nmethod is not yet active (i.e., the frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
            // is not set up yet) => use return address pushed by
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
            // caller => don't push another return address
11788
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11637
diff changeset
   830
            Events::log_exception(thread, "NullPointerException in IC check " INTPTR_FORMAT, pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
            return StubRoutines::throw_NullPointerException_at_call_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
   834
          if (nm->method()->is_method_handle_intrinsic()) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
   835
            // exception happened inside MH dispatch code, similar to a vtable stub
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
   836
            Events::log_exception(thread, "NullPointerException in MH adapter " INTPTR_FORMAT, pc);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
   837
            return StubRoutines::throw_NullPointerException_at_call_entry();
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
   838
          }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
   839
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
          _implicit_null_throws++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
          target_pc = nm->continuation_for_implicit_exception(pc);
4891
7c8755dd5bb2 6920293: OptimizeStringConcat causing core dumps
never
parents: 4755
diff changeset
   844
          // If there's an unexpected fault, target_pc might be NULL,
7c8755dd5bb2 6920293: OptimizeStringConcat causing core dumps
never
parents: 4755
diff changeset
   845
          // in which case we want to fall through into the normal
7c8755dd5bb2 6920293: OptimizeStringConcat causing core dumps
never
parents: 4755
diff changeset
   846
          // error handling code.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
        break; // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
      case IMPLICIT_DIVIDE_BY_ZERO: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
        nmethod* nm = CodeCache::find_nmethod(pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
        guarantee(nm != NULL, "must have containing nmethod for implicit division-by-zero exceptions");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
        _implicit_div0_throws++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
        target_pc = nm->continuation_for_implicit_exception(pc);
4891
7c8755dd5bb2 6920293: OptimizeStringConcat causing core dumps
never
parents: 4755
diff changeset
   860
        // If there's an unexpected fault, target_pc might be NULL,
7c8755dd5bb2 6920293: OptimizeStringConcat causing core dumps
never
parents: 4755
diff changeset
   861
        // in which case we want to fall through into the normal
7c8755dd5bb2 6920293: OptimizeStringConcat causing core dumps
never
parents: 4755
diff changeset
   862
        // error handling code.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
        break; // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
      default: ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
    assert(exception_kind == IMPLICIT_NULL || exception_kind == IMPLICIT_DIVIDE_BY_ZERO, "wrong implicit exception kind");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
    // for AbortVMOnException flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    NOT_PRODUCT(Exceptions::debug_check_abort("java.lang.NullPointerException"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
    if (exception_kind == IMPLICIT_NULL) {
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11487
diff changeset
   874
      Events::log_exception(thread, "Implicit null exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
    } else {
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11487
diff changeset
   876
      Events::log_exception(thread, "Implicit division by zero exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
    return target_pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
JNI_ENTRY(void, throw_unsatisfied_link_error(JNIEnv* env, ...))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  THROW(vmSymbols::java_lang_UnsatisfiedLinkError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   892
JNI_ENTRY(void, throw_unsupported_operation_exception(JNIEnv* env, ...))
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   893
{
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   894
  THROW(vmSymbols::java_lang_UnsupportedOperationException());
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   895
}
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   896
JNI_END
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
address SharedRuntime::native_method_throw_unsatisfied_link_error_entry() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  return CAST_FROM_FN_PTR(address, &throw_unsatisfied_link_error);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
13396
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   902
address SharedRuntime::native_method_throw_unsupported_operation_exception_entry() {
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   903
  return CAST_FROM_FN_PTR(address, &throw_unsupported_operation_exception);
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   904
}
1b2b5f740ee0 7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents: 13391
diff changeset
   905
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
JRT_ENTRY(intptr_t, SharedRuntime::trace_bytecode(JavaThread* thread, intptr_t preserve_this_value, intptr_t tos, intptr_t tos2))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  const frame f = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  assert(f.is_interpreted_frame(), "must be an interpreted frame");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  methodHandle mh(THREAD, f.interpreter_frame_method());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  BytecodeTracer::trace(mh, f.interpreter_frame_bcp(), tos, tos2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  return preserve_this_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
JRT_ENTRY(void, SharedRuntime::yield_all(JavaThread* thread, int attempts))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  os::yield_all(attempts);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
JRT_ENTRY_NO_ASYNC(void, SharedRuntime::register_finalizer(JavaThread* thread, oopDesc* obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
  assert(obj->is_oop(), "must be a valid oop");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   927
  assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   928
  InstanceKlass::register_finalizer(instanceOop(obj), CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
jlong SharedRuntime::get_java_tid(Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  if (thread != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
    if (thread->is_Java_thread()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
      oop obj = ((JavaThread*)thread)->threadObj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
      return (obj == NULL) ? 0 : java_lang_Thread::thread_id(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
/**
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
 * This function ought to be a void function, but cannot be because
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
 * it gets turned into a tail-call on sparc, which runs into dtrace bug
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
 * 6254741.  Once that is fixed we can remove the dummy return value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
int SharedRuntime::dtrace_object_alloc(oopDesc* o) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
  return dtrace_object_alloc_base(Thread::current(), o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
int SharedRuntime::dtrace_object_alloc_base(Thread* thread, oopDesc* o) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  assert(DTraceAllocProbes, "wrong call");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   953
  Klass* klass = o->klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  int size = o->size();
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   955
  Symbol* name = klass->name();
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   956
#ifndef USDT2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
  HS_DTRACE_PROBE4(hotspot, object__alloc, get_java_tid(thread),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
                   name->bytes(), name->utf8_length(), size * HeapWordSize);
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   959
#else /* USDT2 */
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   960
  HOTSPOT_OBJECT_ALLOC(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   961
                   get_java_tid(thread),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   962
                   (char *) name->bytes(), name->utf8_length(), size * HeapWordSize);
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   963
#endif /* USDT2 */
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
JRT_LEAF(int, SharedRuntime::dtrace_method_entry(
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   968
    JavaThread* thread, Method* method))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
  assert(DTraceMethodProbes, "wrong call");
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   970
  Symbol* kname = method->klass_name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   971
  Symbol* name = method->name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   972
  Symbol* sig = method->signature();
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   973
#ifndef USDT2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  HS_DTRACE_PROBE7(hotspot, method__entry, get_java_tid(thread),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
      kname->bytes(), kname->utf8_length(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
      name->bytes(), name->utf8_length(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
      sig->bytes(), sig->utf8_length());
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   978
#else /* USDT2 */
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   979
  HOTSPOT_METHOD_ENTRY(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   980
      get_java_tid(thread),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   981
      (char *) kname->bytes(), kname->utf8_length(),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   982
      (char *) name->bytes(), name->utf8_length(),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   983
      (char *) sig->bytes(), sig->utf8_length());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   984
#endif /* USDT2 */
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
JRT_LEAF(int, SharedRuntime::dtrace_method_exit(
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
   989
    JavaThread* thread, Method* method))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
  assert(DTraceMethodProbes, "wrong call");
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   991
  Symbol* kname = method->klass_name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   992
  Symbol* name = method->name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
   993
  Symbol* sig = method->signature();
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   994
#ifndef USDT2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  HS_DTRACE_PROBE7(hotspot, method__return, get_java_tid(thread),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
      kname->bytes(), kname->utf8_length(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
      name->bytes(), name->utf8_length(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
      sig->bytes(), sig->utf8_length());
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
   999
#else /* USDT2 */
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
  1000
  HOTSPOT_METHOD_RETURN(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
  1001
      get_java_tid(thread),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
  1002
      (char *) kname->bytes(), kname->utf8_length(),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
  1003
      (char *) name->bytes(), name->utf8_length(),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
  1004
      (char *) sig->bytes(), sig->utf8_length());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10254
diff changeset
  1005
#endif /* USDT2 */
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
// Finds receiver, CallInfo (i.e. receiver method), and calling bytecode)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
// for a call current in progress, i.e., arguments has been pushed on stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
// put callee has not been invoked yet.  Used by: resolve virtual/static,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
// vtable updates, etc.  Caller frame must be compiled.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
Handle SharedRuntime::find_callee_info(JavaThread* thread, Bytecodes::Code& bc, CallInfo& callinfo, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  // last java frame on stack (which includes native call frames)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  vframeStream vfst(thread, true);  // Do not skip and javaCalls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  return find_callee_info_helper(thread, vfst, bc, callinfo, CHECK_(Handle()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
// Finds receiver, CallInfo (i.e. receiver method), and calling bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
// for a call current in progress, i.e., arguments has been pushed on stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
// but callee has not been invoked yet.  Caller frame must be compiled.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
Handle SharedRuntime::find_callee_info_helper(JavaThread* thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
                                              vframeStream& vfst,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
                                              Bytecodes::Code& bc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
                                              CallInfo& callinfo, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  Handle receiver;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  Handle nullHandle;  //create a handy null handle for exception returns
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  assert(!vfst.at_end(), "Java frame must exist");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
  // Find caller and bci from vframe
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1037
  methodHandle caller(THREAD, vfst.method());
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1038
  int          bci   = vfst.bci();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
  // Find bytecode
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
  1041
  Bytecode_invoke bytecode(caller, bci);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1042
  bc = bytecode.invoke_code();
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
  1043
  int bytecode_index = bytecode.index();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  // Find receiver for non-static call
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1046
  if (bc != Bytecodes::_invokestatic &&
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1047
      bc != Bytecodes::_invokedynamic) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
    // This register map must be update since we need to find the receiver for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
    // compiled frames. The receiver might be in a register.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
    RegisterMap reg_map2(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
    frame stubFrame   = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
    // Caller-frame is a compiled frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
    frame callerFrame = stubFrame.sender(&reg_map2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
  1055
    methodHandle callee = bytecode.static_target(CHECK_(nullHandle));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
    if (callee.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
      THROW_(vmSymbols::java_lang_NoSuchMethodException(), nullHandle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
    // Retrieve from a compiled argument list
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
    receiver = Handle(THREAD, callerFrame.retrieve_receiver(&reg_map2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
    if (receiver.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
      THROW_(vmSymbols::java_lang_NullPointerException(), nullHandle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  // Resolve method. This is parameterized by bytecode.
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1068
  constantPoolHandle constants(THREAD, caller->constants());
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1069
  assert(receiver.is_null() || receiver->is_oop(), "wrong receiver");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  LinkResolver::resolve_invoke(callinfo, receiver, constants, bytecode_index, bc, CHECK_(nullHandle));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  // Check that the receiver klass is of the right subtype and that it is initialized for virtual calls
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3262
diff changeset
  1074
  if (bc != Bytecodes::_invokestatic && bc != Bytecodes::_invokedynamic) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
    assert(receiver.not_null(), "should have thrown exception");
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1076
    KlassHandle receiver_klass(THREAD, receiver->klass());
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1077
    Klass* rk = constants->klass_ref_at(bytecode_index, CHECK_(nullHandle));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
                            // klass is already loaded
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1079
    KlassHandle static_receiver_klass(THREAD, rk);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1080
    // Method handle invokes might have been optimized to a direct call
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1081
    // so don't check for the receiver class.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1082
    // FIXME this weakens the assert too much
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1083
    methodHandle callee = callinfo.selected_method();
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1084
    assert(receiver_klass->is_subtype_of(static_receiver_klass()) ||
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1085
           callee->is_method_handle_intrinsic() ||
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1086
           callee->is_compiled_lambda_form(),
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1087
           "actual receiver must be subclass of static receiver klass");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
    if (receiver_klass->oop_is_instance()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1089
      if (InstanceKlass::cast(receiver_klass())->is_not_initialized()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
        tty->print_cr("ERROR: Klass not yet initialized!!");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1091
        receiver_klass()->print();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
      }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1093
      assert(!InstanceKlass::cast(receiver_klass())->is_not_initialized(), "receiver_klass must be initialized");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  return receiver;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
methodHandle SharedRuntime::find_callee_method(JavaThread* thread, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
  // We need first to check if any Java activations (compiled, interpreted)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
  // exist on the stack since last JavaCall.  If not, we need
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
  // to get the target method from the JavaCall wrapper.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
  vframeStream vfst(thread, true);  // Do not skip any javaCalls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  methodHandle callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
  if (vfst.at_end()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
    // No Java frames were found on stack since we did the JavaCall.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
    // Hence the stack can only contain an entry_frame.  We need to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
    // find the target method from the stub frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
    RegisterMap reg_map(thread, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
    frame fr = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
    assert(fr.is_runtime_frame(), "must be a runtimeStub");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
    fr = fr.sender(&reg_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
    assert(fr.is_entry_frame(), "must be");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
    // fr is now pointing to the entry frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
    callee_method = methodHandle(THREAD, fr.entry_frame_call_wrapper()->callee_method());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
    assert(fr.entry_frame_call_wrapper()->receiver() == NULL || !callee_method->is_static(), "non-null receiver for static call??");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
    Bytecodes::Code bc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
    CallInfo callinfo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
    find_callee_info_helper(thread, vfst, bc, callinfo, CHECK_(methodHandle()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
    callee_method = callinfo.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
  assert(callee_method()->is_method(), "must be");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
  return callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
// Resolves a call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
methodHandle SharedRuntime::resolve_helper(JavaThread *thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
                                           bool is_virtual,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
                                           bool is_optimized, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  methodHandle callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  callee_method = resolve_sub_helper(thread, is_virtual, is_optimized, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
  if (JvmtiExport::can_hotswap_or_post_breakpoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
    int retry_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
    while (!HAS_PENDING_EXCEPTION && callee_method->is_old() &&
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4567
diff changeset
  1139
           callee_method->method_holder() != SystemDictionary::Object_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
      // If has a pending exception then there is no need to re-try to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
      // resolve this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
      // If the method has been redefined, we need to try again.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
      // Hack: we have no way to update the vtables of arrays, so don't
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
      // require that java.lang.Object has been updated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
      // It is very unlikely that method is redefined more than 100 times
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
      // in the middle of resolve. If it is looping here more than 100 times
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
      // means then there could be a bug here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
      guarantee((retry_count++ < 100),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
                "Could not resolve to latest version of redefined method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
      // method is redefined in the middle of resolve so re-try.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
      callee_method = resolve_sub_helper(thread, is_virtual, is_optimized, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
  return callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
// Resolves a call.  The compilers generate code for calls that go here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
// and are patched with the real destination of the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
methodHandle SharedRuntime::resolve_sub_helper(JavaThread *thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
                                           bool is_virtual,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
                                           bool is_optimized, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
  ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
  RegisterMap cbl_map(thread, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
  frame caller_frame = thread->last_frame().sender(&cbl_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
  1168
  CodeBlob* caller_cb = caller_frame.cb();
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
  1169
  guarantee(caller_cb != NULL && caller_cb->is_nmethod(), "must be called from nmethod");
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
  1170
  nmethod* caller_nm = caller_cb->as_nmethod_or_null();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
  // make sure caller is not getting deoptimized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
  // and removed before we are done with it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  // CLEANUP - with lazy deopt shouldn't need this lock
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
  1174
  nmethodLocker caller_lock(caller_nm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  // determine call info & receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
  // note: a) receiver is NULL for static calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
  //       b) an exception is thrown if receiver is NULL for non-static calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
  CallInfo call_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
  Bytecodes::Code invoke_code = Bytecodes::_illegal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
  Handle receiver = find_callee_info(thread, invoke_code,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
                                     call_info, CHECK_(methodHandle()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  methodHandle callee_method = call_info.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1186
  assert((!is_virtual && invoke_code == Bytecodes::_invokestatic ) ||
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1187
         (!is_virtual && invoke_code == Bytecodes::_invokehandle ) ||
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1188
         (!is_virtual && invoke_code == Bytecodes::_invokedynamic) ||
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1189
         ( is_virtual && invoke_code != Bytecodes::_invokestatic ), "inconsistent bytecode");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  // tracing/debugging/statistics
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
  int *addr = (is_optimized) ? (&_resolve_opt_virtual_ctr) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
                (is_virtual) ? (&_resolve_virtual_ctr) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
                               (&_resolve_static_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
  Atomic::inc(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
  if (TraceCallFixup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
    ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
    tty->print("resolving %s%s (%s) call to",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
      (is_optimized) ? "optimized " : "", (is_virtual) ? "virtual" : "static",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
      Bytecodes::name(invoke_code));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
    callee_method->print_short_name(tty);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1204
    tty->print_cr(" at pc: " INTPTR_FORMAT " to code: " INTPTR_FORMAT, caller_frame.pc(), callee_method->code());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1208
  // JSR 292 key invariant:
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
  1209
  // If the resolved method is a MethodHandle invoke target the call
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1210
  // site must be a MethodHandle call site, because the lambda form might tail-call
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1211
  // leaving the stack in a state unknown to either caller or callee
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1212
  // TODO detune for now but we might need it again
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1213
//  assert(!callee_method->is_compiled_lambda_form() ||
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1214
//         caller_nm->is_method_handle_return(caller_frame.pc()), "must be MH call site");
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
  1215
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
  // Compute entry points. This might require generation of C2I converter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  // frames, so we cannot be holding any locks here. Furthermore, the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
  // computation of the entry points is independent of patching the call.  We
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
  // always return the entry-point, but we only patch the stub if the call has
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
  // not been deoptimized.  Return values: For a virtual call this is an
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
  // (cached_oop, destination address) pair. For a static call/optimized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
  // virtual this is just a destination address.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
  StaticCallInfo static_call_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
  CompiledICInfo virtual_call_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
  // Make sure the callee nmethod does not get deoptimized and removed before
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
  // we are done patching the code.
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
  1229
  nmethod* callee_nm = callee_method->code();
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
  1230
  nmethodLocker nl_callee(callee_nm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
#ifdef ASSERT
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 4904
diff changeset
  1232
  address dest_entry_point = callee_nm == NULL ? 0 : callee_nm->entry_point(); // used below
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
  if (is_virtual) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
    assert(receiver.not_null(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
    bool static_bound = call_info.resolved_method()->can_be_statically_bound();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
    KlassHandle h_klass(THREAD, receiver->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
    CompiledIC::compute_monomorphic_entry(callee_method, h_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
                     is_optimized, static_bound, virtual_call_info,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
                     CHECK_(methodHandle()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
    // static call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
    CompiledStaticCall::compute_entry(callee_method, static_call_info);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
  // grab lock, check for deoptimization and potentially patch caller
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
    MutexLocker ml_patch(CompiledIC_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1251
    // Now that we are ready to patch if the Method* was redefined then
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
    // don't update call site and let the caller retry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
    if (!callee_method->is_old()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
      // We must not try to patch to jump to an already unloaded method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
      if (dest_entry_point != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
        assert(CodeCache::find_blob(dest_entry_point) != NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
               "should not unload nmethod while locked");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
      if (is_virtual) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1263
        nmethod* nm = callee_nm;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1264
        if (nm == NULL) CodeCache::find_blob(caller_frame.pc());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1265
        CompiledIC* inline_cache = CompiledIC_before(caller_nm, caller_frame.pc());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
        if (inline_cache->is_clean()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
          inline_cache->set_to_monomorphic(virtual_call_info);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
        CompiledStaticCall* ssc = compiledStaticCall_before(caller_frame.pc());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
        if (ssc->is_clean()) ssc->set(static_call_info);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
  } // unlock CompiledIC_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
  return callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
// Inline caches exist only in compiled code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method_ic_miss(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
  RegisterMap reg_map(thread, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
  frame stub_frame = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
  assert(stub_frame.is_runtime_frame(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
  frame caller_frame = stub_frame.sender(&reg_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
  assert(!caller_frame.is_interpreted_frame() && !caller_frame.is_entry_frame(), "unexpected frame");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
#endif /* ASSERT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
  methodHandle callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
  JRT_BLOCK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
    callee_method = SharedRuntime::handle_ic_miss_helper(thread, CHECK_NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1294
    // Return Method* through TLS
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1295
    thread->set_vm_result_2(callee_method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
  JRT_BLOCK_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
  // return compiled code entry point after potential safepoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
  assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
  return callee_method->verified_code_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
// Handle call site that has been made non-entrant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method(JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
  // 6243940 We might end up in here if the callee is deoptimized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
  // as we race to call it.  We don't want to take a safepoint if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
  // the caller was interpreted because the caller frame will look
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
  // interpreted to the stack walkers and arguments are now
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
  // "compiled" so it is much better to make this transition
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
  // invisible to the stack walking code. The i2c path will
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
  // place the callee method in the callee_target. It is stashed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  // there because if we try and find the callee by normal means a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
  // safepoint is possible and have trouble gc'ing the compiled args.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
  RegisterMap reg_map(thread, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
  frame stub_frame = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
  assert(stub_frame.is_runtime_frame(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
  frame caller_frame = stub_frame.sender(&reg_map);
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3262
diff changeset
  1318
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3262
diff changeset
  1319
  // MethodHandle invokes don't have a CompiledIC and should always
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3262
diff changeset
  1320
  // simply redispatch to the callee_target.
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3262
diff changeset
  1321
  address   sender_pc = caller_frame.pc();
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3262
diff changeset
  1322
  CodeBlob* sender_cb = caller_frame.cb();
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3262
diff changeset
  1323
  nmethod*  sender_nm = sender_cb->as_nmethod_or_null();
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3262
diff changeset
  1324
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3262
diff changeset
  1325
  if (caller_frame.is_interpreted_frame() ||
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  1326
      caller_frame.is_entry_frame()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1327
    Method* callee = thread->callee_target();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
    guarantee(callee != NULL && callee->is_method(), "bad handshake");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1329
    thread->set_vm_result_2(callee);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
    thread->set_callee_target(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
    return callee->get_c2i_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
  // Must be compiled to compiled path which is safe to stackwalk
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
  methodHandle callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
  JRT_BLOCK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
    // Force resolving of caller (if we called from compiled frame)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
    callee_method = SharedRuntime::reresolve_call_site(thread, CHECK_NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1339
    thread->set_vm_result_2(callee_method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
  JRT_BLOCK_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
  // return compiled code entry point after potential safepoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
  assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  return callee_method->verified_code_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
// resolve a static call and patch code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_static_call_C(JavaThread *thread ))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
  methodHandle callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
  JRT_BLOCK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
    callee_method = SharedRuntime::resolve_helper(thread, false, false, CHECK_NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1352
    thread->set_vm_result_2(callee_method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
  JRT_BLOCK_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
  // return compiled code entry point after potential safepoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
  assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
  return callee_method->verified_code_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
// resolve virtual call and update inline cache to monomorphic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_virtual_call_C(JavaThread *thread ))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
  methodHandle callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  JRT_BLOCK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
    callee_method = SharedRuntime::resolve_helper(thread, true, false, CHECK_NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1365
    thread->set_vm_result_2(callee_method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  JRT_BLOCK_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  // return compiled code entry point after potential safepoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
  assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
  return callee_method->verified_code_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
// Resolve a virtual call that can be statically bound (e.g., always
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
// monomorphic, so it has no inline cache).  Patch code to resolved target.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_opt_virtual_call_C(JavaThread *thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
  methodHandle callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
  JRT_BLOCK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
    callee_method = SharedRuntime::resolve_helper(thread, true, true, CHECK_NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1379
    thread->set_vm_result_2(callee_method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
  JRT_BLOCK_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
  // return compiled code entry point after potential safepoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
  assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
  return callee_method->verified_code_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
methodHandle SharedRuntime::handle_ic_miss_helper(JavaThread *thread, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
  ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
  CallInfo call_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
  Bytecodes::Code bc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
  // receiver is NULL for static calls. An exception is thrown for NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
  // receivers for non-static calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
  Handle receiver = find_callee_info(thread, bc, call_info,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
                                     CHECK_(methodHandle()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
  // Compiler1 can produce virtual call sites that can actually be statically bound
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
  // If we fell thru to below we would think that the site was going megamorphic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
  // when in fact the site can never miss. Worse because we'd think it was megamorphic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
  // we'd try and do a vtable dispatch however methods that can be statically bound
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
  // don't have vtable entries (vtable_index < 0) and we'd blow up. So we force a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
  // reresolution of the  call site (as if we did a handle_wrong_method and not an
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
  // plain ic_miss) and the site will be converted to an optimized virtual call site
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
  // never to miss again. I don't believe C2 will produce code like this but if it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
  // did this would still be the correct thing to do for it too, hence no ifdef.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
  if (call_info.resolved_method()->can_be_statically_bound()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
    methodHandle callee_method = SharedRuntime::reresolve_call_site(thread, CHECK_(methodHandle()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
    if (TraceCallFixup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
      RegisterMap reg_map(thread, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
      frame caller_frame = thread->last_frame().sender(&reg_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
      ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
      tty->print("converting IC miss to reresolve (%s) call to", Bytecodes::name(bc));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
      callee_method->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
      tty->print_cr(" from pc: " INTPTR_FORMAT, caller_frame.pc());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
      tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
    return callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
  methodHandle callee_method = call_info.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
  bool should_be_mono = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
  Atomic::inc(&_ic_miss_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
  // Statistics & Tracing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
  if (TraceCallFixup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
    ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
    tty->print("IC miss (%s) call to", Bytecodes::name(bc));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
    callee_method->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
    tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
  if (ICMissHistogram) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
    MutexLocker m(VMStatistic_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
    RegisterMap reg_map(thread, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
    frame f = thread->last_frame().real_sender(&reg_map);// skip runtime stub
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
    // produce statistics under the lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
    trace_ic_miss(f.pc());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
  // install an event collector so that when a vtable stub is created the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
  // profiler can be notified via a DYNAMIC_CODE_GENERATED event. The
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
  // event can't be posted when the stub is created as locks are held
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
  // - instead the event will be deferred until the event collector goes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
  // out of scope.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
  JvmtiDynamicCodeEventCollector event_collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
  // Update inline cache to megamorphic. Skip update if caller has been
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
  // made non-entrant or we are called from interpreted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
  { MutexLocker ml_patch (CompiledIC_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
    RegisterMap reg_map(thread, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
    frame caller_frame = thread->last_frame().sender(&reg_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
    CodeBlob* cb = caller_frame.cb();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
    if (cb->is_nmethod() && ((nmethod*)cb)->is_in_use()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
      // Not a non-entrant nmethod, so find inline_cache
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1462
      CompiledIC* inline_cache = CompiledIC_before(((nmethod*)cb), caller_frame.pc());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
      bool should_be_mono = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
      if (inline_cache->is_optimized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
        if (TraceCallFixup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
          ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
          tty->print("OPTIMIZED IC miss (%s) call to", Bytecodes::name(bc));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
          callee_method->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
          tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
        should_be_mono = true;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1472
      } else if (inline_cache->is_icholder_call()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1473
        CompiledICHolder* ic_oop = inline_cache->cached_icholder();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1474
        if ( ic_oop != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
          if (receiver()->klass() == ic_oop->holder_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
            // This isn't a real miss. We must have seen that compiled code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
            // is now available and we want the call site converted to a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
            // monomorphic compiled call site.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
            // We can't assert for callee_method->code() != NULL because it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
            // could have been deoptimized in the meantime
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
            if (TraceCallFixup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
              ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
              tty->print("FALSE IC miss (%s) converting to compiled call to", Bytecodes::name(bc));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
              callee_method->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
              tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
            should_be_mono = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
      if (should_be_mono) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
        // We have a path that was monomorphic but was going interpreted
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
        // and now we have (or had) a compiled entry. We correct the IC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
        // by using a new icBuffer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
        CompiledICInfo info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
        KlassHandle receiver_klass(THREAD, receiver()->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
        inline_cache->compute_monomorphic_entry(callee_method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
                                                receiver_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
                                                inline_cache->is_optimized(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
                                                false,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
                                                info, CHECK_(methodHandle()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
        inline_cache->set_to_monomorphic(info);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
      } else if (!inline_cache->is_megamorphic() && !inline_cache->is_clean()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
        // Change to megamorphic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
        inline_cache->set_to_megamorphic(&call_info, bc, CHECK_(methodHandle()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
        // Either clean or megamorphic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
  } // Release CompiledIC_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
  return callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
// Resets a call-site in compiled code so it will get resolved again.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
// This routines handles both virtual call sites, optimized virtual call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
// sites, and static call sites. Typically used to change a call sites
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
// destination from compiled to interpreted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
methodHandle SharedRuntime::reresolve_call_site(JavaThread *thread, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
  ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
  RegisterMap reg_map(thread, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
  frame stub_frame = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
  assert(stub_frame.is_runtime_frame(), "must be a runtimeStub");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
  frame caller = stub_frame.sender(&reg_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
  // Do nothing if the frame isn't a live compiled frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
  // nmethod could be deoptimized by the time we get here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
  // so no update to the caller is needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
  if (caller.is_compiled_frame() && !caller.is_deoptimized_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
    address pc = caller.pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
    // Default call_addr is the location of the "basic" call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
    // Determine the address of the call we a reresolving. With
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
    // Inline Caches we will always find a recognizable call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
    // With Inline Caches disabled we may or may not find a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
    // recognizable call. We will always find a call for static
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
    // calls and for optimized virtual calls. For vanilla virtual
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
    // calls it depends on the state of the UseInlineCaches switch.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
    // With Inline Caches disabled we can get here for a virtual call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
    // for two reasons:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
    //   1 - calling an abstract method. The vtable for abstract methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
    //       will run us thru handle_wrong_method and we will eventually
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
    //       end up in the interpreter to throw the ame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
    //   2 - a racing deoptimization. We could be doing a vanilla vtable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
    //       call and between the time we fetch the entry address and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
    //       we jump to it the target gets deoptimized. Similar to 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
    //       we will wind up in the interprter (thru a c2i with c2).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
    address call_addr = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
      // Get call instruction under lock because another thread may be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
      // busy patching it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
      MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
      // Location of call instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
      if (NativeCall::is_call_before(pc)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
        NativeCall *ncall = nativeCall_before(pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
        call_addr = ncall->instruction_address();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
    // Check for static or virtual call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
    bool is_static_call = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
    nmethod* caller_nm = CodeCache::find_nmethod(pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
    // Make sure nmethod doesn't get deoptimized and removed until
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
    // this is done with it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
    // CLEANUP - with lazy deopt shouldn't need this lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
    nmethodLocker nmlock(caller_nm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
    if (call_addr != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
      RelocIterator iter(caller_nm, call_addr, call_addr+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
      int ret = iter.next(); // Get item
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
      if (ret) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
        assert(iter.addr() == call_addr, "must find call");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
        if (iter.type() == relocInfo::static_call_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
          is_static_call = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
          assert(iter.type() == relocInfo::virtual_call_type ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
                 iter.type() == relocInfo::opt_virtual_call_type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
                , "unexpected relocInfo. type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
        assert(!UseInlineCaches, "relocation info. must exist for this address");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
      // Cleaning the inline cache will force a new resolve. This is more robust
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
      // than directly setting it to the new destination, since resolving of calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
      // is always done through the same code path. (experience shows that it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
      // leads to very hard to track down bugs, if an inline cache gets updated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
      // to a wrong method). It should not be performance critical, since the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
      // resolve is only done once.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
      MutexLocker ml(CompiledIC_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
      // We do not patch the call site if the nmethod has been made non-entrant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
      // as it is a waste of time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
      if (caller_nm->is_in_use()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
        if (is_static_call) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
          CompiledStaticCall* ssc= compiledStaticCall_at(call_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
          ssc->set_to_clean();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
          // compiled, dispatched call (which used to call an interpreted method)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1611
          CompiledIC* inline_cache = CompiledIC_at(caller_nm, call_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
          inline_cache->set_to_clean();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
  methodHandle callee_method = find_callee_method(thread, CHECK_(methodHandle()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
  Atomic::inc(&_wrong_method_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
  if (TraceCallFixup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
    ResourceMark rm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
    tty->print("handle_wrong_method reresolving call to");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
    callee_method->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
    tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
  return callee_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
13881
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1636
#ifdef ASSERT
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1637
void SharedRuntime::check_member_name_argument_is_last_argument(methodHandle method,
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1638
                                                                const BasicType* sig_bt,
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1639
                                                                const VMRegPair* regs) {
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1640
  ResourceMark rm;
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1641
  const int total_args_passed = method->size_of_parameters();
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1642
  const VMRegPair*    regs_with_member_name = regs;
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1643
        VMRegPair* regs_without_member_name = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed - 1);
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1644
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1645
  const int member_arg_pos = total_args_passed - 1;
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1646
  assert(member_arg_pos >= 0 && member_arg_pos < total_args_passed, "oob");
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1647
  assert(sig_bt[member_arg_pos] == T_OBJECT, "dispatch argument must be an object");
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1648
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1649
  const bool is_outgoing = method->is_method_handle_intrinsic();
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1650
  int comp_args_on_stack = java_calling_convention(sig_bt, regs_without_member_name, total_args_passed - 1, is_outgoing);
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1651
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1652
  for (int i = 0; i < member_arg_pos; i++) {
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1653
    VMReg a =    regs_with_member_name[i].first();
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1654
    VMReg b = regs_without_member_name[i].first();
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1655
    assert(a->value() == b->value(), err_msg_res("register allocation mismatch: a=%d, b=%d", a->value(), b->value()));
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1656
  }
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1657
  assert(regs_with_member_name[member_arg_pos].first()->is_valid(), "bad member arg");
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1658
}
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1659
#endif
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  1660
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
// We are calling the interpreter via a c2i. Normally this would mean that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
// we were called by a compiled method. However we could have lost a race
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
// where we went int -> i2c -> c2i and so the caller could in fact be
4753
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1665
// interpreted. If the caller is compiled we attempt to patch the caller
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
// so he no longer calls into the interpreter.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1667
IRT_LEAF(void, SharedRuntime::fixup_callers_callsite(Method* method, address caller_pc))
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1668
  Method* moop(method);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
  address entry_point = moop->from_compiled_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
  // It's possible that deoptimization can occur at a call site which hasn't
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
  // been resolved yet, in which case this function will be called from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
  // an nmethod that has been patched for deopt and we can ignore the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
  // request for a fixup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
  // Also it is possible that we lost a race in that from_compiled_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
  // is now back to the i2c in that case we don't need to patch and if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
  // we did we'd leap into space because the callsite needs to use
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1679
  // "to interpreter" stub in order to load up the Method*. Don't
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
  // ask me how I know this...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
  CodeBlob* cb = CodeCache::find_blob(caller_pc);
4753
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1683
  if (!cb->is_nmethod() || entry_point == moop->get_c2i_entry()) {
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1684
    return;
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1685
  }
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1686
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1687
  // The check above makes sure this is a nmethod.
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1688
  nmethod* nm = cb->as_nmethod_or_null();
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1689
  assert(nm, "must be");
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1690
10968
6f5d19d76c93 7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents: 10740
diff changeset
  1691
  // Get the return PC for the passed caller PC.
6f5d19d76c93 7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents: 10740
diff changeset
  1692
  address return_pc = caller_pc + frame::pc_return_offset;
6f5d19d76c93 7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents: 10740
diff changeset
  1693
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
  // There is a benign race here. We could be attempting to patch to a compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
  // entry point at the same time the callee is being deoptimized. If that is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
  // the case then entry_point may in fact point to a c2i and we'd patch the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
  // call site with the same old data. clear_code will set code() to NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
  // at the end of it. If we happen to see that NULL then we can skip trying
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  // to patch. If we hit the window where the callee has a c2i in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
  // from_compiled_entry and the NULL isn't present yet then we lose the race
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
  // and patch the code with the same old data. Asi es la vida.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
  if (moop->code() == NULL) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
4753
9e7bcf214f71 6921799: JSR 292 call sites should not be fixed-up
twisti
parents: 4752
diff changeset
  1705
  if (nm->is_in_use()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
    // Expect to find a native call there (unless it was no-inline cache vtable dispatch)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
    MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag);
10968
6f5d19d76c93 7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents: 10740
diff changeset
  1709
    if (NativeCall::is_call_before(return_pc)) {
6f5d19d76c93 7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents: 10740
diff changeset
  1710
      NativeCall *call = nativeCall_before(return_pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
      // bug 6281185. We might get here after resolving a call site to a vanilla
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
      // virtual call. Because the resolvee uses the verified entry it may then
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
      // see compiled code and attempt to patch the site by calling us. This would
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
      // then incorrectly convert the call site to optimized and its downhill from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
      // there. If you're lucky you'll get the assert in the bugid, if not you've
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
      // just made a call site that could be megamorphic into a monomorphic site
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
      // for the rest of its life! Just another racing bug in the life of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
      // fixup_callers_callsite ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
      //
5686
5435e77aa3df 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 5420
diff changeset
  1721
      RelocIterator iter(nm, call->instruction_address(), call->next_instruction_address());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
      iter.next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
      assert(iter.has_current(), "must have a reloc at java call site");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
      relocInfo::relocType typ = iter.reloc()->type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
      if ( typ != relocInfo::static_call_type &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
           typ != relocInfo::opt_virtual_call_type &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
           typ != relocInfo::static_stub_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
        return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
      address destination = call->destination();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
      if (destination != entry_point) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
        CodeBlob* callee = CodeCache::find_blob(destination);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
        // callee == cb seems weird. It means calling interpreter thru stub.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
        if (callee == cb || callee->is_adapter_blob()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
          // static call or optimized virtual
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
          if (TraceCallFixup) {
4752
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
  1737
            tty->print("fixup callsite           at " INTPTR_FORMAT " to compiled code for", caller_pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
            moop->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
            tty->print_cr(" to " INTPTR_FORMAT, entry_point);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
          call->set_destination_mt_safe(entry_point);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
          if (TraceCallFixup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
            tty->print("failed to fixup callsite at " INTPTR_FORMAT " to compiled code for", caller_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
            moop->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
            tty->print_cr(" to " INTPTR_FORMAT, entry_point);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
          // assert is too strong could also be resolve destinations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
          // assert(InlineCacheBuffer::contains(destination) || VtableStubs::contains(destination), "must be");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
          if (TraceCallFixup) {
4752
67a506670cd0 6921352: JSR 292 needs its own deopt handler
twisti
parents: 4750
diff changeset
  1753
            tty->print("already patched callsite at " INTPTR_FORMAT " to compiled code for", caller_pc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
            moop->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
            tty->print_cr(" to " INTPTR_FORMAT, entry_point);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
IRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
// same as JVM_Arraycopy, but called directly from compiled code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
JRT_ENTRY(void, SharedRuntime::slow_arraycopy_C(oopDesc* src,  jint src_pos,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
                                                oopDesc* dest, jint dest_pos,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
                                                jint length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
                                                JavaThread* thread)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
  _slow_array_copy_ctr++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
  // Check if we have null pointers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
  if (src == NULL || dest == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
    THROW(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
  // Do the copy.  The casts to arrayOop are necessary to the copy_array API,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
  // even though the copy_array API also performs dynamic checks to ensure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
  // that src and dest are truly arrays (and are conformable).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
  // The copy_array mechanism is awkward and could be removed, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
  // the compilers don't call this function except as a last resort,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
  // so it probably doesn't matter.
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 13952
diff changeset
  1781
  src->klass()->copy_array((arrayOopDesc*)src,  src_pos,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
                                        (arrayOopDesc*)dest, dest_pos,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
                                        length, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
char* SharedRuntime::generate_class_cast_message(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
    JavaThread* thread, const char* objName) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
  // Get target class name from the checkcast instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
  vframeStream vfst(thread, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
  assert(!vfst.at_end(), "Java frame must exist");
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
  1793
  Bytecode_checkcast cc(vfst.method(), vfst.method()->bcp_from(vfst.bci()));
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 13952
diff changeset
  1794
  Klass* targetKlass = vfst.method()->constants()->klass_at(
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 13952
diff changeset
  1795
    cc.index(), thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
  return generate_class_cast_message(objName, targetKlass->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
char* SharedRuntime::generate_class_cast_message(
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2332
diff changeset
  1800
    const char* objName, const char* targetKlassName, const char* desc) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
  size_t msglen = strlen(objName) + strlen(desc) + strlen(targetKlassName) + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
226
e4a3ef4b2665 6631248: Memory problem when doing invalid type cast
kamg
parents: 1
diff changeset
  1803
  char* message = NEW_RESOURCE_ARRAY(char, msglen);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
  if (NULL == message) {
226
e4a3ef4b2665 6631248: Memory problem when doing invalid type cast
kamg
parents: 1
diff changeset
  1805
    // Shouldn't happen, but don't cause even more problems if it does
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
    message = const_cast<char*>(objName);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
    jio_snprintf(message, msglen, "%s%s%s", objName, desc, targetKlassName);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
  return message;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
JRT_LEAF(void, SharedRuntime::reguard_yellow_pages())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
  (void) JavaThread::current()->reguard_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
// Handles the uncommon case in locking, i.e., contention or an inflated lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
int SharedRuntime::_monitor_enter_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
JRT_ENTRY_NO_ASYNC(void, SharedRuntime::complete_monitor_locking_C(oopDesc* _obj, BasicLock* lock, JavaThread* thread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
  oop obj(_obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
  _monitor_enter_ctr++;             // monitor enter slow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
  if (PrintBiasedLockingStatistics) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
    Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
  Handle h_obj(THREAD, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
  if (UseBiasedLocking) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
    // Retry fast entry if bias is revoked to avoid unnecessary inflation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
    ObjectSynchronizer::fast_enter(h_obj, lock, true, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
    ObjectSynchronizer::slow_enter(h_obj, lock, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
  assert(!HAS_PENDING_EXCEPTION, "Should have no exception here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
int SharedRuntime::_monitor_exit_ctr=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
// Handles the uncommon cases of monitor unlocking in compiled code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
JRT_LEAF(void, SharedRuntime::complete_monitor_unlocking_C(oopDesc* _obj, BasicLock* lock))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
   oop obj(_obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
  _monitor_exit_ctr++;              // monitor exit slow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
  Thread* THREAD = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
  // I'm not convinced we need the code contained by MIGHT_HAVE_PENDING anymore
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
  // testing was unable to ever fire the assert that guarded it so I have removed it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
  assert(!HAS_PENDING_EXCEPTION, "Do we need code below anymore?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
#undef MIGHT_HAVE_PENDING
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
#ifdef MIGHT_HAVE_PENDING
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
  // Save and restore any pending_exception around the exception mark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
  // While the slow_exit must not throw an exception, we could come into
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
  // this routine with one set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
  oop pending_excep = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
  const char* pending_file;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
  int pending_line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
  if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
    pending_excep = PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
    pending_file  = THREAD->exception_file();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
    pending_line  = THREAD->exception_line();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
    CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
#endif /* MIGHT_HAVE_PENDING */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
    // Exit must be non-blocking, and therefore no exceptions can be thrown.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
    ObjectSynchronizer::slow_exit(obj, lock, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
#ifdef MIGHT_HAVE_PENDING
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
  if (pending_excep != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
    THREAD->set_pending_exception(pending_excep, pending_file, pending_line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
#endif /* MIGHT_HAVE_PENDING */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
void SharedRuntime::print_statistics() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
  ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
  if (xtty != NULL)  xtty->head("statistics type='SharedRuntime'");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
  if (_monitor_enter_ctr ) tty->print_cr("%5d monitor enter slow",  _monitor_enter_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
  if (_monitor_exit_ctr  ) tty->print_cr("%5d monitor exit slow",   _monitor_exit_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
  if (_throw_null_ctr) tty->print_cr("%5d implicit null throw", _throw_null_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
  SharedRuntime::print_ic_miss_histogram();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
  if (CountRemovableExceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
    if (_nof_removable_exceptions > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
      Unimplemented(); // this counter is not yet incremented
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
      tty->print_cr("Removable exceptions: %d", _nof_removable_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
  // Dump the JRT_ENTRY counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
  if( _new_instance_ctr ) tty->print_cr("%5d new instance requires GC", _new_instance_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
  if( _new_array_ctr ) tty->print_cr("%5d new array requires GC", _new_array_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
  if( _multi1_ctr ) tty->print_cr("%5d multianewarray 1 dim", _multi1_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
  if( _multi2_ctr ) tty->print_cr("%5d multianewarray 2 dim", _multi2_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
  if( _multi3_ctr ) tty->print_cr("%5d multianewarray 3 dim", _multi3_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
  if( _multi4_ctr ) tty->print_cr("%5d multianewarray 4 dim", _multi4_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
  if( _multi5_ctr ) tty->print_cr("%5d multianewarray 5 dim", _multi5_ctr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
  tty->print_cr("%5d inline cache miss in compiled", _ic_miss_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
  tty->print_cr("%5d wrong method", _wrong_method_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
  tty->print_cr("%5d unresolved static call site", _resolve_static_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
  tty->print_cr("%5d unresolved virtual call site", _resolve_virtual_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
  tty->print_cr("%5d unresolved opt virtual call site", _resolve_opt_virtual_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
  if( _mon_enter_stub_ctr ) tty->print_cr("%5d monitor enter stub", _mon_enter_stub_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
  if( _mon_exit_stub_ctr ) tty->print_cr("%5d monitor exit stub", _mon_exit_stub_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
  if( _mon_enter_ctr ) tty->print_cr("%5d monitor enter slow", _mon_enter_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
  if( _mon_exit_ctr ) tty->print_cr("%5d monitor exit slow", _mon_exit_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
  if( _partial_subtype_ctr) tty->print_cr("%5d slow partial subtype", _partial_subtype_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
  if( _jbyte_array_copy_ctr ) tty->print_cr("%5d byte array copies", _jbyte_array_copy_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
  if( _jshort_array_copy_ctr ) tty->print_cr("%5d short array copies", _jshort_array_copy_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
  if( _jint_array_copy_ctr ) tty->print_cr("%5d int array copies", _jint_array_copy_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
  if( _jlong_array_copy_ctr ) tty->print_cr("%5d long array copies", _jlong_array_copy_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
  if( _oop_array_copy_ctr ) tty->print_cr("%5d oop array copies", _oop_array_copy_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
  if( _checkcast_array_copy_ctr ) tty->print_cr("%5d checkcast array copies", _checkcast_array_copy_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
  if( _unsafe_array_copy_ctr ) tty->print_cr("%5d unsafe array copies", _unsafe_array_copy_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
  if( _generic_array_copy_ctr ) tty->print_cr("%5d generic array copies", _generic_array_copy_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
  if( _slow_array_copy_ctr ) tty->print_cr("%5d slow array copies", _slow_array_copy_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
  if( _find_handler_ctr ) tty->print_cr("%5d find exception handler", _find_handler_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
  if( _rethrow_ctr ) tty->print_cr("%5d rethrow handler", _rethrow_ctr );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1932
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  1933
  AdapterHandlerLibrary::print_statistics();
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  1934
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1935
  if (xtty != NULL)  xtty->tail("statistics");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1937
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
inline double percent(int x, int y) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
  return 100.0 * x / MAX2(y, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
class MethodArityHistogram {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1943
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
  enum { MAX_ARITY = 256 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
  static int _arity_histogram[MAX_ARITY];     // histogram of #args
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
  static int _size_histogram[MAX_ARITY];      // histogram of arg size in words
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
  static int _max_arity;                      // max. arity seen
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
  static int _max_size;                       // max. arg size seen
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
  static void add_method_to_histogram(nmethod* nm) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  1952
    Method* m = nm->method();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1953
    ArgumentCount args(m->signature());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
    int arity   = args.size() + (m->is_static() ? 0 : 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
    int argsize = m->size_of_parameters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
    arity   = MIN2(arity, MAX_ARITY-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
    argsize = MIN2(argsize, MAX_ARITY-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1958
    int count = nm->method()->compiled_invocation_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1959
    _arity_histogram[arity]  += count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1960
    _size_histogram[argsize] += count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1961
    _max_arity = MAX2(_max_arity, arity);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1962
    _max_size  = MAX2(_max_size, argsize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1963
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
  void print_histogram_helper(int n, int* histo, const char* name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1966
    const int N = MIN2(5, n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1967
    tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1968
    double sum = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1969
    double weighted_sum = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1970
    int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
    for (i = 0; i <= n; i++) { sum += histo[i]; weighted_sum += i*histo[i]; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
    double rest = sum;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
    double percent = sum / 100;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1974
    for (i = 0; i <= N; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1975
      rest -= histo[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1976
      tty->print_cr("%4d: %7d (%5.1f%%)", i, histo[i], histo[i] / percent);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1977
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1978
    tty->print_cr("rest: %7d (%5.1f%%))", (int)rest, rest / percent);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
    tty->print_cr("(avg. %s = %3.1f, max = %d)", name, weighted_sum / sum, n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
  void print_histogram() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
    tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
    print_histogram_helper(_max_arity, _arity_histogram, "arity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1985
    tty->print_cr("\nSame for parameter size (in words):");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
    print_histogram_helper(_max_size, _size_histogram, "size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
  MethodArityHistogram() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
    _max_arity = _max_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
    for (int i = 0; i < MAX_ARITY; i++) _arity_histogram[i] = _size_histogram [i] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
    CodeCache::nmethods_do(add_method_to_histogram);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1996
    print_histogram();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
int MethodArityHistogram::_arity_histogram[MethodArityHistogram::MAX_ARITY];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
int MethodArityHistogram::_size_histogram[MethodArityHistogram::MAX_ARITY];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
int MethodArityHistogram::_max_arity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
int MethodArityHistogram::_max_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
void SharedRuntime::print_call_statistics(int comp_total) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
  tty->print_cr("Calls from compiled code:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
  int total  = _nof_normal_calls + _nof_interface_calls + _nof_static_calls;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
  int mono_c = _nof_normal_calls - _nof_optimized_calls - _nof_megamorphic_calls;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
  int mono_i = _nof_interface_calls - _nof_optimized_interface_calls - _nof_megamorphic_interface_calls;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
  tty->print_cr("\t%9d   (%4.1f%%) total non-inlined   ", total, percent(total, total));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
  tty->print_cr("\t%9d   (%4.1f%%) virtual calls       ", _nof_normal_calls, percent(_nof_normal_calls, total));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
  tty->print_cr("\t  %9d  (%3.0f%%)   inlined          ", _nof_inlined_calls, percent(_nof_inlined_calls, _nof_normal_calls));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
  tty->print_cr("\t  %9d  (%3.0f%%)   optimized        ", _nof_optimized_calls, percent(_nof_optimized_calls, _nof_normal_calls));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
  tty->print_cr("\t  %9d  (%3.0f%%)   monomorphic      ", mono_c, percent(mono_c, _nof_normal_calls));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
  tty->print_cr("\t  %9d  (%3.0f%%)   megamorphic      ", _nof_megamorphic_calls, percent(_nof_megamorphic_calls, _nof_normal_calls));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
  tty->print_cr("\t%9d   (%4.1f%%) interface calls     ", _nof_interface_calls, percent(_nof_interface_calls, total));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
  tty->print_cr("\t  %9d  (%3.0f%%)   inlined          ", _nof_inlined_interface_calls, percent(_nof_inlined_interface_calls, _nof_interface_calls));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
  tty->print_cr("\t  %9d  (%3.0f%%)   optimized        ", _nof_optimized_interface_calls, percent(_nof_optimized_interface_calls, _nof_interface_calls));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
  tty->print_cr("\t  %9d  (%3.0f%%)   monomorphic      ", mono_i, percent(mono_i, _nof_interface_calls));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
  tty->print_cr("\t  %9d  (%3.0f%%)   megamorphic      ", _nof_megamorphic_interface_calls, percent(_nof_megamorphic_interface_calls, _nof_interface_calls));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
  tty->print_cr("\t%9d   (%4.1f%%) static/special calls", _nof_static_calls, percent(_nof_static_calls, total));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
  tty->print_cr("\t  %9d  (%3.0f%%)   inlined          ", _nof_inlined_static_calls, percent(_nof_inlined_static_calls, _nof_static_calls));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
  tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
  tty->print_cr("Note 1: counter updates are not MT-safe.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
  tty->print_cr("Note 2: %% in major categories are relative to total non-inlined calls;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
  tty->print_cr("        %% in nested categories are relative to their category");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
  tty->print_cr("        (and thus add up to more than 100%% with inlining)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
  tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2030
  MethodArityHistogram h;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2035
// A simple wrapper class around the calling convention information
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2036
// that allows sharing of adapters for the same calling convention.
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2037
class AdapterFingerPrint : public CHeapObj<mtCode> {
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2038
 private:
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2039
  enum {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2040
    _basic_type_bits = 4,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2041
    _basic_type_mask = right_n_bits(_basic_type_bits),
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2042
    _basic_types_per_int = BitsPerInt / _basic_type_bits,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2043
    _compact_int_count = 3
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2044
  };
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2045
  // TO DO:  Consider integrating this with a more global scheme for compressing signatures.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2046
  // For now, 4 bits per components (plus T_VOID gaps after double/long) is not excessive.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2047
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2048
  union {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2049
    int  _compact[_compact_int_count];
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2050
    int* _fingerprint;
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2051
  } _value;
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2052
  int _length; // A negative length indicates the fingerprint is in the compact form,
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2053
               // Otherwise _value._fingerprint is the array.
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2054
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2055
  // Remap BasicTypes that are handled equivalently by the adapters.
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2056
  // These are correct for the current system but someday it might be
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2057
  // necessary to make this mapping platform dependent.
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2058
  static int adapter_encoding(BasicType in) {
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2059
    switch(in) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2060
      case T_BOOLEAN:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2061
      case T_BYTE:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2062
      case T_SHORT:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2063
      case T_CHAR:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2064
        // There are all promoted to T_INT in the calling convention
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2065
        return T_INT;
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2066
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2067
      case T_OBJECT:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2068
      case T_ARRAY:
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2069
        // In other words, we assume that any register good enough for
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2070
        // an int or long is good enough for a managed pointer.
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2071
#ifdef _LP64
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 5334
diff changeset
  2072
        return T_LONG;
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2073
#else
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 5334
diff changeset
  2074
        return T_INT;
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2075
#endif
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2076
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2077
      case T_INT:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2078
      case T_LONG:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2079
      case T_FLOAT:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2080
      case T_DOUBLE:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2081
      case T_VOID:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2082
        return in;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2083
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2084
      default:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2085
        ShouldNotReachHere();
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2086
        return T_CONFLICT;
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2087
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2088
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2089
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2090
 public:
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2091
  AdapterFingerPrint(int total_args_passed, BasicType* sig_bt) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2092
    // The fingerprint is based on the BasicType signature encoded
10254
406448a00c51 7071427: AdapterFingerPrint can hold 8 entries per int
never
parents: 10004
diff changeset
  2093
    // into an array of ints with eight entries per int.
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2094
    int* ptr;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2095
    int len = (total_args_passed + (_basic_types_per_int-1)) / _basic_types_per_int;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2096
    if (len <= _compact_int_count) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2097
      assert(_compact_int_count == 3, "else change next line");
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2098
      _value._compact[0] = _value._compact[1] = _value._compact[2] = 0;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2099
      // Storing the signature encoded as signed chars hits about 98%
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2100
      // of the time.
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2101
      _length = -len;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2102
      ptr = _value._compact;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2103
    } else {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2104
      _length = len;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2105
      _value._fingerprint = NEW_C_HEAP_ARRAY(int, _length, mtCode);
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2106
      ptr = _value._fingerprint;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2107
    }
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2108
10254
406448a00c51 7071427: AdapterFingerPrint can hold 8 entries per int
never
parents: 10004
diff changeset
  2109
    // Now pack the BasicTypes with 8 per int
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2110
    int sig_index = 0;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2111
    for (int index = 0; index < len; index++) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2112
      int value = 0;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2113
      for (int byte = 0; byte < _basic_types_per_int; byte++) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2114
        int bt = ((sig_index < total_args_passed)
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2115
                  ? adapter_encoding(sig_bt[sig_index++])
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2116
                  : 0);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2117
        assert((bt & _basic_type_mask) == bt, "must fit in 4 bits");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2118
        value = (value << _basic_type_bits) | bt;
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2119
      }
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2120
      ptr[index] = value;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2121
    }
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2122
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2123
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2124
  ~AdapterFingerPrint() {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2125
    if (_length > 0) {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2126
      FREE_C_HEAP_ARRAY(int, _value._fingerprint, mtCode);
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2127
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2128
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2129
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2130
  int value(int index) {
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2131
    if (_length < 0) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2132
      return _value._compact[index];
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2133
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2134
    return _value._fingerprint[index];
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2135
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2136
  int length() {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2137
    if (_length < 0) return -_length;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2138
    return _length;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2139
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2140
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2141
  bool is_compact() {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2142
    return _length <= 0;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2143
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2144
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2145
  unsigned int compute_hash() {
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2146
    int hash = 0;
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2147
    for (int i = 0; i < length(); i++) {
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2148
      int v = value(i);
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2149
      hash = (hash << 8) ^ v ^ (hash >> 5);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2150
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2151
    return (unsigned int)hash;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2152
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2153
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2154
  const char* as_string() {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2155
    stringStream st;
10254
406448a00c51 7071427: AdapterFingerPrint can hold 8 entries per int
never
parents: 10004
diff changeset
  2156
    st.print("0x");
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2157
    for (int i = 0; i < length(); i++) {
10254
406448a00c51 7071427: AdapterFingerPrint can hold 8 entries per int
never
parents: 10004
diff changeset
  2158
      st.print("%08x", value(i));
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2159
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2160
    return st.as_string();
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2161
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2162
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2163
  bool equals(AdapterFingerPrint* other) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2164
    if (other->_length != _length) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2165
      return false;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2166
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2167
    if (_length < 0) {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2168
      assert(_compact_int_count == 3, "else change next line");
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2169
      return _value._compact[0] == other->_value._compact[0] &&
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2170
             _value._compact[1] == other->_value._compact[1] &&
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2171
             _value._compact[2] == other->_value._compact[2];
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2172
    } else {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2173
      for (int i = 0; i < _length; i++) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2174
        if (_value._fingerprint[i] != other->_value._fingerprint[i]) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2175
          return false;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2176
        }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2177
      }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2178
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2179
    return true;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2180
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2181
};
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2182
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2183
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2184
// A hashtable mapping from AdapterFingerPrints to AdapterHandlerEntries
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2185
class AdapterHandlerTable : public BasicHashtable<mtCode> {
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2186
  friend class AdapterHandlerTableIterator;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2187
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2188
 private:
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2189
4904
186345703249 6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents: 4898
diff changeset
  2190
#ifndef PRODUCT
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2191
  static int _lookups; // number of calls to lookup
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2192
  static int _buckets; // number of buckets checked
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2193
  static int _equals;  // number of buckets checked with matching hash
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2194
  static int _hits;    // number of successful lookups
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2195
  static int _compact; // number of equals calls with compact signature
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2196
#endif
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2197
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2198
  AdapterHandlerEntry* bucket(int i) {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2199
    return (AdapterHandlerEntry*)BasicHashtable<mtCode>::bucket(i);
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2200
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2201
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2202
 public:
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2203
  AdapterHandlerTable()
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2204
    : BasicHashtable<mtCode>(293, sizeof(AdapterHandlerEntry)) { }
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2205
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2206
  // Create a new entry suitable for insertion in the table
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2207
  AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry, address c2i_unverified_entry) {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2208
    AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable<mtCode>::new_entry(fingerprint->compute_hash());
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2209
    entry->init(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2210
    return entry;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2211
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2212
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2213
  // Insert an entry into the table
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2214
  void add(AdapterHandlerEntry* entry) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2215
    int index = hash_to_index(entry->hash());
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2216
    add_entry(index, entry);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2217
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2218
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2219
  void free_entry(AdapterHandlerEntry* entry) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2220
    entry->deallocate();
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2221
    BasicHashtable<mtCode>::free_entry(entry);
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2222
  }
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2223
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2224
  // Find a entry with the same fingerprint if it exists
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2225
  AdapterHandlerEntry* lookup(int total_args_passed, BasicType* sig_bt) {
4904
186345703249 6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents: 4898
diff changeset
  2226
    NOT_PRODUCT(_lookups++);
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2227
    AdapterFingerPrint fp(total_args_passed, sig_bt);
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2228
    unsigned int hash = fp.compute_hash();
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2229
    int index = hash_to_index(hash);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2230
    for (AdapterHandlerEntry* e = bucket(index); e != NULL; e = e->next()) {
4904
186345703249 6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents: 4898
diff changeset
  2231
      NOT_PRODUCT(_buckets++);
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2232
      if (e->hash() == hash) {
4904
186345703249 6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents: 4898
diff changeset
  2233
        NOT_PRODUCT(_equals++);
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2234
        if (fp.equals(e->fingerprint())) {
4904
186345703249 6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents: 4898
diff changeset
  2235
#ifndef PRODUCT
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2236
          if (fp.is_compact()) _compact++;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2237
          _hits++;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2238
#endif
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2239
          return e;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2240
        }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2241
      }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2242
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2243
    return NULL;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2244
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2245
4904
186345703249 6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents: 4898
diff changeset
  2246
#ifndef PRODUCT
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2247
  void print_statistics() {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2248
    ResourceMark rm;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2249
    int longest = 0;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2250
    int empty = 0;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2251
    int total = 0;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2252
    int nonempty = 0;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2253
    for (int index = 0; index < table_size(); index++) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2254
      int count = 0;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2255
      for (AdapterHandlerEntry* e = bucket(index); e != NULL; e = e->next()) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2256
        count++;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2257
      }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2258
      if (count != 0) nonempty++;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2259
      if (count == 0) empty++;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2260
      if (count > longest) longest = count;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2261
      total += count;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2262
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2263
    tty->print_cr("AdapterHandlerTable: empty %d longest %d total %d average %f",
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2264
                  empty, longest, total, total / (double)nonempty);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2265
    tty->print_cr("AdapterHandlerTable: lookups %d buckets %d equals %d hits %d compact %d",
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2266
                  _lookups, _buckets, _equals, _hits, _compact);
4904
186345703249 6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents: 4898
diff changeset
  2267
  }
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2268
#endif
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2269
};
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2270
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2271
4904
186345703249 6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents: 4898
diff changeset
  2272
#ifndef PRODUCT
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2273
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2274
int AdapterHandlerTable::_lookups;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2275
int AdapterHandlerTable::_buckets;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2276
int AdapterHandlerTable::_equals;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2277
int AdapterHandlerTable::_hits;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2278
int AdapterHandlerTable::_compact;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2279
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
  2280
#endif
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
  2281
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2282
class AdapterHandlerTableIterator : public StackObj {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2283
 private:
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2284
  AdapterHandlerTable* _table;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2285
  int _index;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2286
  AdapterHandlerEntry* _current;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2287
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2288
  void scan() {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2289
    while (_index < _table->table_size()) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2290
      AdapterHandlerEntry* a = _table->bucket(_index);
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5686
diff changeset
  2291
      _index++;
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2292
      if (a != NULL) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2293
        _current = a;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2294
        return;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2295
      }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2296
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2297
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2298
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2299
 public:
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2300
  AdapterHandlerTableIterator(AdapterHandlerTable* table): _table(table), _index(0), _current(NULL) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2301
    scan();
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2302
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2303
  bool has_next() {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2304
    return _current != NULL;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2305
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2306
  AdapterHandlerEntry* next() {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2307
    if (_current != NULL) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2308
      AdapterHandlerEntry* result = _current;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2309
      _current = _current->next();
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2310
      if (_current == NULL) scan();
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2311
      return result;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2312
    } else {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2313
      return NULL;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2314
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2315
  }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2316
};
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2317
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2318
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2319
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2320
// Implementation of AdapterHandlerLibrary
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2321
AdapterHandlerTable* AdapterHandlerLibrary::_adapters = NULL;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2322
AdapterHandlerEntry* AdapterHandlerLibrary::_abstract_method_handler = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2323
const int AdapterHandlerLibrary_size = 16*K;
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2324
BufferBlob* AdapterHandlerLibrary::_buffer = NULL;
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2325
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2326
BufferBlob* AdapterHandlerLibrary::buffer_blob() {
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2327
  // Should be called only when AdapterHandlerLibrary_lock is active.
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2328
  if (_buffer == NULL) // Initialize lazily
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2329
      _buffer = BufferBlob::create("adapters", AdapterHandlerLibrary_size);
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2330
  return _buffer;
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2331
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2333
void AdapterHandlerLibrary::initialize() {
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2334
  if (_adapters != NULL) return;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2335
  _adapters = new AdapterHandlerTable();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2336
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
  // Create a special handler for abstract methods.  Abstract methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
  // are never compiled so an i2c entry is somewhat meaningless, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2339
  // fill it in with something appropriate just in case.  Pass handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2340
  // wrong method for the c2i transitions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2341
  address wrong_method = SharedRuntime::get_handle_wrong_method_stub();
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2342
  _abstract_method_handler = AdapterHandlerLibrary::new_entry(new AdapterFingerPrint(0, NULL),
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2343
                                                              StubRoutines::throw_AbstractMethodError_entry(),
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2344
                                                              wrong_method, wrong_method);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2345
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2346
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2347
AdapterHandlerEntry* AdapterHandlerLibrary::new_entry(AdapterFingerPrint* fingerprint,
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2348
                                                      address i2c_entry,
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2349
                                                      address c2i_entry,
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2350
                                                      address c2i_unverified_entry) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2351
  return _adapters->new_entry(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2352
}
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2353
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2354
AdapterHandlerEntry* AdapterHandlerLibrary::get_adapter(methodHandle method) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2355
  // Use customized signature handler.  Need to lock around updates to
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2356
  // the AdapterHandlerTable (it is not safe for concurrent readers
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2357
  // and a single writer: this could be fixed if it becomes a
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2358
  // problem).
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2360
  // Get the address of the ic_miss handlers before we grab the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
  // AdapterHandlerLibrary_lock. This fixes bug 6236259 which
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
  // was caused by the initialization of the stubs happening
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
  // while we held the lock and then notifying jvmti while
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2364
  // holding it. This just forces the initialization to be a little
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
  // earlier.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
  address ic_miss = SharedRuntime::get_ic_miss_stub();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
  assert(ic_miss != NULL, "must have handler");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2368
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2369
  ResourceMark rm;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2370
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2371
  NOT_PRODUCT(int insts_size);
5050
47ecd86932ce 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 5046
diff changeset
  2372
  AdapterBlob* B = NULL;
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2373
  AdapterHandlerEntry* entry = NULL;
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2374
  AdapterFingerPrint* fingerprint = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2375
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2376
    MutexLocker mu(AdapterHandlerLibrary_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2377
    // make sure data structure is initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2378
    initialize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2379
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2380
    if (method->is_abstract()) {
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2381
      return _abstract_method_handler;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2382
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2383
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2384
    // Fill in the signature array, for the calling-convention call.
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2385
    int total_args_passed = method->size_of_parameters(); // All args on stack
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2386
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2387
    BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2388
    VMRegPair* regs   = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2389
    int i = 0;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2390
    if (!method->is_static())  // Pass in receiver first
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2391
      sig_bt[i++] = T_OBJECT;
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2392
    for (SignatureStream ss(method->signature()); !ss.at_return_type(); ss.next()) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2393
      sig_bt[i++] = ss.type();  // Collect remaining bits of signature
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2394
      if (ss.type() == T_LONG || ss.type() == T_DOUBLE)
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2395
        sig_bt[i++] = T_VOID;   // Longs & doubles take 2 Java slots
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2396
    }
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2397
    assert(i == total_args_passed, "");
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2398
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2399
    // Lookup method signature's fingerprint
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2400
    entry = _adapters->lookup(total_args_passed, sig_bt);
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2401
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2402
#ifdef ASSERT
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2403
    AdapterHandlerEntry* shared_entry = NULL;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2404
    if (VerifyAdapterSharing && entry != NULL) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2405
      shared_entry = entry;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2406
      entry = NULL;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2407
    }
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2408
#endif
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2409
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2410
    if (entry != NULL) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2411
      return entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2412
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2413
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2414
    // Get a description of the compiled java calling convention and the largest used (VMReg) stack slot usage
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2415
    int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false);
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2416
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2417
    // Make a C heap allocated version of the fingerprint to store in the adapter
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2418
    fingerprint = new AdapterFingerPrint(total_args_passed, sig_bt);
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2419
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2420
    // Create I2C & C2I handlers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2421
5050
47ecd86932ce 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 5046
diff changeset
  2422
    BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2423
    if (buf != NULL) {
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2424
      CodeBuffer buffer(buf);
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2425
      short buffer_locs[20];
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2426
      buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs,
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2427
                                             sizeof(buffer_locs)/sizeof(relocInfo));
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2428
      MacroAssembler _masm(&buffer);
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2429
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2430
      entry = SharedRuntime::generate_i2c2i_adapters(&_masm,
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2431
                                                     total_args_passed,
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2432
                                                     comp_args_on_stack,
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2433
                                                     sig_bt,
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2434
                                                     regs,
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2435
                                                     fingerprint);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2436
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2437
#ifdef ASSERT
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2438
      if (VerifyAdapterSharing) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2439
        if (shared_entry != NULL) {
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2440
          assert(shared_entry->compare_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt),
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2441
                 "code must match");
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2442
          // Release the one just created and return the original
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2443
          _adapters->free_entry(entry);
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2444
          return shared_entry;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2445
        } else  {
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2446
          entry->save_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt);
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2447
        }
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2448
      }
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2449
#endif
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2450
5050
47ecd86932ce 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 5046
diff changeset
  2451
      B = AdapterBlob::create(&buffer);
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2452
      NOT_PRODUCT(insts_size = buffer.insts_size());
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2453
    }
201
7893b7ce2d8d 6650373: Assert in methodOopDesc::make_adapters()
kvn
parents: 189
diff changeset
  2454
    if (B == NULL) {
7893b7ce2d8d 6650373: Assert in methodOopDesc::make_adapters()
kvn
parents: 189
diff changeset
  2455
      // CodeCache is full, disable compilation
7893b7ce2d8d 6650373: Assert in methodOopDesc::make_adapters()
kvn
parents: 189
diff changeset
  2456
      // Ought to log this but compile log is only per compile thread
7893b7ce2d8d 6650373: Assert in methodOopDesc::make_adapters()
kvn
parents: 189
diff changeset
  2457
      // and we're some non descript Java thread.
4750
71fd601907dc 4360113: Evict nmethods when code cache gets full
kvn
parents: 4749
diff changeset
  2458
      MutexUnlocker mu(AdapterHandlerLibrary_lock);
71fd601907dc 4360113: Evict nmethods when code cache gets full
kvn
parents: 4749
diff changeset
  2459
      CompileBroker::handle_full_code_cache();
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2460
      return NULL; // Out of CodeCache space
201
7893b7ce2d8d 6650373: Assert in methodOopDesc::make_adapters()
kvn
parents: 189
diff changeset
  2461
    }
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2462
    entry->relocate(B->content_begin());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2463
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2464
    // debugging suppport
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2465
    if (PrintAdapterHandlers || PrintStubCode) {
13887
89b873bcc55b 7200163: add CodeComments functionality to assember stubs
kvn
parents: 13883
diff changeset
  2466
      ttyLocker ttyl;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2467
      entry->print_adapter_on(tty);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2468
      tty->print_cr("i2c argument handler #%d for: %s %s (%d bytes generated)",
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2469
                    _adapters->number_of_entries(), (method->is_static() ? "static" : "receiver"),
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2470
                    method->signature()->as_C_string(), insts_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2471
      tty->print_cr("c2i argument handler starts at %p",entry->get_c2i_entry());
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2472
      if (Verbose || PrintStubCode) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2473
        address first_pc = entry->base_address();
13887
89b873bcc55b 7200163: add CodeComments functionality to assember stubs
kvn
parents: 13883
diff changeset
  2474
        if (first_pc != NULL) {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2475
          Disassembler::decode(first_pc, first_pc + insts_size);
13887
89b873bcc55b 7200163: add CodeComments functionality to assember stubs
kvn
parents: 13883
diff changeset
  2476
          tty->cr();
89b873bcc55b 7200163: add CodeComments functionality to assember stubs
kvn
parents: 13883
diff changeset
  2477
        }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2478
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2479
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2480
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2481
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2482
    _adapters->add(entry);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2483
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2484
  // Outside of the lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2485
  if (B != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2486
    char blob_id[256];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2487
    jio_snprintf(blob_id,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2488
                 sizeof(blob_id),
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2489
                 "%s(%s)@" PTR_FORMAT,
5050
47ecd86932ce 6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents: 5046
diff changeset
  2490
                 B->name(),
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2491
                 fingerprint->as_string(),
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2492
                 B->content_begin());
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2493
    Forte::register_stub(blob_id, B->content_begin(), B->content_end());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2494
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2495
    if (JvmtiExport::should_post_dynamic_code_generated()) {
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2496
      JvmtiExport::post_dynamic_code_generated(blob_id, B->content_begin(), B->content_end());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2497
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2498
  }
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2499
  return entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2500
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2501
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2502
address AdapterHandlerEntry::base_address() {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2503
  address base = _i2c_entry;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2504
  if (base == NULL)  base = _c2i_entry;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2505
  assert(base <= _c2i_entry || _c2i_entry == NULL, "");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2506
  assert(base <= _c2i_unverified_entry || _c2i_unverified_entry == NULL, "");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2507
  return base;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2508
}
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2509
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2510
void AdapterHandlerEntry::relocate(address new_base) {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2511
  address old_base = base_address();
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2512
  assert(old_base != NULL, "");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2513
  ptrdiff_t delta = new_base - old_base;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2514
  if (_i2c_entry != NULL)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2515
    _i2c_entry += delta;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2516
  if (_c2i_entry != NULL)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
    _c2i_entry += delta;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2518
  if (_c2i_unverified_entry != NULL)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
    _c2i_unverified_entry += delta;
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2520
  assert(base_address() == new_base, "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2522
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2523
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2524
void AdapterHandlerEntry::deallocate() {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2525
  delete _fingerprint;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2526
#ifdef ASSERT
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2527
  if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code, mtCode);
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2528
  if (_saved_sig)  FREE_C_HEAP_ARRAY(Basictype, _saved_sig, mtCode);
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2529
#endif
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2530
}
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2531
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2532
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2533
#ifdef ASSERT
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2534
// Capture the code before relocation so that it can be compared
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2535
// against other versions.  If the code is captured after relocation
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2536
// then relative instructions won't be equivalent.
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2537
void AdapterHandlerEntry::save_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2538
  _saved_code = NEW_C_HEAP_ARRAY(unsigned char, length, mtCode);
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2539
  _code_length = length;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2540
  memcpy(_saved_code, buffer, length);
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2541
  _total_args_passed = total_args_passed;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2542
  _saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed, mtCode);
4755
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2543
  memcpy(_saved_sig, sig_bt, _total_args_passed * sizeof(BasicType));
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2544
}
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2545
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2546
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2547
bool AdapterHandlerEntry::compare_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2548
  if (length != _code_length) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2549
    return false;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2550
  }
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2551
  for (int i = 0; i < length; i++) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2552
    if (buffer[i] != _saved_code[i]) {
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2553
      return false;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2554
    }
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2555
  }
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2556
  return true;
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2557
}
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2558
#endif
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2559
eee57ea6d910 6921922: fix for 6911204 breaks tagged stack interpreter
never
parents: 4753
diff changeset
  2560
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2561
// Create a native wrapper for this native method.  The wrapper converts the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
// java compiled calling convention to the native convention, handlizes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
// arguments, and transitions to native.  On return from the native we transition
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
// back to java blocking if a safepoint is in progress.
8872
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8495
diff changeset
  2565
nmethod *AdapterHandlerLibrary::create_native_wrapper(methodHandle method, int compile_id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2566
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
  nmethod* nm = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2569
  assert(method->is_native(), "must be native");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2570
  assert(method->is_method_handle_intrinsic() ||
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2571
         method->has_native_function(), "must have something valid to call!");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
    // perform the work while holding the lock, but perform any printing outside the lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
    MutexLocker mu(AdapterHandlerLibrary_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
    // See if somebody beat us to it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
    nm = method->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
    if (nm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
      return nm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2580
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2581
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2582
    ResourceMark rm;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2584
    BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2585
    if (buf != NULL) {
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2586
      CodeBuffer buffer(buf);
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2587
      double locs_buf[20];
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2588
      buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2589
      MacroAssembler _masm(&buffer);
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2590
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2591
      // Fill in the signature array, for the calling-convention call.
13881
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  2592
      const int total_args_passed = method->size_of_parameters();
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  2593
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  2594
      BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed);
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  2595
      VMRegPair*   regs = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed);
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2596
      int i=0;
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2597
      if( !method->is_static() )  // Pass in receiver first
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2598
        sig_bt[i++] = T_OBJECT;
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2599
      SignatureStream ss(method->signature());
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2600
      for( ; !ss.at_return_type(); ss.next()) {
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2601
        sig_bt[i++] = ss.type();  // Collect remaining bits of signature
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2602
        if( ss.type() == T_LONG || ss.type() == T_DOUBLE )
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2603
          sig_bt[i++] = T_VOID;   // Longs & doubles take 2 Java slots
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2604
      }
13881
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  2605
      assert(i == total_args_passed, "");
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2606
      BasicType ret_type = ss.type();
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2607
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2608
      // Now get the compiled-Java layout as input (or output) arguments.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2609
      // NOTE: Stubs for compiled entry points of method handle intrinsics
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2610
      // are just trampolines so the argument registers must be outgoing ones.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2611
      const bool is_outgoing = method->is_method_handle_intrinsic();
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2612
      int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, is_outgoing);
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2613
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2614
      // Generate the compiled-to-native wrapper code
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2615
      nm = SharedRuntime::generate_native_wrapper(&_masm,
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2616
                                                  method,
8872
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8495
diff changeset
  2617
                                                  compile_id,
13881
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  2618
                                                  sig_bt,
a326d528f3e1 7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents: 13728
diff changeset
  2619
                                                  regs,
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2620
                                                  ret_type);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2621
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
  // Must unlock before calling set_code
6270
d628c75fbf48 6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents: 6176
diff changeset
  2625
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2626
  // Install the generated code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
  if (nm != NULL) {
8872
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8495
diff changeset
  2628
    if (PrintCompilation) {
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8495
diff changeset
  2629
      ttyLocker ttyl;
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8495
diff changeset
  2630
      CompileTask::print_compilation(tty, nm, method->is_static() ? "(static)" : "");
36680c58660e 7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents: 8495
diff changeset
  2631
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2632
    method->set_code(method, nm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2633
    nm->post_compiled_method_load_event();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2634
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2635
    // CodeCache is full, disable compilation
4750
71fd601907dc 4360113: Evict nmethods when code cache gets full
kvn
parents: 4749
diff changeset
  2636
    CompileBroker::handle_full_code_cache();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2637
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2638
  return nm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2639
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2640
11637
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2641
JRT_ENTRY_NO_ASYNC(void, SharedRuntime::block_for_jni_critical(JavaThread* thread))
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2642
  assert(thread == JavaThread::current(), "must be");
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2643
  // The code is about to enter a JNI lazy critical native method and
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2644
  // _needs_gc is true, so if this thread is already in a critical
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2645
  // section then just return, otherwise this thread should block
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2646
  // until needs_gc has been cleared.
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2647
  if (thread->in_critical()) {
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2648
    return;
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2649
  }
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2650
  // Lock and unlock a critical section to give the system a chance to block
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2651
  GC_locker::lock_critical(thread);
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2652
  GC_locker::unlock_critical(thread);
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2653
JRT_END
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11636
diff changeset
  2654
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2655
#ifdef HAVE_DTRACE_H
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2656
// Create a dtrace nmethod for this method.  The wrapper converts the
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2657
// java compiled calling convention to the native convention, makes a dummy call
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2658
// (actually nops for the size of the call instruction, which become a trap if
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2659
// probe is enabled). The returns to the caller. Since this all looks like a
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2660
// leaf no thread transition is needed.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2661
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2662
nmethod *AdapterHandlerLibrary::create_dtrace_nmethod(methodHandle method) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2663
  ResourceMark rm;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2664
  nmethod* nm = NULL;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2665
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2666
  if (PrintCompilation) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2667
    ttyLocker ttyl;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2668
    tty->print("---   n%s  ");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2669
    method->print_short_name(tty);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2670
    if (method->is_static()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2671
      tty->print(" (static)");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2672
    }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2673
    tty->cr();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2674
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2675
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2676
  {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2677
    // perform the work while holding the lock, but perform any printing
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2678
    // outside the lock
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2679
    MutexLocker mu(AdapterHandlerLibrary_lock);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2680
    // See if somebody beat us to it
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2681
    nm = method->code();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2682
    if (nm) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2683
      return nm;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2684
    }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2685
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2686
    ResourceMark rm;
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2687
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2688
    BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2689
    if (buf != NULL) {
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6270
diff changeset
  2690
      CodeBuffer buffer(buf);
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2691
      // Need a few relocation entries
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2692
      double locs_buf[20];
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2693
      buffer.insts()->initialize_shared_locs(
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2694
        (relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2695
      MacroAssembler _masm(&buffer);
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2696
2732
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2697
      // Generate the compiled-to-native wrapper code
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2698
      nm = SharedRuntime::generate_dtrace_nmethod(&_masm, method);
3ab85419f523 6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents: 2534
diff changeset
  2699
    }
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2700
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2701
  return nm;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2702
}
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2703
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2704
// the dtrace method needs to convert java lang string to utf8 string.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2705
void SharedRuntime::get_utf(oopDesc* src, address dst) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2706
  typeArrayOop jlsValue  = java_lang_String::value(src);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2707
  int          jlsOffset = java_lang_String::offset(src);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2708
  int          jlsLen    = java_lang_String::length(src);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2709
  jchar*       jlsPos    = (jlsLen == 0) ? NULL :
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2710
                                           jlsValue->char_at_addr(jlsOffset);
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13887
diff changeset
  2711
  assert(TypeArrayKlass::cast(jlsValue->klass())->element_type() == T_CHAR, "compressed string");
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2712
  (void) UNICODE::as_utf8(jlsPos, jlsLen, (char *)dst, max_dtrace_string_size);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2713
}
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2714
#endif // ndef HAVE_DTRACE_H
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 235
diff changeset
  2715
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
// -------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2717
// Java-Java calling convention
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
// (what you use when Java calls Java)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2720
//------------------------------name_for_receiver----------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2721
// For a given signature, return the VMReg for parameter 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2722
VMReg SharedRuntime::name_for_receiver() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2723
  VMRegPair regs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2724
  BasicType sig_bt = T_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2725
  (void) java_calling_convention(&sig_bt, &regs, 1, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
  // Return argument 0 register.  In the LP64 build pointers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
  // take 2 registers, but the VM wants only the 'main' name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
  return regs.first();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2729
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2730
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7913
diff changeset
  2731
VMRegPair *SharedRuntime::find_callee_arguments(Symbol* sig, bool has_receiver, int* arg_size) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2732
  // This method is returning a data structure allocating as a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2733
  // ResourceObject, so do not put any ResourceMarks in here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2734
  char *s = sig->as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2735
  int len = (int)strlen(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2736
  *s++; len--;                  // Skip opening paren
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2737
  char *t = s+len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2738
  while( *(--t) != ')' ) ;      // Find close paren
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2739
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2740
  BasicType *sig_bt = NEW_RESOURCE_ARRAY( BasicType, 256 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2741
  VMRegPair *regs = NEW_RESOURCE_ARRAY( VMRegPair, 256 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2742
  int cnt = 0;
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4564
diff changeset
  2743
  if (has_receiver) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2744
    sig_bt[cnt++] = T_OBJECT; // Receiver is argument 0; not in signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2745
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2746
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2747
  while( s < t ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2748
    switch( *s++ ) {            // Switch on signature character
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2749
    case 'B': sig_bt[cnt++] = T_BYTE;    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2750
    case 'C': sig_bt[cnt++] = T_CHAR;    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2751
    case 'D': sig_bt[cnt++] = T_DOUBLE;  sig_bt[cnt++] = T_VOID; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2752
    case 'F': sig_bt[cnt++] = T_FLOAT;   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2753
    case 'I': sig_bt[cnt++] = T_INT;     break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2754
    case 'J': sig_bt[cnt++] = T_LONG;    sig_bt[cnt++] = T_VOID; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2755
    case 'S': sig_bt[cnt++] = T_SHORT;   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2756
    case 'Z': sig_bt[cnt++] = T_BOOLEAN; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2757
    case 'V': sig_bt[cnt++] = T_VOID;    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2758
    case 'L':                   // Oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2759
      while( *s++ != ';'  ) ;   // Skip signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2760
      sig_bt[cnt++] = T_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2761
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2762
    case '[': {                 // Array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2763
      do {                      // Skip optional size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2764
        while( *s >= '0' && *s <= '9' ) s++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2765
      } while( *s++ == '[' );   // Nested arrays?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2766
      // Skip element type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2767
      if( s[-1] == 'L' )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2768
        while( *s++ != ';'  ) ; // Skip signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2769
      sig_bt[cnt++] = T_ARRAY;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2770
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2771
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2772
    default : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2773
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2774
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2775
  assert( cnt < 256, "grow table size" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2776
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2777
  int comp_args_on_stack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2778
  comp_args_on_stack = java_calling_convention(sig_bt, regs, cnt, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2779
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2780
  // the calling convention doesn't count out_preserve_stack_slots so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2781
  // we must add that in to get "true" stack offsets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2782
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2783
  if (comp_args_on_stack) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2784
    for (int i = 0; i < cnt; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2785
      VMReg reg1 = regs[i].first();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2786
      if( reg1->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2787
        // Yuck
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2788
        reg1 = reg1->bias(out_preserve_stack_slots());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2789
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2790
      VMReg reg2 = regs[i].second();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2791
      if( reg2->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2792
        // Yuck
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2793
        reg2 = reg2->bias(out_preserve_stack_slots());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2794
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2795
      regs[i].set_pair(reg2, reg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2796
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2797
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2798
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2799
  // results
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2800
  *arg_size = cnt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2801
  return regs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2802
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2803
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2804
// OSR Migration Code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2805
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2806
// This code is used convert interpreter frames into compiled frames.  It is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2807
// called from very start of a compiled OSR nmethod.  A temp array is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2808
// allocated to hold the interesting bits of the interpreter frame.  All
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2809
// active locks are inflated to allow them to move.  The displaced headers and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2810
// active interpeter locals are copied into the temp buffer.  Then we return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2811
// back to the compiled code.  The compiled code then pops the current
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2812
// interpreter frame off the stack and pushes a new compiled frame.  Then it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2813
// copies the interpreter locals and displaced headers where it wants.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2814
// Finally it calls back to free the temp buffer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2815
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2816
// All of this is done NOT at any Safepoint, nor is any safepoint or GC allowed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2817
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2818
JRT_LEAF(intptr_t*, SharedRuntime::OSR_migration_begin( JavaThread *thread) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2819
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2820
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2821
  // This code is dependent on the memory layout of the interpreter local
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2822
  // array and the monitors. On all of our platforms the layout is identical
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2823
  // so this code is shared. If some platform lays the their arrays out
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2824
  // differently then this code could move to platform specific code or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2825
  // the code here could be modified to copy items one at a time using
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2826
  // frame accessor methods and be platform independent.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2827
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2828
  frame fr = thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2829
  assert( fr.is_interpreted_frame(), "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2830
  assert( fr.interpreter_frame_expression_stack_size()==0, "only handle empty stacks" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2831
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2832
  // Figure out how many monitors are active.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2833
  int active_monitor_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2834
  for( BasicObjectLock *kptr = fr.interpreter_frame_monitor_end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2835
       kptr < fr.interpreter_frame_monitor_begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2836
       kptr = fr.next_monitor_in_interpreter_frame(kptr) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2837
    if( kptr->obj() != NULL ) active_monitor_count++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2838
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2839
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2840
  // QQQ we could place number of active monitors in the array so that compiled code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2841
  // could double check it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2842
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13396
diff changeset
  2843
  Method* moop = fr.interpreter_frame_method();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2844
  int max_locals = moop->max_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2845
  // Allocate temp buffer, 1 word per local & 2 per active monitor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2846
  int buf_size_words = max_locals + active_monitor_count*2;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2847
  intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words, mtCode);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2848
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2849
  // Copy the locals.  Order is preserved so that loading of longs works.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2850
  // Since there's no GC I can copy the oops blindly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2851
  assert( sizeof(HeapWord)==sizeof(intptr_t), "fix this code");
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 5334
diff changeset
  2852
  Copy::disjoint_words((HeapWord*)fr.interpreter_frame_local_at(max_locals-1),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2853
                       (HeapWord*)&buf[0],
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2854
                       max_locals);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2855
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2856
  // Inflate locks.  Copy the displaced headers.  Be careful, there can be holes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2857
  int i = max_locals;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2858
  for( BasicObjectLock *kptr2 = fr.interpreter_frame_monitor_end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2859
       kptr2 < fr.interpreter_frame_monitor_begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2860
       kptr2 = fr.next_monitor_in_interpreter_frame(kptr2) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2861
    if( kptr2->obj() != NULL) {         // Avoid 'holes' in the monitor array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2862
      BasicLock *lock = kptr2->lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2863
      // Inflate so the displaced header becomes position-independent
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2864
      if (lock->displaced_header()->is_unlocked())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2865
        ObjectSynchronizer::inflate_helper(kptr2->obj());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2866
      // Now the displaced header is free to move
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2867
      buf[i++] = (intptr_t)lock->displaced_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2868
      buf[i++] = (intptr_t)kptr2->obj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2869
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2870
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2871
  assert( i - max_locals == active_monitor_count*2, "found the expected number of monitors" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2872
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2873
  return buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2874
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2875
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2876
JRT_LEAF(void, SharedRuntime::OSR_migration_end( intptr_t* buf) )
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11788
diff changeset
  2877
  FREE_C_HEAP_ARRAY(intptr_t,buf, mtCode);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2878
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2879
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2880
bool AdapterHandlerLibrary::contains(CodeBlob* b) {
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2881
  AdapterHandlerTableIterator iter(_adapters);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2882
  while (iter.has_next()) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2883
    AdapterHandlerEntry* a = iter.next();
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2884
    if ( b == CodeCache::find_blob(a->get_i2c_entry()) ) return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2885
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2886
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2887
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2888
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
  2889
void AdapterHandlerLibrary::print_handler_on(outputStream* st, CodeBlob* b) {
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2890
  AdapterHandlerTableIterator iter(_adapters);
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2891
  while (iter.has_next()) {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2892
    AdapterHandlerEntry* a = iter.next();
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2893
    if (b == CodeCache::find_blob(a->get_i2c_entry())) {
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
  2894
      st->print("Adapter for signature: ");
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2895
      a->print_adapter_on(tty);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2896
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2897
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2898
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2899
  assert(false, "Should have found handler");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2900
}
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2901
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2902
void AdapterHandlerEntry::print_adapter_on(outputStream* st) const {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2903
  st->print_cr("AHE@" INTPTR_FORMAT ": %s i2c: " INTPTR_FORMAT " c2i: " INTPTR_FORMAT " c2iUV: " INTPTR_FORMAT,
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2904
               (intptr_t) this, fingerprint()->as_string(),
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2905
               get_i2c_entry(), get_c2i_entry(), get_c2i_unverified_entry());
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2906
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2907
}
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13195
diff changeset
  2908
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
  2909
#ifndef PRODUCT
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5924
diff changeset
  2910
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2911
void AdapterHandlerLibrary::print_statistics() {
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2912
  _adapters->print_statistics();
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2913
}
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4571
diff changeset
  2914
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2915
#endif /* PRODUCT */